diff --git a/stage0/src/Init/Lean/Elab/Quotation.lean b/stage0/src/Init/Lean/Elab/Quotation.lean
index 900f530950..8515ab3a1e 100644
--- a/stage0/src/Init/Lean/Elab/Quotation.lean
+++ b/stage0/src/Init/Lean/Elab/Quotation.lean
@@ -426,7 +426,7 @@ def oldParseExpr (env : Environment) (input : String) (pos : String.Pos) : Excep
 let c := Parser.mkParserContext env (Parser.mkInputContext input "<foo>");
 let s := Parser.mkParserState c.input;
 let s := s.setPos pos;
-let s := (Parser.termParser Parser.appPrec : Parser.Parser).fn Parser.appPrec c s;
+let s := (Parser.termParser Parser.appPrec : Parser.Parser).fn { rbp := Parser.appPrec, .. c } s;
 let stx := s.stxStack.back;
 match s.errorMsg with
 | some errorMsg =>
diff --git a/stage0/src/Init/Lean/Parser/Command.lean b/stage0/src/Init/Lean/Parser/Command.lean
index cfd18a8223..a888614230 100644
--- a/stage0/src/Init/Lean/Parser/Command.lean
+++ b/stage0/src/Init/Lean/Parser/Command.lean
@@ -15,7 +15,7 @@ registerBuiltinParserAttribute `builtinCommandParser `command
 @[init] def regCommandParserAttribute : IO Unit :=
 registerBuiltinDynamicParserAttribute `commandParser `command
 
-@[inline] def commandParser {k : ParserKind} (rbp : Nat := 0) : Parser k :=
+@[inline] def commandParser (rbp : Nat := 0) : Parser :=
 categoryParser `command rbp
 
 /--
@@ -28,7 +28,7 @@ categoryParser `command rbp
 
 namespace Command
 def commentBody : Parser :=
-{ fn := rawFn (fun _ => finishCommentBlock 1) true }
+{ fn := rawFn (finishCommentBlock 1) true }
 
 def docComment       := parser! "/--" >> commentBody
 def attrArg : Parser := ident <|> strLit <|> numLit
diff --git a/stage0/src/Init/Lean/Parser/Level.lean b/stage0/src/Init/Lean/Parser/Level.lean
index c5c2a2f51d..dc71411c0b 100644
--- a/stage0/src/Init/Lean/Parser/Level.lean
+++ b/stage0/src/Init/Lean/Parser/Level.lean
@@ -12,7 +12,7 @@ namespace Parser
 @[init] def regBuiltinLevelParserAttr : IO Unit :=
 registerBuiltinParserAttribute `builtinLevelParser `level
 
-@[inline] def levelParser {k : ParserKind} (rbp : Nat := 0) : Parser k :=
+@[inline] def levelParser (rbp : Nat := 0) : Parser :=
 categoryParser `level rbp
 
 namespace Level
diff --git a/stage0/src/Init/Lean/Parser/Module.lean b/stage0/src/Init/Lean/Parser/Module.lean
index fda6197cf1..439db6474d 100644
--- a/stage0/src/Init/Lean/Parser/Module.lean
+++ b/stage0/src/Init/Lean/Parser/Module.lean
@@ -39,7 +39,7 @@ let ctx := mkParserContext env inputCtx;
 let ctx := Module.updateTokens ctx;
 let s   := mkParserState ctx.input;
 let s   := whitespace ctx s;
-let s   := Module.header.fn (0:Nat) ctx s;
+let s   := Module.header.fn ctx s;
 let stx := s.stxStack.back;
 match s.errorMsg with
 | some errorMsg =>
@@ -73,7 +73,7 @@ partial def parseCommand (env : Environment) (inputCtx : InputContext) : ModuleP
     let c  := mkParserContext env inputCtx;
     let s  := { ParserState . cache := initCacheForInput c.input, pos := pos };
     let s  := whitespace c s;
-    let s  := (commandParser : Parser).fn (0:Nat) c s;
+    let s  := (commandParser : Parser).fn c s;
     match s.errorMsg with
     | none =>
       let stx := s.stxStack.back;
diff --git a/stage0/src/Init/Lean/Parser/Parser.lean b/stage0/src/Init/Lean/Parser/Parser.lean
index f375d37019..d6d12610ac 100644
--- a/stage0/src/Init/Lean/Parser/Parser.lean
+++ b/stage0/src/Init/Lean/Parser/Parser.lean
@@ -91,6 +91,7 @@ instance InputContext.inhabited : Inhabited InputContext :=
 ⟨{ input := "", fileName := "", fileMap := arbitrary _ }⟩
 
 structure ParserContext extends InputContext :=
+(rbp      : Nat)
 (env      : Environment)
 (tokens   : TokenTable)
 
@@ -212,17 +213,9 @@ match s with
 
 end ParserState
 
-def ParserArg : ParserKind → Type
-| ParserKind.leading  => Nat
-| ParserKind.trailing => Unit
+def ParserFn := ParserContext → ParserState → ParserState
 
-export ParserKind (leading trailing)
-
-def BasicParserFn := ParserContext → ParserState → ParserState
-
-def ParserFn (k : ParserKind) := ParserArg k → BasicParserFn
-
-instance ParserFn.inhabited (k : ParserKind) : Inhabited (ParserFn k) := ⟨fun _ _ => id⟩
+instance ParserFn.inhabited : Inhabited ParserFn := ⟨fun _ => id⟩
 
 inductive FirstTokens
 | epsilon   : FirstTokens
@@ -266,79 +259,75 @@ structure ParserInfo :=
 (collectKinds  : SyntaxNodeKindSet → SyntaxNodeKindSet := id)
 (firstTokens   : FirstTokens                           := FirstTokens.unknown)
 
-structure Parser (k : ParserKind := leading) :=
+structure Parser :=
 (info : ParserInfo := {})
-(fn   : ParserFn k)
+(fn   : ParserFn)
 
-instance Parser.inhabited {k : ParserKind} : Inhabited (Parser k) :=
-⟨{ fn := fun _ _ s => s }⟩
+instance Parser.inhabited : Inhabited Parser :=
+⟨{ fn := fun _ s => s }⟩
 
-abbrev TrailingParser := Parser trailing
+abbrev TrailingParser := Parser
 
 @[noinline] def epsilonInfo : ParserInfo :=
 { firstTokens := FirstTokens.epsilon }
 
-@[inline] def toTrailing (p : Parser) (rbp : Nat := 0) : TrailingParser :=
-{ info := p.info,
-  fn   := fun a => p.fn rbp }
-
-@[inline] def checkLeadingFn (p : Syntax → Bool) : ParserFn trailing :=
-fun _ c s =>
+@[inline] def checkStackTopFn (p : Syntax → Bool) : ParserFn :=
+fun c s =>
   if p s.stxStack.back then s
   else s.mkUnexpectedError "invalid leading token"
 
-@[inline] def checkLeading (p : Syntax → Bool) : TrailingParser :=
+@[inline] def checkStackTop (p : Syntax → Bool) : Parser :=
 { info := epsilonInfo,
-  fn   := checkLeadingFn p }
+  fn   := checkStackTopFn p }
 
-@[inline] def andthenAux (p q : BasicParserFn) : BasicParserFn :=
+@[inline] def andthenFn (p q : ParserFn) : ParserFn :=
 fun c s =>
   let s := p c s;
   if s.hasError then s else q c s
 
-@[inline] def andthenFn {k : ParserKind} (p q : ParserFn k) : ParserFn k :=
-fun a c s => andthenAux (p a) (q a) c s
-
 @[noinline] def andthenInfo (p q : ParserInfo) : ParserInfo :=
 { collectTokens := p.collectTokens ∘ q.collectTokens,
   collectKinds  := p.collectKinds ∘ q.collectKinds,
   firstTokens   := p.firstTokens.seq q.firstTokens }
 
-@[inline] def andthen {k : ParserKind} (p q : Parser k) : Parser k :=
+@[inline] def andthen (p q : Parser) : Parser :=
 { info := andthenInfo p.info q.info,
   fn   := andthenFn p.fn q.fn }
 
-instance hashAndthen {k : ParserKind} : HasAndthen (Parser k) :=
+instance hashAndthen : HasAndthen Parser :=
 ⟨andthen⟩
 
-@[inline] def nodeFn {k : ParserKind} (n : SyntaxNodeKind) (p : ParserFn k) : ParserFn k
-| a, c, s =>
+@[inline] def nodeFn (n : SyntaxNodeKind) (p : ParserFn) : ParserFn
+| c, s =>
   let iniSz := s.stackSize;
-  let s     := p a c s;
-  match k with
-  | ParserKind.trailing => s.mkTrailingNode n iniSz
-  | ParserKind.leading  => s.mkNode n iniSz
+  let s     := p c s;
+  s.mkNode n iniSz
+
+@[inline] def trailingNodeFn (n : SyntaxNodeKind) (p : ParserFn) : ParserFn
+| c, s =>
+  let iniSz := s.stackSize;
+  let s     := p c s;
+  s.mkTrailingNode n iniSz
 
 @[noinline] def nodeInfo (n : SyntaxNodeKind) (p : ParserInfo) : ParserInfo :=
 { collectTokens := p.collectTokens,
   collectKinds  := fun s => (p.collectKinds s).insert n,
   firstTokens   := p.firstTokens }
 
-@[inline] def node {k : ParserKind} (n : SyntaxNodeKind) (p : Parser k) : Parser k :=
+@[inline] def node (n : SyntaxNodeKind) (p : Parser) : Parser :=
 { info := nodeInfo n p.info,
-  /- Remark: the compiler currently does not eta-expand structure fields.
-     So, we force it here to trigger inlining at `node` combinators. -/
   fn   := nodeFn n p.fn }
 
-@[inline] def group {k : ParserKind} (p : Parser k) : Parser k :=
+@[inline] def leadingNode (n : SyntaxNodeKind) (p : Parser) : Parser :=
+node n p
+
+@[inline] def trailingNode (n : SyntaxNodeKind) (p : Parser) : TrailingParser :=
+{ info := nodeInfo n p.info,
+  fn   := trailingNodeFn n p.fn }
+
+@[inline] def group (p : Parser) : Parser :=
 node nullKind p
 
-@[inline] def leadingNode (n : SyntaxNodeKind) (p : Parser leading) : Parser :=
-node n p
-
-@[inline] def trailingNode (n : SyntaxNodeKind) (p : Parser trailing) : TrailingParser :=
-node n p
-
 def mergeOrElseErrors (s : ParserState) (error1 : Error) (iniPos : Nat) : ParserState :=
 match s with
 | ⟨stack, pos, cache, some error2⟩ =>
@@ -346,15 +335,15 @@ match s with
   else s
 | other => other
 
-@[inline] def orelseFn {k : ParserKind} (p q : ParserFn k) : ParserFn k
-| a, c, s =>
+@[inline] def orelseFn (p q : ParserFn) : ParserFn
+| c, s =>
   let iniSz  := s.stackSize;
   let iniPos := s.pos;
-  let s      := p a c s;
+  let s      := p c s;
   match s.errorMsg with
   | some errorMsg =>
     if s.pos == iniPos then
-      mergeOrElseErrors (q a c (s.restore iniSz iniPos)) errorMsg iniPos
+      mergeOrElseErrors (q c (s.restore iniSz iniPos)) errorMsg iniPos
     else
       s
   | none => s
@@ -364,34 +353,34 @@ match s with
   collectKinds  := p.collectKinds ∘ q.collectKinds,
   firstTokens   := p.firstTokens.merge q.firstTokens }
 
-@[inline] def orelse {k : ParserKind} (p q : Parser k) : Parser k :=
+@[inline] def orelse (p q : Parser) : Parser :=
 { info := orelseInfo p.info q.info,
   fn   := orelseFn p.fn q.fn }
 
-instance hashOrelse {k : ParserKind} : HasOrelse (Parser k) :=
+instance hashOrelse : HasOrelse Parser :=
 ⟨orelse⟩
 
 @[noinline] def noFirstTokenInfo (info : ParserInfo) : ParserInfo :=
 { collectTokens := info.collectTokens,
   collectKinds  := info.collectKinds }
 
-@[inline] def tryFn {k : ParserKind} (p : ParserFn k ) : ParserFn k
-| a, c, s =>
+@[inline] def tryFn (p : ParserFn) : ParserFn
+| c, s =>
   let iniSz  := s.stackSize;
   let iniPos := s.pos;
-  match p a c s with
+  match p c s with
   | ⟨stack, _, cache, some msg⟩ => ⟨stack.shrink iniSz, iniPos, cache, some msg⟩
   | other                       => other
 
-@[inline] def try {k : ParserKind} (p : Parser k) : Parser k :=
+@[inline] def try (p : Parser) : Parser :=
 { info := p.info,
   fn   := tryFn p.fn }
 
-@[inline] def optionalFn {k : ParserKind} (p : ParserFn k) : ParserFn k :=
-fun a c s =>
+@[inline] def optionalFn (p : ParserFn) : ParserFn :=
+fun c s =>
   let iniSz  := s.stackSize;
   let iniPos := s.pos;
-  let s      := p a c s;
+  let s      := p c s;
   let s      := if s.hasError && s.pos == iniPos then s.restore iniSz iniPos else s;
   s.mkNode nullKind iniSz
 
@@ -400,60 +389,60 @@ fun a c s =>
   collectKinds  := p.collectKinds,
   firstTokens   := p.firstTokens.toOptional }
 
-@[inline] def optional {k : ParserKind} (p : Parser k) : Parser k :=
+@[inline] def optional (p : Parser) : Parser :=
 { info := optionaInfo p.info,
   fn   := optionalFn p.fn }
 
-@[inline] def lookaheadFn {k : ParserKind} (p : ParserFn k) : ParserFn k :=
-fun a c s =>
+@[inline] def lookaheadFn (p : ParserFn) : ParserFn :=
+fun c s =>
   let iniSz  := s.stackSize;
   let iniPos := s.pos;
-  let s      := p a c s;
+  let s      := p c s;
   if s.hasError then s else s.restore iniSz iniPos
 
-@[inline] def lookahead {k : ParserKind} (p : Parser k) : Parser k :=
+@[inline] def lookahead (p : Parser) : Parser :=
 { info := p.info,
   fn   := lookaheadFn p.fn }
 
-@[specialize] partial def manyAux {k : ParserKind} (p : ParserFn k) : ParserFn k
-| a, c, s =>
+@[specialize] partial def manyAux (p : ParserFn) : ParserFn
+| c, s =>
   let iniSz  := s.stackSize;
   let iniPos := s.pos;
-  let s      := p a c s;
+  let s      := p c s;
   if s.hasError then
     if iniPos == s.pos then s.restore iniSz iniPos else s
   else if iniPos == s.pos then s.mkUnexpectedError "invalid 'many' parser combinator application, parser did not consume anything"
-  else manyAux a c s
+  else manyAux c s
 
-@[inline] def manyFn {k : ParserKind} (p : ParserFn k) : ParserFn k :=
-fun a c s =>
+@[inline] def manyFn (p : ParserFn) : ParserFn :=
+fun c s =>
   let iniSz  := s.stackSize;
-  let s := manyAux p a c s;
+  let s := manyAux p c s;
   s.mkNode nullKind iniSz
 
-@[inline] def many {k : ParserKind} (p : Parser k) : Parser k :=
+@[inline] def many (p : Parser) : Parser :=
 { info := noFirstTokenInfo p.info,
   fn   := manyFn p.fn }
 
-@[inline] def many1Fn {k : ParserKind} (p : ParserFn k) (unboxSingleton : Bool) : ParserFn k :=
-fun a c s =>
+@[inline] def many1Fn (p : ParserFn) (unboxSingleton : Bool) : ParserFn :=
+fun c s =>
   let iniSz  := s.stackSize;
-  let s := andthenFn p (manyAux p) a c s;
+  let s := andthenFn p (manyAux p) c s;
   if s.stackSize - iniSz == 1 && unboxSingleton then
     s
   else
     s.mkNode nullKind iniSz
 
-@[inline] def many1 {k : ParserKind} (p : Parser k) (unboxSingleton := false) : Parser k :=
+@[inline] def many1 (p : Parser) (unboxSingleton := false) : Parser :=
 { info := p.info,
   fn   := many1Fn p.fn unboxSingleton }
 
-@[specialize] private partial def sepByFnAux {k : ParserKind} (p : ParserFn k) (sep : ParserFn k) (allowTrailingSep : Bool)
-    (iniSz : Nat) (unboxSingleton : Bool)  : Bool → ParserFn k
-| pOpt, a, c, s =>
+@[specialize] private partial def sepByFnAux (p : ParserFn) (sep : ParserFn) (allowTrailingSep : Bool)
+    (iniSz : Nat) (unboxSingleton : Bool)  : Bool → ParserFn
+| pOpt, c, s =>
   let sz  := s.stackSize;
   let pos := s.pos;
-  let s   := p a c s;
+  let s   := p c s;
   if s.hasError then
     if pOpt then
       let s := s.restore sz pos;
@@ -468,7 +457,7 @@ fun a c s =>
   else
     let sz  := s.stackSize;
     let pos := s.pos;
-    let s   := sep a c s;
+    let s   := sep c s;
     if s.hasError then
       let s := s.restore sz pos;
       if s.stackSize - iniSz == 1 && unboxSingleton then
@@ -476,17 +465,17 @@ fun a c s =>
       else
         s.mkNode nullKind iniSz
     else
-      sepByFnAux allowTrailingSep a c s
+      sepByFnAux allowTrailingSep c s
 
-@[specialize] def sepByFn {k : ParserKind} (allowTrailingSep : Bool) (p : ParserFn k) (sep : ParserFn k) : ParserFn k
-| a, c, s =>
+@[specialize] def sepByFn (allowTrailingSep : Bool) (p : ParserFn) (sep : ParserFn) : ParserFn
+| c, s =>
   let iniSz := s.stackSize;
-  sepByFnAux p sep allowTrailingSep iniSz false true a c s
+  sepByFnAux p sep allowTrailingSep iniSz false true c s
 
-@[specialize] def sepBy1Fn {k : ParserKind} (allowTrailingSep : Bool) (p : ParserFn k) (sep : ParserFn k) (unboxSingleton : Bool) : ParserFn k
-| a, c, s =>
+@[specialize] def sepBy1Fn (allowTrailingSep : Bool) (p : ParserFn) (sep : ParserFn) (unboxSingleton : Bool) : ParserFn
+| c, s =>
   let iniSz := s.stackSize;
-  sepByFnAux p sep allowTrailingSep iniSz unboxSingleton false a c s
+  sepByFnAux p sep allowTrailingSep iniSz unboxSingleton false c s
 
 @[noinline] def sepByInfo (p sep : ParserInfo) : ParserInfo :=
 { collectTokens := p.collectTokens ∘ sep.collectTokens,
@@ -497,35 +486,35 @@ fun a c s =>
   collectKinds  := p.collectKinds ∘ sep.collectKinds,
   firstTokens   := p.firstTokens }
 
-@[inline] def sepBy {k : ParserKind} (p sep : Parser k) (allowTrailingSep : Bool := false) : Parser k :=
+@[inline] def sepBy (p sep : Parser) (allowTrailingSep : Bool := false) : Parser :=
 { info := sepByInfo p.info sep.info,
   fn   := sepByFn allowTrailingSep p.fn sep.fn }
 
-@[inline] def sepBy1 {k : ParserKind} (p sep : Parser k) (allowTrailingSep : Bool := false) (unboxSingleton := false) : Parser k :=
+@[inline] def sepBy1 (p sep : Parser) (allowTrailingSep : Bool := false) (unboxSingleton := false) : Parser :=
 { info := sepBy1Info p.info sep.info,
   fn   := sepBy1Fn allowTrailingSep p.fn sep.fn unboxSingleton }
 
-@[specialize] partial def satisfyFn (p : Char → Bool) (errorMsg : String := "unexpected character") : BasicParserFn
+@[specialize] partial def satisfyFn (p : Char → Bool) (errorMsg : String := "unexpected character") : ParserFn
 | c, s =>
   let i := s.pos;
   if c.input.atEnd i then s.mkEOIError
   else if p (c.input.get i) then s.next c.input i
   else s.mkUnexpectedError errorMsg
 
-@[specialize] partial def takeUntilFn (p : Char → Bool) : BasicParserFn
+@[specialize] partial def takeUntilFn (p : Char → Bool) : ParserFn
 | c, s =>
   let i := s.pos;
   if c.input.atEnd i then s
   else if p (c.input.get i) then s
   else takeUntilFn c (s.next c.input i)
 
-@[specialize] def takeWhileFn (p : Char → Bool) : BasicParserFn :=
+@[specialize] def takeWhileFn (p : Char → Bool) : ParserFn :=
 takeUntilFn (fun c => !p c)
 
-@[inline] def takeWhile1Fn (p : Char → Bool) (errorMsg : String) : BasicParserFn :=
-andthenAux (satisfyFn p errorMsg) (takeWhileFn p)
+@[inline] def takeWhile1Fn (p : Char → Bool) (errorMsg : String) : ParserFn :=
+andthenFn (satisfyFn p errorMsg) (takeWhileFn p)
 
-partial def finishCommentBlock : Nat → BasicParserFn
+partial def finishCommentBlock : Nat → ParserFn
 | nesting, c, s =>
   let input := c.input;
   let i     := s.pos;
@@ -551,7 +540,7 @@ partial def finishCommentBlock : Nat → BasicParserFn
     else finishCommentBlock nesting c (s.setPos i)
 
 /- Consume whitespace and comments -/
-partial def whitespace : BasicParserFn
+partial def whitespace : ParserFn
 | c, s =>
   let input := c.input;
   let i     := s.pos;
@@ -562,7 +551,7 @@ partial def whitespace : BasicParserFn
     else if curr == '-' then
       let i    := input.next i;
       let curr := input.get i;
-      if curr == '-' then andthenAux (takeUntilFn (fun c => c = '\n')) whitespace c (s.next input i)
+      if curr == '-' then andthenFn (takeUntilFn (fun c => c = '\n')) whitespace c (s.next input i)
       else s
     else if curr == '/' then
       let i    := input.next i;
@@ -571,15 +560,15 @@ partial def whitespace : BasicParserFn
         let i    := input.next i;
         let curr := input.get i;
         if curr == '-' then s -- "/--" doc comment is an actual token
-        else andthenAux (finishCommentBlock 1) whitespace c (s.next input i)
+        else andthenFn (finishCommentBlock 1) whitespace c (s.next input i)
       else s
     else s
 
 def mkEmptySubstringAt (s : String) (p : Nat) : Substring :=
 {str := s, startPos := p, stopPos := p }
 
-private def rawAux {k : ParserKind} (startPos : Nat) (trailingWs : Bool) : ParserFn k
-| a, c, s =>
+private def rawAux (startPos : Nat) (trailingWs : Bool) : ParserFn
+| c, s =>
   let input   := c.input;
   let stopPos := s.pos;
   let leading := mkEmptySubstringAt input startPos;
@@ -596,19 +585,19 @@ private def rawAux {k : ParserKind} (startPos : Nat) (trailingWs : Bool) : Parse
     s.pushSyntax atom
 
 /-- Match an arbitrary Parser and return the consumed String in a `Syntax.atom`. -/
-@[inline] def rawFn {k : ParserKind} (p : ParserFn k) (trailingWs := false) : ParserFn k
-| a, c, s =>
+@[inline] def rawFn (p : ParserFn) (trailingWs := false) : ParserFn
+| c, s =>
   let startPos := s.pos;
-  let s := p a c s;
-  if s.hasError then s else rawAux startPos trailingWs a c s
+  let s := p c s;
+  if s.hasError then s else rawAux startPos trailingWs c s
 
-@[inline] def chFn {k : ParserKind} (c : Char) (trailingWs := false) : ParserFn k :=
-rawFn (fun _ => satisfyFn (fun d => c == d) ("'" ++ toString c ++ "'")) trailingWs
+@[inline] def chFn (c : Char) (trailingWs := false) : ParserFn :=
+rawFn (satisfyFn (fun d => c == d) ("'" ++ toString c ++ "'")) trailingWs
 
-def rawCh {k : ParserKind} (c : Char) (trailingWs := false) : Parser k :=
+def rawCh (c : Char) (trailingWs := false) : Parser :=
 { fn := chFn c trailingWs }
 
-def hexDigitFn : BasicParserFn
+def hexDigitFn : ParserFn
 | c, s =>
   let input := c.input;
   let i     := s.pos;
@@ -619,7 +608,7 @@ def hexDigitFn : BasicParserFn
     if curr.isDigit || ('a' <= curr && curr <= 'f') || ('A' <= curr && curr <= 'F') then s.setPos i
     else s.mkUnexpectedError "invalid hexadecimal numeral"
 
-def quotedCharFn : BasicParserFn
+def quotedCharFn : ParserFn
 | c, s =>
   let input := c.input;
   let i     := s.pos;
@@ -629,14 +618,14 @@ def quotedCharFn : BasicParserFn
     if curr == '\\' || curr == '\"' || curr == '\'' || curr == 'n' || curr == 't' then
       s.next input i
     else if curr == 'x' then
-      andthenAux hexDigitFn hexDigitFn c (s.next input i)
+      andthenFn hexDigitFn hexDigitFn c (s.next input i)
     else if curr == 'u' then
-      andthenAux hexDigitFn (andthenAux hexDigitFn (andthenAux hexDigitFn hexDigitFn)) c (s.next input i)
+      andthenFn hexDigitFn (andthenFn hexDigitFn (andthenFn hexDigitFn hexDigitFn)) c (s.next input i)
     else
       s.mkUnexpectedError "invalid escape sequence"
 
 /-- Push `(Syntax.node tk <new-atom>)` into syntax stack -/
-def mkNodeToken (n : SyntaxNodeKind) (startPos : Nat) : BasicParserFn :=
+def mkNodeToken (n : SyntaxNodeKind) (startPos : Nat) : ParserFn :=
 fun c s =>
 let input     := c.input;
 let stopPos   := s.pos;
@@ -648,7 +637,7 @@ let trailing  := { Substring . str := input, startPos := stopPos, stopPos := wsS
 let info      := { SourceInfo . leading := leading, pos := startPos, trailing := trailing };
 s.pushSyntax (mkStxLit n val (some info))
 
-def charLitFnAux (startPos : Nat) : BasicParserFn
+def charLitFnAux (startPos : Nat) : ParserFn
 | c, s =>
   let input := c.input;
   let i     := s.pos;
@@ -665,7 +654,7 @@ def charLitFnAux (startPos : Nat) : BasicParserFn
       if curr == '\'' then mkNodeToken charLitKind startPos c s
       else s.mkUnexpectedError "missing end of character literal"
 
-partial def strLitFnAux (startPos : Nat) : BasicParserFn
+partial def strLitFnAux (startPos : Nat) : ParserFn
 | c, s =>
   let input := c.input;
   let i     := s.pos;
@@ -675,10 +664,10 @@ partial def strLitFnAux (startPos : Nat) : BasicParserFn
     let s    := s.setPos (input.next i);
     if curr == '\"' then
       mkNodeToken strLitKind startPos c s
-    else if curr == '\\' then andthenAux quotedCharFn strLitFnAux c s
+    else if curr == '\\' then andthenFn quotedCharFn strLitFnAux c s
     else strLitFnAux c s
 
-def decimalNumberFn (startPos : Nat) : BasicParserFn :=
+def decimalNumberFn (startPos : Nat) : ParserFn :=
 fun c s =>
   let s     := takeWhileFn (fun c => c.isDigit) c s;
   let input := c.input;
@@ -695,22 +684,22 @@ fun c s =>
     else s;
   mkNodeToken numLitKind startPos c s
 
-def binNumberFn (startPos : Nat) : BasicParserFn :=
+def binNumberFn (startPos : Nat) : ParserFn :=
 fun c s =>
   let s := takeWhile1Fn (fun c => c == '0' || c == '1') "binary number" c s;
   mkNodeToken numLitKind startPos c s
 
-def octalNumberFn (startPos : Nat) : BasicParserFn :=
+def octalNumberFn (startPos : Nat) : ParserFn :=
 fun c s =>
   let s := takeWhile1Fn (fun c => '0' ≤ c && c ≤ '7') "octal number" c s;
   mkNodeToken numLitKind startPos c s
 
-def hexNumberFn (startPos : Nat) : BasicParserFn :=
+def hexNumberFn (startPos : Nat) : ParserFn :=
 fun c s =>
   let s := takeWhile1Fn (fun c => ('0' ≤ c && c ≤ '9') || ('a' ≤ c && c ≤ 'f') || ('A' ≤ c && c ≤ 'F')) "hexadecimal number" c s;
   mkNodeToken numLitKind startPos c s
 
-def numberFnAux : BasicParserFn :=
+def numberFnAux : ParserFn :=
 fun c s =>
   let input    := c.input;
   let startPos := s.pos;
@@ -755,7 +744,7 @@ match tk with
    -- we want it to be recognized as a symbol
   tk.val.bsize ≥ idStopPos - idStartPos
 
-def mkTokenAndFixPos (startPos : Nat) (tk : Option TokenConfig) : BasicParserFn :=
+def mkTokenAndFixPos (startPos : Nat) (tk : Option TokenConfig) : ParserFn :=
 fun c s =>
 match tk with
 | none    => s.mkErrorAt "token" startPos
@@ -771,7 +760,7 @@ match tk with
   let atom      := mkAtom { leading := leading, pos := startPos, trailing := trailing } val;
   s.pushSyntax atom
 
-def mkIdResult (startPos : Nat) (tk : Option TokenConfig) (val : Name) : BasicParserFn :=
+def mkIdResult (startPos : Nat) (tk : Option TokenConfig) (val : Name) : ParserFn :=
 fun c s =>
 let stopPos           := s.pos;
 if isToken startPos stopPos tk then
@@ -787,7 +776,7 @@ else
   let atom            := mkIdent info rawVal val;
   s.pushSyntax atom
 
-partial def identFnAux (startPos : Nat) (tk : Option TokenConfig) : Name → BasicParserFn
+partial def identFnAux (startPos : Nat) (tk : Option TokenConfig) : Name → ParserFn
 | r, c, s =>
   let input := c.input;
   let i     := s.pos;
@@ -823,7 +812,7 @@ partial def identFnAux (startPos : Nat) (tk : Option TokenConfig) : Name → Bas
 private def isIdFirstOrBeginEscape (c : Char) : Bool :=
 isIdFirst c || isIdBeginEscape c
 
-private def nameLitAux (startPos : Nat) : BasicParserFn
+private def nameLitAux (startPos : Nat) : ParserFn
 | c, s =>
   let input := c.input;
   let s     := identFnAux startPos none Name.anonymous c (s.next input startPos);
@@ -837,7 +826,7 @@ private def nameLitAux (startPos : Nat) : BasicParserFn
       s.pushSyntax (Syntax.node nameLitKind #[mkAtomFrom stx rawStr.toString])
     | _ => s.mkError "invalid Name literal"
 
-private def tokenFnAux : BasicParserFn
+private def tokenFnAux : ParserFn
 | c, s =>
   let input := c.input;
   let i     := s.pos;
@@ -863,7 +852,7 @@ match s with
     ⟨stack, pos, { tokenCache := { startPos := startPos, stopPos := pos, token := tk } }, none⟩
 | other => other
 
-def tokenFn : BasicParserFn :=
+def tokenFn : ParserFn :=
 fun c s =>
   let input := c.input;
   let i     := s.pos;
@@ -887,14 +876,14 @@ else
   (s.restore iniSz iniPos, some stx)
 
 /- Treat keywords as identifiers. -/
-def rawIdentFn : BasicParserFn :=
+def rawIdentFn : ParserFn :=
 fun c s =>
   let input := c.input;
   let i     := s.pos;
   if input.atEnd i then s.mkEOIError
   else identFnAux i none Name.anonymous c s
 
-@[inline] def satisfySymbolFn (p : String → Bool) (expected : List String) : BasicParserFn :=
+@[inline] def satisfySymbolFn (p : String → Bool) (expected : List String) : ParserFn :=
 fun c s =>
   let startPos := s.pos;
   let s        := tokenFn c s;
@@ -905,22 +894,22 @@ fun c s =>
     | Syntax.atom _ sym => if p sym then s else s.mkErrorsAt expected startPos
     | _                 => s.mkErrorsAt expected startPos
 
-@[inline] def symbolFnAux (sym : String) (errorMsg : String) : BasicParserFn :=
+@[inline] def symbolFnAux (sym : String) (errorMsg : String) : ParserFn :=
 satisfySymbolFn (fun s => s == sym) [errorMsg]
 
 def symbolInfo (sym : String) (lbp : Option Nat) : ParserInfo :=
 { collectTokens := fun tks => { val := sym, lbp := lbp } :: tks,
   firstTokens   := FirstTokens.tokens [ { val := sym, lbp := lbp } ] }
 
-@[inline] def symbolFn {k : ParserKind} (sym : String) : ParserFn k :=
-fun _ => symbolFnAux sym ("'" ++ sym ++ "'")
+@[inline] def symbolFn (sym : String) : ParserFn :=
+symbolFnAux sym ("'" ++ sym ++ "'")
 
-@[inline] def symbolAux {k : ParserKind} (sym : String) (lbp : Option Nat := none) : Parser k :=
+@[inline] def symbolAux (sym : String) (lbp : Option Nat := none) : Parser :=
 let sym := sym.trim;
 { info := symbolInfo sym lbp,
   fn   := symbolFn sym }
 
-@[inline] def symbol {k : ParserKind} (sym : String) (lbp : Nat) : Parser k :=
+@[inline] def symbol (sym : String) (lbp : Nat) : Parser :=
 symbolAux sym lbp
 
 /-- Check if the following token is the symbol _or_ identifier `sym`. Useful for
@@ -930,7 +919,7 @@ symbolAux sym lbp
     For example, the universe `max` Function is parsed using this combinator so that
     it can still be used as an identifier outside of universes (but registering it
     as a token in a Term Syntax would not break the universe Parser). -/
-def nonReservedSymbolFnAux (sym : String) (errorMsg : String) : BasicParserFn :=
+def nonReservedSymbolFnAux (sym : String) (errorMsg : String) : ParserFn :=
 fun c s =>
   let startPos := s.pos;
   let s := tokenFn c s;
@@ -947,7 +936,7 @@ fun c s =>
         s.mkErrorAt errorMsg startPos
     | _ => s.mkErrorAt errorMsg startPos
 
-@[inline] def nonReservedSymbolFn (sym : String) : BasicParserFn :=
+@[inline] def nonReservedSymbolFn (sym : String) : ParserFn :=
 nonReservedSymbolFnAux sym ("'" ++ sym ++ "'")
 
 def nonReservedSymbolInfo (sym : String) (includeIdent : Bool) : ParserInfo :=
@@ -957,12 +946,12 @@ def nonReservedSymbolInfo (sym : String) (includeIdent : Bool) : ParserInfo :=
   else
     FirstTokens.tokens [ { val := sym } ] }
 
-@[inline] def nonReservedSymbol {k : ParserKind} (sym : String) (includeIdent := false) : Parser k :=
+@[inline] def nonReservedSymbol (sym : String) (includeIdent := false) : Parser :=
 let sym := sym.trim;
 { info := nonReservedSymbolInfo sym includeIdent,
-  fn   := fun _ => nonReservedSymbolFn sym }
+  fn   := nonReservedSymbolFn sym }
 
-partial def strAux (sym : String) (errorMsg : String) : Nat → BasicParserFn
+partial def strAux (sym : String) (errorMsg : String) : Nat → ParserFn
 | j, c, s =>
   if sym.atEnd j then s
   else
@@ -976,14 +965,14 @@ match prev.getTailInfo with
 | some info => info.trailing.stopPos > info.trailing.startPos
 | none      => false
 
-def checkWsBeforeFn (errorMsg : String) : BasicParserFn :=
+def checkWsBeforeFn (errorMsg : String) : ParserFn :=
 fun c s =>
   let prev := s.stxStack.back;
   if checkTailWs prev then s else s.mkError errorMsg
 
-def checkWsBefore {k : ParserKind} (errorMsg : String) : Parser k :=
+def checkWsBefore (errorMsg : String) : Parser :=
 { info := epsilonInfo,
-  fn   := fun _ => checkWsBeforeFn errorMsg }
+  fn   := checkWsBeforeFn errorMsg }
 
 def checkTailNoWs (prev : Syntax) : Bool :=
 match prev.getTailInfo with
@@ -995,21 +984,21 @@ match stack.findRev? $ fun stx => !stx.isNone with
 | none => Syntax.missing
 | some stx => stx
 
-def checkNoWsBeforeFn (errorMsg : String) : BasicParserFn :=
+def checkNoWsBeforeFn (errorMsg : String) : ParserFn :=
 fun c s =>
   let prev := pickNonNone s.stxStack;
   if checkTailNoWs prev then s else s.mkError errorMsg
 
-def checkNoWsBefore {k : ParserKind} (errorMsg : String) : Parser k :=
+def checkNoWsBefore (errorMsg : String) : Parser :=
 { info := epsilonInfo,
-  fn   := fun _ => checkNoWsBeforeFn errorMsg }
+  fn   := checkNoWsBeforeFn errorMsg }
 
 def symbolNoWsInfo (sym : String) (lbpNoWs : Option Nat) : ParserInfo :=
 { collectTokens := fun tks => { val := sym, lbpNoWs := lbpNoWs } :: tks,
   firstTokens   := FirstTokens.tokens [ { val := sym, lbpNoWs := lbpNoWs } ] }
 
-@[inline] def symbolNoWsFnAux (sym : String) (errorMsg : String) : ParserFn trailing :=
-fun _ c s =>
+@[inline] def symbolNoWsFnAux (sym : String) (errorMsg : String) : ParserFn :=
+fun c s =>
   let left := s.stxStack.back;
   if checkTailNoWs left then
     let startPos := s.pos;
@@ -1025,45 +1014,45 @@ fun _ c s =>
   else
     s.mkError errorMsg
 
-@[inline] def symbolNoWsFn (sym : String) : ParserFn trailing :=
+@[inline] def symbolNoWsFn (sym : String) : ParserFn :=
 symbolNoWsFnAux sym ("'" ++ sym ++ "' without whitespaces around it")
 
 /- Similar to `symbol`, but succeeds only if there is no space whitespace after leading term and after `sym`. -/
-@[inline] def symbolNoWsAux (sym : String) (lbp : Option Nat) : TrailingParser :=
+@[inline] def symbolNoWsAux (sym : String) (lbp : Option Nat) : Parser :=
 let sym := sym.trim;
 { info := symbolNoWsInfo sym lbp,
   fn   := symbolNoWsFn sym }
 
-@[inline] def symbolNoWs (sym : String) (lbp : Nat) : TrailingParser :=
+@[inline] def symbolNoWs (sym : String) (lbp : Nat) : Parser :=
 symbolNoWsAux sym lbp
 
-def unicodeSymbolFnAux (sym asciiSym : String) (expected : List String) : BasicParserFn :=
+def unicodeSymbolFnAux (sym asciiSym : String) (expected : List String) : ParserFn :=
 satisfySymbolFn (fun s => s == sym || s == asciiSym) expected
 
 def unicodeSymbolInfo (sym asciiSym : String) (lbp : Option Nat) : ParserInfo :=
 { collectTokens := fun tks => { val := sym, lbp := lbp } :: { val := asciiSym, lbp := lbp } :: tks,
   firstTokens   := FirstTokens.tokens [ { val := sym, lbp := lbp }, { val := asciiSym, lbp := lbp } ] }
 
-@[inline] def unicodeSymbolFn {k : ParserKind} (sym asciiSym : String) : ParserFn k :=
-fun _ => unicodeSymbolFnAux sym asciiSym ["'" ++ sym ++ "', '" ++ asciiSym ++ "'"]
+@[inline] def unicodeSymbolFn (sym asciiSym : String) : ParserFn :=
+unicodeSymbolFnAux sym asciiSym ["'" ++ sym ++ "', '" ++ asciiSym ++ "'"]
 
-@[inline] def unicodeSymbol {k : ParserKind} (sym asciiSym : String) (lbp : Option Nat := none) : Parser k :=
+@[inline] def unicodeSymbol (sym asciiSym : String) (lbp : Option Nat := none) : Parser :=
 let sym := sym.trim;
 let asciiSym := asciiSym.trim;
 { info := unicodeSymbolInfo sym asciiSym lbp,
   fn   := unicodeSymbolFn sym asciiSym }
 
-def unicodeSymbolCheckPrecFnAux (sym asciiSym : String) (lbp : Nat) (expected : List String) (precErrorMsg : String) : ParserFn leading :=
-fun (rbp : Nat) c s =>
-  if rbp > lbp then s.mkUnexpectedError precErrorMsg
+def unicodeSymbolCheckPrecFnAux (sym asciiSym : String) (lbp : Nat) (expected : List String) (precErrorMsg : String) : ParserFn :=
+fun c s =>
+  if c.rbp > lbp then s.mkUnexpectedError precErrorMsg
   else satisfySymbolFn (fun s => s == sym || s == asciiSym) expected c s
 
-@[inline] def unicodeSymbolCheckPrecFn (sym asciiSym : String) (lbp : Nat) : ParserFn leading :=
+@[inline] def unicodeSymbolCheckPrecFn (sym asciiSym : String) (lbp : Nat) : ParserFn :=
 unicodeSymbolCheckPrecFnAux sym asciiSym lbp
   ["'" ++ sym ++ "'", "'" ++ asciiSym ++ "'"]
   ("found '" ++ sym ++ "' as expected, but brackets are needed") -- improve error message
 
-@[inline] def unicodeSymbolCheckPrec (sym asciiSym : String) (lbp : Nat) : Parser leading :=
+@[inline] def unicodeSymbolCheckPrec (sym asciiSym : String) (lbp : Nat) : Parser :=
 let sym := sym.trim;
 let asciiSym := asciiSym.trim;
 { info := unicodeSymbolInfo sym asciiSym lbp,
@@ -1072,61 +1061,61 @@ let asciiSym := asciiSym.trim;
 def mkAtomicInfo (k : String) : ParserInfo :=
 { firstTokens := FirstTokens.tokens [ { val := k } ] }
 
-def numLitFn {k : ParserKind} : ParserFn k :=
-fun _ c s =>
+def numLitFn : ParserFn :=
+fun c s =>
   let iniPos := s.pos;
   let s      := tokenFn c s;
   if s.hasError || !(s.stxStack.back.isOfKind numLitKind) then s.mkErrorAt "numeral" iniPos else s
 
-@[inline] def numLitNoAntiquot {k : ParserKind} : Parser k :=
+@[inline] def numLitNoAntiquot : Parser :=
 { fn   := numLitFn,
   info := mkAtomicInfo "numLit" }
 
-def strLitFn {k : ParserKind} : ParserFn k :=
-fun _ c s =>
+def strLitFn : ParserFn :=
+fun c s =>
   let iniPos := s.pos;
   let s := tokenFn c s;
   if s.hasError || !(s.stxStack.back.isOfKind strLitKind) then s.mkErrorAt "string literal" iniPos else s
 
-@[inline] def strLitNoAntiquot {k : ParserKind} : Parser k :=
+@[inline] def strLitNoAntiquot : Parser :=
 { fn   := strLitFn,
   info := mkAtomicInfo "strLit" }
 
-def charLitFn {k : ParserKind} : ParserFn k :=
-fun _ c s =>
+def charLitFn : ParserFn :=
+fun c s =>
   let iniPos := s.pos;
   let s := tokenFn c s;
   if s.hasError || !(s.stxStack.back.isOfKind charLitKind) then s.mkErrorAt "character literal" iniPos else s
 
-@[inline] def charLitNoAntiquot {k : ParserKind} : Parser k :=
+@[inline] def charLitNoAntiquot : Parser :=
 { fn   := charLitFn,
   info := mkAtomicInfo "charLit" }
 
-def nameLitFn {k : ParserKind} : ParserFn k :=
-fun _ c s =>
+def nameLitFn : ParserFn :=
+fun c s =>
   let iniPos := s.pos;
   let s := tokenFn c s;
   if s.hasError || !(s.stxStack.back.isOfKind nameLitKind) then s.mkErrorAt "Name literal" iniPos else s
 
-@[inline] def nameLitNoAntiquot {k : ParserKind} : Parser k :=
+@[inline] def nameLitNoAntiquot : Parser :=
 { fn   := nameLitFn,
   info := mkAtomicInfo "nameLit" }
 
-def identFn {k : ParserKind} : ParserFn k :=
-fun _ c s =>
+def identFn : ParserFn :=
+fun c s =>
   let iniPos := s.pos;
   let s      := tokenFn c s;
   if s.hasError || !(s.stxStack.back.isIdent) then s.mkErrorAt "identifier" iniPos else s
 
-@[inline] def identNoAntiquot {k : ParserKind} : Parser k :=
+@[inline] def identNoAntiquot : Parser :=
 { fn   := identFn,
   info := mkAtomicInfo "ident" }
 
-@[inline] def rawIdentNoAntiquot {k : ParserKind} : Parser k :=
-{ fn := fun _ => rawIdentFn }
+@[inline] def rawIdentNoAntiquot : Parser :=
+{ fn := rawIdentFn }
 
-def identEqFn {k : ParserKind} (id : Name) : ParserFn k :=
-fun _ c s =>
+def identEqFn (id : Name) : ParserFn :=
+fun c s =>
   let iniPos := s.pos;
   let s      := tokenFn c s;
   if s.hasError then
@@ -1135,19 +1124,19 @@ fun _ c s =>
     | Syntax.ident _ _ val _ => if val != id then s.mkErrorAt ("expected identifier '" ++ toString id ++ "'") iniPos else s
     | _ => s.mkErrorAt "identifier" iniPos
 
-@[inline] def identEq {k : ParserKind} (id : Name) : Parser k :=
+@[inline] def identEq (id : Name) : Parser :=
 { fn   := identEqFn id,
   info := mkAtomicInfo "ident" }
 
-def quotedSymbolFn {k : ParserKind} : ParserFn k :=
-nodeFn `quotedSymbol (andthenFn (andthenFn (chFn '`') (rawFn (fun _ => takeUntilFn (fun c => c == '`')))) (chFn '`' true))
+def quotedSymbolFn : ParserFn :=
+nodeFn `quotedSymbol (andthenFn (andthenFn (chFn '`') (rawFn (takeUntilFn (fun c => c == '`')))) (chFn '`' true))
 
 -- TODO: remove after old frontend is gone
-def quotedSymbol {k : ParserKind} : Parser k :=
+def quotedSymbol : Parser :=
 { fn := quotedSymbolFn }
 
-def unquotedSymbolFn {k : ParserKind} : ParserFn k :=
-fun _ c s =>
+def unquotedSymbolFn : ParserFn :=
+fun c s =>
   let iniPos := s.pos;
   let s      := tokenFn c s;
   if s.hasError || s.stxStack.back.isIdent || isLitKind s.stxStack.back.getKind then
@@ -1155,10 +1144,10 @@ fun _ c s =>
   else
     s
 
-def unquotedSymbol {k : ParserKind} : Parser k :=
+def unquotedSymbol : Parser :=
 { fn := unquotedSymbolFn }
 
-instance string2basic {k : ParserKind} : HasCoe String (Parser k) :=
+instance stringToParserCoe : HasCoe String Parser :=
 ⟨symbolAux⟩
 
 namespace ParserState
@@ -1203,13 +1192,13 @@ s.keepLatest startStackSize
 
 end ParserState
 
-def longestMatchStep {k : ParserKind} (startSize : Nat) (startPos : String.Pos) (p : ParserFn k) : ParserFn k :=
-fun a c s =>
+def longestMatchStep (startSize : Nat) (startPos : String.Pos) (p : ParserFn) : ParserFn :=
+fun c s =>
 let prevErrorMsg  := s.errorMsg;
 let prevStopPos   := s.pos;
 let prevSize      := s.stackSize;
 let s             := s.restore prevSize startPos;
-let s             := p a c s;
+let s             := p c s;
 match prevErrorMsg, s.errorMsg with
 | none, none   => -- both succeeded
   if s.pos > prevStopPos      then s.replaceLongest startSize prevSize -- replace
@@ -1230,53 +1219,53 @@ match prevErrorMsg, s.errorMsg with
 def longestMatchMkResult (startSize : Nat) (s : ParserState) : ParserState :=
 if !s.hasError && s.stackSize > startSize + 1 then s.mkNode choiceKind startSize else s
 
-def longestMatchFnAux {k : ParserKind} (startSize : Nat) (startPos : String.Pos) : List (Parser k) → ParserFn k
-| []    => fun _ _ s => longestMatchMkResult startSize s
-| p::ps => fun a c s =>
-   let s := longestMatchStep startSize startPos p.fn a c s;
-   longestMatchFnAux ps a c s
+def longestMatchFnAux (startSize : Nat) (startPos : String.Pos) : List Parser → ParserFn
+| []    => fun _ s => longestMatchMkResult startSize s
+| p::ps => fun c s =>
+   let s := longestMatchStep startSize startPos p.fn c s;
+   longestMatchFnAux ps c s
 
-def longestMatchFn₁ {k : ParserKind} (p : ParserFn k) : ParserFn k :=
-fun a c s =>
+def longestMatchFn₁ (p : ParserFn) : ParserFn :=
+fun c s =>
 let startSize := s.stackSize;
-let s := p a c s;
+let s := p c s;
 if s.hasError then s else s.mkLongestNodeAlt startSize
 
-def longestMatchFn {k : ParserKind} : List (Parser k) → ParserFn k
-| []    => fun _ _ s => s.mkError "longestMatch: empty list"
+def longestMatchFn : List Parser → ParserFn
+| []    => fun _ s => s.mkError "longestMatch: empty list"
 | [p]   => longestMatchFn₁ p.fn
-| p::ps => fun a c s =>
+| p::ps => fun c s =>
   let startSize := s.stackSize;
   let startPos  := s.pos;
-  let s         := p.fn a c s;
+  let s         := p.fn c s;
   if s.hasError then
     let s := s.shrinkStack startSize;
-    longestMatchFnAux startSize startPos ps a c s
+    longestMatchFnAux startSize startPos ps c s
   else
     let s := s.mkLongestNodeAlt startSize;
-    longestMatchFnAux startSize startPos ps a c s
+    longestMatchFnAux startSize startPos ps c s
 
-def anyOfFn {k : ParserKind} : List (Parser k) → ParserFn k
-| [],    _, _, s => s.mkError "anyOf: empty list"
-| [p],   a, c, s => p.fn a c s
-| p::ps, a, c, s => orelseFn p.fn (anyOfFn ps) a c s
+def anyOfFn : List Parser → ParserFn
+| [],    _, s => s.mkError "anyOf: empty list"
+| [p],   c, s => p.fn c s
+| p::ps, c, s => orelseFn p.fn (anyOfFn ps) c s
 
-@[inline] def checkColGeFn (col : Nat) (errorMsg : String) : BasicParserFn :=
+@[inline] def checkColGeFn (col : Nat) (errorMsg : String) : ParserFn :=
 fun c s =>
   let pos := c.fileMap.toPosition s.pos;
   if pos.column ≥ col then s
   else s.mkError errorMsg
 
-@[inline] def checkColGe {k : ParserKind} (col : Nat) (errorMsg : String) : Parser k :=
-{ fn := fun _ => checkColGeFn col errorMsg }
+@[inline] def checkColGe (col : Nat) (errorMsg : String) : Parser :=
+{ fn := checkColGeFn col errorMsg }
 
-@[inline] def withPosition {k : ParserKind} (p : Position → Parser k) : Parser k :=
+@[inline] def withPosition (p : Position → Parser) : Parser :=
 { info := (p { line := 1, column := 0 }).info,
-  fn   := fun a c s =>
+  fn   := fun c s =>
    let pos := c.fileMap.toPosition s.pos;
-   (p pos).fn a c s }
+   (p pos).fn c s }
 
-@[inline] def many1Indent {k : ParserKind} (p : Parser k) (errorMsg : String) : Parser k :=
+@[inline] def many1Indent (p : Parser) (errorMsg : String) : Parser :=
 withPosition $ fun pos => many1 (checkColGe pos.column errorMsg >> p)
 
 /-- A multimap indexed by tokens. Used for indexing parsers by their leading token. -/
@@ -1375,20 +1364,20 @@ private def mkResult (s : ParserState) (iniSz : Nat) : ParserState :=
 if s.stackSize == iniSz + 1 then s
 else s.mkNode nullKind iniSz -- throw error instead?
 
-def leadingParser (kind : Name) (tables : PrattParsingTables) (leadingIdentAsSymbol : Bool) : ParserFn leading :=
-fun a c s =>
+def leadingParser (kind : Name) (tables : PrattParsingTables) (leadingIdentAsSymbol : Bool) : ParserFn :=
+fun c s =>
   let iniSz   := s.stackSize;
   let (s, ps) := indexed tables.leadingTable c s leadingIdentAsSymbol;
   let ps      := tables.leadingParsers ++ ps;
   if ps.isEmpty then
     s.mkError (toString kind)
   else
-    let s := longestMatchFn ps a c s;
+    let s := longestMatchFn ps c s;
     mkResult s iniSz
 
-def trailingLoopStep (tables : PrattParsingTables) (ps : List (Parser trailing)) : ParserFn trailing :=
-fun _ c s =>
-  orelseFn (longestMatchFn ps) (anyOfFn tables.trailingParsers) () c s
+def trailingLoopStep (tables : PrattParsingTables) (ps : List Parser) : ParserFn :=
+fun c s =>
+  orelseFn (longestMatchFn ps) (anyOfFn tables.trailingParsers) c s
 
 private def mkTrailingResult (s : ParserState) (iniSz : Nat) : ParserState :=
 let s := mkResult s iniSz;
@@ -1398,11 +1387,11 @@ let result := s.stxStack.back;
 let s      := s.popSyntax.popSyntax;
 s.pushSyntax result
 
-partial def trailingLoop (tables : PrattParsingTables) (rbp : Nat) (c : ParserContext) : ParserState → ParserState
+partial def trailingLoop (tables : PrattParsingTables) (c : ParserContext) : ParserState → ParserState
 | s =>
   let left := s.stxStack.back;
   let (s, lbp) := currLbp left c s;
-  if rbp ≥ lbp then s
+  if c.rbp ≥ lbp then s
   else
     let iniSz         := s.stackSize;
     let identAsSymbol := false;
@@ -1410,23 +1399,23 @@ partial def trailingLoop (tables : PrattParsingTables) (rbp : Nat) (c : ParserCo
     if ps.isEmpty && tables.trailingParsers.isEmpty then
       s -- no available trailing parser
     else
-      let s := trailingLoopStep tables ps () c s;
+      let s := trailingLoopStep tables ps c s;
       if s.hasError then s
       else
         let s := mkTrailingResult s iniSz;
         trailingLoop s
 
-def prattParser (kind : Name) (tables : PrattParsingTables) (leadingIdentAsSymbol : Bool) : ParserFn leading :=
-fun rbp c s =>
-  let s := leadingParser kind tables leadingIdentAsSymbol rbp c s;
+def prattParser (kind : Name) (tables : PrattParsingTables) (leadingIdentAsSymbol : Bool) : ParserFn :=
+fun c s =>
+  let s := leadingParser kind tables leadingIdentAsSymbol c s;
   if s.hasError then s
   else
-    trailingLoop tables rbp c s
+    trailingLoop tables c s
 
-abbrev CategoryParserFn := Name → ParserFn leading
+abbrev CategoryParserFn := Name → ParserFn
 
 def mkCategoryParserFnRef : IO (IO.Ref CategoryParserFn) :=
-IO.mkRef $ fun _ _ => whitespace
+IO.mkRef $ fun _ => whitespace
 
 @[init mkCategoryParserFnRef]
 constant categoryParserFnRef : IO.Ref CategoryParserFn := arbitrary _
@@ -1437,25 +1426,25 @@ registerEnvExtension $ categoryParserFnRef.get
 @[init mkCategoryParserFnExtension]
 def categoryParserFnExtension : EnvExtension CategoryParserFn := arbitrary _
 
-def categoryParserFn (catName : Name) : ParserFn leading :=
-fun rbp ctx s => categoryParserFnExtension.getState ctx.env catName rbp ctx s
+def categoryParserFn (catName : Name) : ParserFn :=
+fun ctx s => categoryParserFnExtension.getState ctx.env catName ctx s
 
-def categoryParser {k} (catName : Name) (rbp : Nat) : Parser k :=
-{ fn := fun _ => categoryParserFn catName rbp }
+def categoryParser (catName : Name) (rbp : Nat) : Parser :=
+{ fn := fun c s => categoryParserFn catName { rbp := rbp, .. c } s }
 
 -- Define `termParser` here because we need it for antiquotations
-@[inline] def termParser {k : ParserKind} (rbp : Nat := 0) : Parser k :=
+@[inline] def termParser (rbp : Nat := 0) : Parser :=
 categoryParser `term rbp
 
 /- ============== -/
 /- Antiquotations -/
 /- ============== -/
 
-def dollarSymbol {k : ParserKind} : Parser k := symbol "$" 1
+def dollarSymbol : Parser := symbol "$" 1
 
 /-- Fail if previous token is immediately followed by ':'. -/
-private def noImmediateColon {k : ParserKind} : Parser k :=
-{ fn := fun _ c s =>
+private def noImmediateColon : Parser :=
+{ fn := fun c s =>
   let prev := s.stxStack.back;
   if checkTailNoWs prev then
     let input := c.input;
@@ -1469,16 +1458,16 @@ private def noImmediateColon {k : ParserKind} : Parser k :=
   else s
 }
 
-def setExpectedFn {k : ParserKind} (expected : List String) (p : ParserFn k) : ParserFn k :=
-fun a c s => match p a c s with
+def setExpectedFn (expected : List String) (p : ParserFn) : ParserFn :=
+fun c s => match p c s with
   | s'@{ errorMsg := some msg } => { s' with errorMsg := some { msg with expected := [] } }
   | s'                          => s'
 
-def setExpected {k : ParserKind} (expected : List String) (p : Parser k) : Parser k :=
+def setExpected (expected : List String) (p : Parser) : Parser :=
 { fn := setExpectedFn expected p.fn, info := p.info }
 
-def pushNone {k : ParserKind} : Parser k :=
-{ fn := fun a c s => s.pushSyntax mkNullNode }
+def pushNone : Parser :=
+{ fn := fun c s => s.pushSyntax mkNullNode }
 
 /-
   We support two kinds of antiquotations: `$id` and `$(t)`, where `id` is a term identifier and `t` is a term.
@@ -1486,16 +1475,16 @@ def pushNone {k : ParserKind} : Parser k :=
   TODO: we are making both cases look like syntax terms. Reason: the current expander expects a term.
   We should remove this hack and modify the expander. This hack is bad since it relies on how we define `id` and `paren` in
   the term parser at `Term.lean`. -/
-private def antiquotId {k} : Parser k         := node `Lean.Parser.Term.id (identNoAntiquot >> pushNone)
-private def antiquotNestedExpr {k} : Parser k := node `Lean.Parser.Term.paren ("(" >> node nullKind (termParser >> pushNone) >> ")")
-private def antiquotExpr {k} : Parser k       := antiquotId <|> antiquotNestedExpr
+private def antiquotId : Parser         := node `Lean.Parser.Term.id (identNoAntiquot >> pushNone)
+private def antiquotNestedExpr : Parser := node `Lean.Parser.Term.paren ("(" >> node nullKind (termParser >> pushNone) >> ")")
+private def antiquotExpr : Parser       := antiquotId <|> antiquotNestedExpr
 
 /--
   Define parser for `$e` (if anonymous == true) and `$e:name`. Both
   forms can also be used with an appended `*` to turn them into an
   antiquotation "splice". If `kind` is given, it will additionally be checked
   when evaluating `match_syntax`. -/
-def mkAntiquotAux (name : String) (kind : Option SyntaxNodeKind) (anonymous := true) : Parser :=
+def mkAntiquot (name : String) (kind : Option SyntaxNodeKind) (anonymous := true) : Parser :=
 let kind := (kind.getD Name.anonymous) ++ `antiquot;
 let nameP := checkNoWsBefore ("no space before ':" ++ name ++ "'") >> symbolAux ":" >> nonReservedSymbol name;
 -- if parsing the kind fails and `anonymous` is true, check that we're not ignoring a different
@@ -1504,49 +1493,44 @@ let nameP := if anonymous then nameP <|> noImmediateColon >> pushNone >> pushNon
 -- antiquotations are not part of the "standard" syntax, so hide "expected '$'" on error
 node kind $ try $ setExpected [] dollarSymbol >> checkNoWsBefore "no space before" >> antiquotExpr >> nameP >> optional (checkNoWsBefore "" >> "*")
 
-def mkAntiquot {k : ParserKind} (name : String) (kind : Option SyntaxNodeKind) (anonymous := true) : Parser k :=
-match k with
-| ParserKind.leading  => mkAntiquotAux name kind anonymous
-| ParserKind.trailing => toTrailing $ mkAntiquotAux name kind anonymous
-
 /- ===================== -/
 /- End of Antiquotations -/
 /- ===================== -/
 
-def nodeWithAntiquot {k : ParserKind} (name : String) (kind : SyntaxNodeKind) (p : Parser k) : Parser k :=
+def nodeWithAntiquot (name : String) (kind : SyntaxNodeKind) (p : Parser) : Parser :=
 mkAntiquot name kind false <|> node kind p
 
-def ident {k : ParserKind} : Parser k :=
+def ident : Parser :=
 mkAntiquot "ident" identKind <|> identNoAntiquot
 
 -- `ident` and `rawIdent` produce the same syntax tree, so we reuse the antiquotation kind name
-def rawIdent {k : ParserKind} : Parser k :=
+def rawIdent : Parser :=
 mkAntiquot "ident" identKind <|> rawIdentNoAntiquot
 
-def numLit {k : ParserKind} : Parser k :=
+def numLit : Parser :=
 mkAntiquot "numLit" numLitKind <|> numLitNoAntiquot
 
-def strLit {k : ParserKind} : Parser k :=
+def strLit : Parser :=
 mkAntiquot "strLit" strLitKind <|> strLitNoAntiquot
 
-def charLit {k : ParserKind} : Parser k :=
+def charLit : Parser :=
 mkAntiquot "charLit" charLitKind <|> charLitNoAntiquot
 
-def nameLit {k : ParserKind} : Parser k :=
+def nameLit : Parser :=
 mkAntiquot "nameLit" nameLitKind <|> nameLitNoAntiquot
 
-def categoryParserOfStackFn (offset : Nat) : ParserFn leading :=
-fun rbp ctx s =>
+def categoryParserOfStackFn (offset : Nat) : ParserFn :=
+fun ctx s =>
   let stack := s.stxStack;
   if stack.size < offset + 1 then
     s.mkUnexpectedError ("failed to determine parser category using syntax stack, stack is too small")
   else
     match stack.get! (stack.size - offset - 1) with
-    | Syntax.ident _ _ catName _ => categoryParserFn catName rbp ctx s
+    | Syntax.ident _ _ catName _ => categoryParserFn catName ctx s
     | _ => s.mkUnexpectedError ("failed to determine parser category using syntax stack, the specified element on the stack is not an identifier")
 
-def categoryParserOfStack {k} (offset : Nat) (rbp : Nat := 0) : Parser k :=
-{ fn := fun _ => categoryParserOfStackFn offset rbp }
+def categoryParserOfStack (offset : Nat) (rbp : Nat := 0) : Parser :=
+{ fn := fun c s => categoryParserOfStackFn offset { rbp := rbp, .. c } s }
 
 def mkBuiltinTokenTable : IO (IO.Ref TokenTable) := IO.mkRef {}
 @[init mkBuiltinTokenTable] constant builtinTokenTable : IO.Ref TokenTable := arbitrary _
@@ -1583,7 +1567,7 @@ inductive ParserExtensionEntry
 | token     (val : TokenConfig) : ParserExtensionEntry
 | kind      (val : SyntaxNodeKind) : ParserExtensionEntry
 | category  (catName : Name) (leadingIdentAsSymbol : Bool)
-| parser    (catName : Name) (declName : Name) (k : ParserKind) (p : Parser k) : ParserExtensionEntry
+| parser    (catName : Name) (declName : Name) (leading : Bool) (p : Parser) : ParserExtensionEntry
 
 structure ParserExtensionState :=
 (tokens      : TokenTable := {})
@@ -1651,10 +1635,10 @@ match categories.find? catName with
 | none     => throwUnknownParserCategory catName
 | some cat => pure $ categories.insert catName { tables := addTrailingParserAux cat.tables p, .. cat }
 
-def addParser {k} (categories : ParserCategories) (catName : Name) (declName : Name) (p : Parser k) : Except String ParserCategories :=
-match k, p with
-| leading, p  => addLeadingParser categories catName declName p
-| trailing, p => addTrailingParser categories catName p
+def addParser (categories : ParserCategories) (catName : Name) (declName : Name) (leading : Bool) (p : Parser) : Except String ParserCategories :=
+match leading, p with
+| true, p  => addLeadingParser categories catName declName p
+| false, p => addTrailingParser categories catName p
 
 def addParserTokens (tokenTable : TokenTable) (info : ParserInfo) : Except String TokenTable :=
 let newTokens := info.collectTokens [];
@@ -1666,18 +1650,18 @@ match addParserTokens tokenTable info with
 | Except.ok tokenTable => builtinTokenTable.set tokenTable
 | Except.error msg     => throw (IO.userError ("invalid builtin parser '" ++ toString declName ++ "', " ++ msg))
 
-def addBuiltinParser {k} (catName : Name) (declName : Name) (p : Parser k) : IO Unit := do
+def addBuiltinParser (catName : Name) (declName : Name) (leading : Bool) (p : Parser) : IO Unit := do
 categories ← builtinParserCategoriesRef.get;
-categories ← IO.ofExcept $ addParser categories catName declName p;
+categories ← IO.ofExcept $ addParser categories catName declName leading p;
 builtinParserCategoriesRef.set categories;
 builtinSyntaxNodeKindSetRef.modify p.info.collectKinds;
 updateBuiltinTokens p.info declName
 
 def addBuiltinLeadingParser (catName : Name) (declName : Name) (p : Parser) : IO Unit :=
-addBuiltinParser catName declName p
+addBuiltinParser catName declName true p
 
 def addBuiltinTrailingParser (catName : Name) (declName : Name) (p : TrailingParser) : IO Unit :=
-addBuiltinParser catName declName p
+addBuiltinParser catName declName false p
 
 private def ParserExtension.addEntry (s : ParserExtensionState) (e : ParserExtensionEntry) : ParserExtensionState :=
 match e with
@@ -1691,63 +1675,58 @@ match e with
   if s.categories.contains catName then s
   else { categories := s.categories.insert catName { tables := {}, leadingIdentAsSymbol := leadingIdentAsSymbol },
          newEntries := ParserExtensionOleanEntry.category catName leadingIdentAsSymbol :: s.newEntries, .. s }
-| ParserExtensionEntry.parser catName declName _ parser =>
-  match addParser s.categories catName declName parser with
+| ParserExtensionEntry.parser catName declName leading parser =>
+  match addParser s.categories catName declName leading parser with
   | Except.ok categories => { categories := categories, newEntries := ParserExtensionOleanEntry.parser catName declName :: s.newEntries, .. s }
   | _ => unreachable!
 
-def compileParserDescr (categories : ParserCategories) : forall {k : ParserKind}, ParserDescrCore k → Except String (Parser k)
-| _, ParserDescr.andthen d₁ d₂                       => andthen <$> compileParserDescr d₁ <*> compileParserDescr d₂
-| _, ParserDescr.orelse d₁ d₂                        => orelse <$> compileParserDescr d₁ <*> compileParserDescr d₂
-| _, ParserDescr.optional d                          => optional <$> compileParserDescr d
-| _, ParserDescr.lookahead d                         => lookahead <$> compileParserDescr d
-| _, ParserDescr.try d                               => try <$> compileParserDescr d
-| _, ParserDescr.many d                              => many <$> compileParserDescr d
-| _, ParserDescr.many1 d                             => many1 <$> compileParserDescr d
-| _, ParserDescr.sepBy d₁ d₂                         => sepBy <$> compileParserDescr d₁ <*> compileParserDescr d₂
-| _, ParserDescr.sepBy1 d₁ d₂                        => sepBy1 <$> compileParserDescr d₁ <*> compileParserDescr d₂
-| _, ParserDescr.node k d                            => node k <$> compileParserDescr d
-| ParserKind.trailing, ParserDescr.trailingNode k d  => trailingNode k <$> compileParserDescr d
-| _, ParserDescr.symbol tk lbp                       => pure $ symbolAux tk lbp
-| _, ParserDescr.numLit                              => pure $ numLit
-| _, ParserDescr.strLit                              => pure $ strLit
-| _, ParserDescr.charLit                             => pure $ charLit
-| _, ParserDescr.nameLit                             => pure $ nameLit
-| _, ParserDescr.ident                               => pure $ ident
-| ParserKind.leading,
-  ParserDescr.nonReservedSymbol tk includeIdent      => pure $ nonReservedSymbol tk includeIdent
-| _, ParserDescr.parser catName rbp =>
+def compileParserDescr (categories : ParserCategories) : ParserDescr → Except String (Parser)
+| ParserDescr.andthen d₁ d₂                       => andthen <$> compileParserDescr d₁ <*> compileParserDescr d₂
+| ParserDescr.orelse d₁ d₂                        => orelse <$> compileParserDescr d₁ <*> compileParserDescr d₂
+| ParserDescr.optional d                          => optional <$> compileParserDescr d
+| ParserDescr.lookahead d                         => lookahead <$> compileParserDescr d
+| ParserDescr.try d                               => try <$> compileParserDescr d
+| ParserDescr.many d                              => many <$> compileParserDescr d
+| ParserDescr.many1 d                             => many1 <$> compileParserDescr d
+| ParserDescr.sepBy d₁ d₂                         => sepBy <$> compileParserDescr d₁ <*> compileParserDescr d₂
+| ParserDescr.sepBy1 d₁ d₂                        => sepBy1 <$> compileParserDescr d₁ <*> compileParserDescr d₂
+| ParserDescr.node k d                            => node k <$> compileParserDescr d
+| ParserDescr.trailingNode k d                    => trailingNode k <$> compileParserDescr d
+| ParserDescr.symbol tk lbp                       => pure $ symbolAux tk lbp
+| ParserDescr.numLit                              => pure $ numLit
+| ParserDescr.strLit                              => pure $ strLit
+| ParserDescr.charLit                             => pure $ charLit
+| ParserDescr.nameLit                             => pure $ nameLit
+| ParserDescr.ident                               => pure $ ident
+| ParserDescr.nonReservedSymbol tk includeIdent   => pure $ nonReservedSymbol tk includeIdent
+| ParserDescr.parser catName rbp =>
   match categories.find? catName with
   | some _ => pure $ categoryParser catName rbp
   | none   => throwUnknownParserCategory catName
 
-unsafe def mkParserOfConstantUnsafe (env : Environment) (categories : ParserCategories) (constName : Name)
-    : Except String (Sigma (fun (k : ParserKind) => Parser k)) :=
+unsafe def mkParserOfConstantUnsafe (env : Environment) (categories : ParserCategories) (constName : Name) : Except String (Bool × Parser) :=
 match env.find? constName with
 | none      => throw ("unknow constant '" ++ toString constName ++ "'")
 | some info =>
   match info.type with
   | Expr.const `Lean.Parser.TrailingParser _ _ => do
-    p ← env.evalConst (Parser trailing) constName;
-    pure ⟨trailing, p⟩
-  | Expr.app (Expr.const `Lean.Parser.Parser _ _) (Expr.const `Lean.ParserKind.leading _ _) _ => do
-    p ← env.evalConst (Parser leading) constName;
-    pure ⟨leading, p⟩
+    p ← env.evalConst Parser constName;
+    pure ⟨false, p⟩
   | Expr.const `Lean.Parser.Parser _ _ => do
-    p ← env.evalConst (Parser leading) constName;
-    pure ⟨leading, p⟩
+    p ← env.evalConst Parser constName;
+    pure ⟨true, p⟩
   | Expr.const `Lean.ParserDescr _ _ => do
     d ← env.evalConst ParserDescr constName;
     p ← compileParserDescr categories d;
-    pure ⟨leading, p⟩
+    pure ⟨true, p⟩
   | Expr.const `Lean.TrailingParserDescr _ _ => do
     d ← env.evalConst TrailingParserDescr constName;
     p ← compileParserDescr categories d;
-    pure ⟨trailing, p⟩
+    pure ⟨false, p⟩
   | _ => throw ("unexpected parser type at '" ++ toString constName ++ "' (`ParserDescr`, `TrailingParserDescr`, `Parser` or `TrailingParser` expected")
 
 @[implementedBy mkParserOfConstantUnsafe]
-constant mkParserOfConstant (env : Environment) (categories : ParserCategories) (constName : Name) : Except String (Sigma (fun (k : ParserKind) => Parser k)) :=
+constant mkParserOfConstant (env : Environment) (categories : ParserCategories) (constName : Name) : Except String (Bool × Parser) :=
 arbitrary _
 
 private def ParserExtension.addImported (env : Environment) (es : Array (Array ParserExtensionOleanEntry)) : IO ParserExtensionState := do
@@ -1768,7 +1747,7 @@ es.foldlM
        | ParserExtensionOleanEntry.parser catName declName =>
          match mkParserOfConstant env s.categories declName with
         | Except.ok p     =>
-          match addParser s.categories catName declName p.2 with
+          match addParser s.categories catName declName p.1 p.2 with
           | Except.ok categories => pure { categories := categories, .. s }
           | Except.error ex      => throw (IO.userError ex)
         | Except.error ex => throw (IO.userError ex))
@@ -1805,18 +1784,18 @@ match (parserExtension.getState env).categories.find? catName with
 | none     => false
 | some cat => cat.leadingIdentAsSymbol
 
-def categoryParserFnImplAux (catName : Name) : ParserFn leading :=
-fun rbp ctx s =>
+def categoryParserFnImplAux (catName : Name) : ParserFn :=
+fun ctx s =>
   let categories := (parserExtension.getState ctx.env).categories;
   match categories.find? catName with
-  | some cat => prattParser catName cat.tables cat.leadingIdentAsSymbol rbp ctx s
+  | some cat => prattParser catName cat.tables cat.leadingIdentAsSymbol ctx s
   | none     => s.mkUnexpectedError ("unknown parser category '" ++ toString catName ++ "'")
 
 private def catNameToString : Name → String
 | Name.str Name.anonymous s _ => s
 | n                           => n.toString
 
-def categoryParserFnImpl (catName : Name) : ParserFn leading :=
+def categoryParserFnImpl (catName : Name) : ParserFn :=
 if catName != `term then
   orelseFn (mkAntiquot (catNameToString catName) none false).fn (categoryParserFnImplAux catName)
 else
@@ -1851,7 +1830,8 @@ def mkInputContext (input : String) (fileName : String) : InputContext :=
   fileMap  := input.toFileMap }
 
 def mkParserContext (env : Environment) (ctx : InputContext) : ParserContext :=
-{ toInputContext := ctx,
+{ rbp            := 0,
+  toInputContext := ctx,
   env            := env,
   tokens         := getTokenTable env }
 
@@ -1865,7 +1845,7 @@ match categories.find? catName with
   let c := mkParserContext env (mkInputContext input fileName);
   let s := mkParserState input;
   let s := whitespace c s;
-  let s := prattParser catName cat.tables cat.leadingIdentAsSymbol (0 : Nat) c s;
+  let s := prattParser catName cat.tables cat.leadingIdentAsSymbol c s;
   if s.hasError then
     Except.error (s.toErrorMsg c)
   else
@@ -1898,8 +1878,6 @@ match env.find? declName with
   match decl.type with
  | Expr.const `Lean.Parser.TrailingParser _ _ =>
    declareTrailingBuiltinParser env catName declName
- | Expr.app (Expr.const `Lean.Parser.Parser _ _) (Expr.const `Lean.ParserKind.leading _ _) _ =>
-   declareLeadingBuiltinParser env catName declName
  | Expr.const `Lean.Parser.Parser _ _ =>
    declareLeadingBuiltinParser env catName declName
  | _ =>
@@ -1923,7 +1901,7 @@ let categories := (parserExtension.getState env).categories;
 match mkParserOfConstant env categories declName with
 | Except.error ex => throw (IO.userError ex)
 | Except.ok p     => do
-  let parserKind := p.1;
+  let leading    := p.1;
   let parser     := p.2;
   let tokens     := parser.info.collectTokens [];
   env ← tokens.foldlM
@@ -1934,11 +1912,10 @@ match mkParserOfConstant env categories declName with
     env;
   let kinds := parser.info.collectKinds {};
   let env := kinds.foldl (fun env kind _ => addSyntaxNodeKind env kind) env;
-  match addParser categories catName declName parser with
-  | Except.ok _     => pure $ parserExtension.addEntry env $ ParserExtensionEntry.parser catName declName parserKind parser
+  match addParser categories catName declName leading parser with
+  | Except.ok _     => pure $ parserExtension.addEntry env $ ParserExtensionEntry.parser catName declName leading parser
   | Except.error ex => throw (IO.userError ex)
 
-
 def mkParserAttributeImpl (attrName : Name) (catName : Name) : AttributeImpl :=
 { name            := attrName,
   descr           := "parser",
@@ -1967,7 +1944,7 @@ registerBuiltinParserAttribute `builtinTermParser `term
 @[init] def regTermParserAttribute : IO Unit :=
 registerBuiltinDynamicParserAttribute `termParser `term
 
-def fieldIdxFn : BasicParserFn :=
+def fieldIdxFn : ParserFn :=
 fun c s =>
   let iniPos := s.pos;
   let curr     := c.input.get iniPos;
@@ -1977,9 +1954,9 @@ fun c s =>
   else
     s.mkErrorAt "field index" iniPos
 
-@[inline] def fieldIdx {k : ParserKind} : Parser k :=
+@[inline] def fieldIdx : Parser :=
 mkAntiquot "fieldIdx" `fieldIdx <|>
-{ fn   := fun _ => fieldIdxFn,
+{ fn   := fieldIdxFn,
   info := mkAtomicInfo "fieldIdx" }
 
 end Parser
diff --git a/stage0/src/Init/Lean/Parser/Syntax.lean b/stage0/src/Init/Lean/Parser/Syntax.lean
index 87783a86e2..ef0462c719 100644
--- a/stage0/src/Init/Lean/Parser/Syntax.lean
+++ b/stage0/src/Init/Lean/Parser/Syntax.lean
@@ -14,7 +14,7 @@ namespace Parser
 let leadingIdentAsSymbol := true;
 registerBuiltinParserAttribute `builtinSyntaxParser `syntax leadingIdentAsSymbol
 
-@[inline] def syntaxParser {k : ParserKind} (rbp : Nat := 0) : Parser k :=
+@[inline] def syntaxParser (rbp : Nat := 0) : Parser :=
 categoryParser `syntax rbp
 
 def maxPrec := parser! nonReservedSymbol "max" true
diff --git a/stage0/src/Init/Lean/Parser/Tactic.lean b/stage0/src/Init/Lean/Parser/Tactic.lean
index 64b6ea869b..587d75d10b 100644
--- a/stage0/src/Init/Lean/Parser/Tactic.lean
+++ b/stage0/src/Init/Lean/Parser/Tactic.lean
@@ -16,19 +16,19 @@ registerBuiltinParserAttribute `builtinTacticParser `tactic leadingIdentAsSymbol
 @[init] def regTacticParserAttribute : IO Unit :=
 registerBuiltinDynamicParserAttribute `tacticParser `tactic
 
-@[inline] def tacticParser {k : ParserKind} (rbp : Nat := 0) : Parser k :=
+@[inline] def tacticParser (rbp : Nat := 0) : Parser :=
 categoryParser `tactic rbp
 
 namespace Tactic
 
-def underscoreFn {k : ParserKind} : ParserFn k :=
-fun a c s =>
-  let s   := symbolFn "_" a c s;
+def underscoreFn : ParserFn :=
+fun c s =>
+  let s   := symbolFn "_" c s;
   let stx := s.stxStack.back;
   let s   := s.popSyntax;
   s.pushSyntax $ mkIdentFrom stx `_
 
-@[inline] def underscore {k : ParserKind} : Parser k :=
+@[inline] def underscore : Parser :=
 { fn   := underscoreFn,
   info := mkAtomicInfo "ident" }
 
diff --git a/stage0/src/Init/Lean/Parser/Term.lean b/stage0/src/Init/Lean/Parser/Term.lean
index 3e8942b53d..cdf64ac428 100644
--- a/stage0/src/Init/Lean/Parser/Term.lean
+++ b/stage0/src/Init/Lean/Parser/Term.lean
@@ -122,9 +122,9 @@ def bracketedDoSeq := parser! "{" >> doSeq >> "}"
 @[builtinTermParser] def uminus := parser! "-" >> termParser 100
 
 def namedArgument  := parser! try ("(" >> ident >> " := ") >> termParser >> ")"
-@[builtinTermParser] def app      := tparser! many1 ((toTrailing namedArgument) <|> termParser appPrec)
+@[builtinTermParser] def app      := tparser! many1 (namedArgument <|> termParser appPrec)
 
-def checkIsSort := checkLeading (fun leading => leading.isOfKind `Lean.Parser.Term.type || leading.isOfKind `Lean.Parser.Term.sort)
+def checkIsSort := checkStackTop (fun stx => stx.isOfKind `Lean.Parser.Term.type || stx.isOfKind `Lean.Parser.Term.sort)
 @[builtinTermParser] def sortApp  := tparser! checkIsSort >> levelParser appPrec
 @[builtinTermParser] def proj     := tparser! symbolNoWs "." (appPrec+1) >> (fieldIdx <|> ident)
 @[builtinTermParser] def arrow    := tparser! unicodeInfixR " → " " -> " 25
@@ -133,7 +133,7 @@ def checkIsSort := checkLeading (fun leading => leading.isOfKind `Lean.Parser.Te
 @[builtinTermParser] def dollar     := tparser! try (dollarSymbol >> checkWsBefore "space expected") >> termParser 0
 @[builtinTermParser] def dollarProj := tparser! symbol "$." 1 >> (fieldIdx <|> ident)
 
-@[builtinTermParser] def «where»    := tparser! symbol " where " 1 >> sepBy1 (toTrailing letDecl) (group ("; " >> " where "))
+@[builtinTermParser] def «where»    := tparser! symbol " where " 1 >> sepBy1 letDecl (group ("; " >> " where "))
 
 @[builtinTermParser] def fcomp  := tparser! infixR " ∘ " 90
 
diff --git a/stage0/src/Init/LeanInit.lean b/stage0/src/Init/LeanInit.lean
index 7b15528ada..f03079c1ad 100644
--- a/stage0/src/Init/LeanInit.lean
+++ b/stage0/src/Init/LeanInit.lean
@@ -132,57 +132,32 @@ mkNameNum g.namePrefix g.idx
 
 end NameGenerator
 
-inductive ParserKind
-| leading | trailing
-
 /-
   Small DSL for describing parsers. We implement an interpreter for it
   at `Parser.lean` -/
-inductive ParserDescrCore : ParserKind → Type
-| andthen {k : ParserKind}       : ParserDescrCore k → ParserDescrCore k → ParserDescrCore k
-| orelse  {k : ParserKind}       : ParserDescrCore k → ParserDescrCore k → ParserDescrCore k
-| optional {k : ParserKind}      : ParserDescrCore k → ParserDescrCore k
-| lookahead {k : ParserKind}     : ParserDescrCore k → ParserDescrCore k
-| try {k : ParserKind}           : ParserDescrCore k → ParserDescrCore k
-| many {k : ParserKind}          : ParserDescrCore k → ParserDescrCore k
-| many1 {k : ParserKind}         : ParserDescrCore k → ParserDescrCore k
-| sepBy {k : ParserKind}         : ParserDescrCore k → ParserDescrCore k → ParserDescrCore k
-| sepBy1 {k : ParserKind}        : ParserDescrCore k → ParserDescrCore k → ParserDescrCore k
-| node {k : ParserKind}          : Name → ParserDescrCore k → ParserDescrCore k
-| trailingNode                   : Name → ParserDescrCore ParserKind.trailing → ParserDescrCore ParserKind.trailing
-| symbol {k : ParserKind}        : String → Option Nat → ParserDescrCore k
-| nonReservedSymbol              : String → Bool → ParserDescrCore ParserKind.leading
-| numLit {k : ParserKind}        : ParserDescrCore k
-| strLit {k : ParserKind}        : ParserDescrCore k
-| charLit {k : ParserKind}       : ParserDescrCore k
-| nameLit {k : ParserKind}       : ParserDescrCore k
-| ident {k : ParserKind}         : ParserDescrCore k
-| parser {k : ParserKind}        : Name → Nat → ParserDescrCore k
+inductive ParserDescr
+| andthen           : ParserDescr → ParserDescr → ParserDescr
+| orelse            : ParserDescr → ParserDescr → ParserDescr
+| optional          : ParserDescr → ParserDescr
+| lookahead         : ParserDescr → ParserDescr
+| try               : ParserDescr → ParserDescr
+| many              : ParserDescr → ParserDescr
+| many1             : ParserDescr → ParserDescr
+| sepBy             : ParserDescr → ParserDescr → ParserDescr
+| sepBy1            : ParserDescr → ParserDescr → ParserDescr
+| node              : Name → ParserDescr → ParserDescr
+| trailingNode      : Name → ParserDescr → ParserDescr
+| symbol            : String → Option Nat → ParserDescr
+| nonReservedSymbol : String → Bool → ParserDescr
+| numLit            : ParserDescr
+| strLit            : ParserDescr
+| charLit           : ParserDescr
+| nameLit           : ParserDescr
+| ident             : ParserDescr
+| parser            : Name → Nat → ParserDescr
 
-instance ParserDescrCore.inhabited {k} : Inhabited (ParserDescrCore k) := ⟨ParserDescrCore.symbol "" none⟩
-
-abbrev ParserDescr := ParserDescrCore ParserKind.leading
-abbrev TrailingParserDescr := ParserDescrCore ParserKind.trailing
-
-@[matchPattern] abbrev ParserDescr.andthen := @ParserDescrCore.andthen
-@[matchPattern] abbrev ParserDescr.orelse := @ParserDescrCore.orelse
-@[matchPattern] abbrev ParserDescr.optional := @ParserDescrCore.optional
-@[matchPattern] abbrev ParserDescr.lookahead := @ParserDescrCore.lookahead
-@[matchPattern] abbrev ParserDescr.try := @ParserDescrCore.try
-@[matchPattern] abbrev ParserDescr.many := @ParserDescrCore.many
-@[matchPattern] abbrev ParserDescr.many1 := @ParserDescrCore.many1
-@[matchPattern] abbrev ParserDescr.sepBy := @ParserDescrCore.sepBy
-@[matchPattern] abbrev ParserDescr.sepBy1 := @ParserDescrCore.sepBy1
-@[matchPattern] abbrev ParserDescr.node := @ParserDescrCore.node
-@[matchPattern] abbrev ParserDescr.trailingNode := @ParserDescrCore.trailingNode
-@[matchPattern] abbrev ParserDescr.symbol := @ParserDescrCore.symbol
-@[matchPattern] abbrev ParserDescr.numLit := @ParserDescrCore.numLit
-@[matchPattern] abbrev ParserDescr.strLit := @ParserDescrCore.strLit
-@[matchPattern] abbrev ParserDescr.charLit := @ParserDescrCore.charLit
-@[matchPattern] abbrev ParserDescr.nameLit := @ParserDescrCore.nameLit
-@[matchPattern] abbrev ParserDescr.ident := @ParserDescrCore.ident
-@[matchPattern] abbrev ParserDescr.nonReservedSymbol := @ParserDescrCore.nonReservedSymbol
-@[matchPattern] abbrev ParserDescr.parser := @ParserDescrCore.parser
+instance ParserDescr.inhabited : Inhabited ParserDescr := ⟨ParserDescr.symbol "" none⟩
+abbrev TrailingParserDescr := ParserDescr
 
 /- Syntax -/
 
diff --git a/stage0/stdlib/Init/Lean/Elab/BuiltinNotation.c b/stage0/stdlib/Init/Lean/Elab/BuiltinNotation.c
index d757465b3a..42a51a0d45 100644
--- a/stage0/stdlib/Init/Lean/Elab/BuiltinNotation.c
+++ b/stage0/stdlib/Init/Lean/Elab/BuiltinNotation.c
@@ -84,7 +84,6 @@ lean_object* l___regBuiltinMacro_Lean_Elab_Term_elabModN___closed__1;
 extern lean_object* l_Lean_Parser_Term_show___elambda__1___closed__2;
 lean_object* l_Lean_Elab_Term_elabMul___closed__2;
 extern lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
-extern lean_object* l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
 extern lean_object* l_Array_empty___closed__1;
 lean_object* l_Lean_Elab_Term_elabPow___closed__3;
 lean_object* lean_environment_find(lean_object*, lean_object*);
@@ -526,6 +525,7 @@ lean_object* l_Lean_Elab_Term_elabProd(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabSub___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabTParserMacro___lambda__1___closed__2;
 lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__24;
+extern lean_object* l_Lean_Parser_Term_dollar___elambda__1___closed__2;
 lean_object* l___regBuiltinMacro_Lean_Elab_Term_elabDiv(lean_object*);
 lean_object* l_Lean_Elab_Term_elabNe___closed__1;
 lean_object* l_Lean_Elab_Term_elabTParserMacro___lambda__1___closed__4;
@@ -1024,7 +1024,7 @@ lean_object* l_Lean_Elab_Term_expandDollar(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_46; uint8_t x_47; 
-x_46 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+x_46 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
 lean_inc(x_1);
 x_47 = l_Lean_Syntax_isOfKind(x_1, x_46);
 if (x_47 == 0)
@@ -1166,7 +1166,7 @@ lean_object* l___regBuiltinMacro_Lean_Elab_Term_expandDollar(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+x_2 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
 x_3 = l___regBuiltinMacro_Lean_Elab_Term_expandDollar___closed__1;
 x_4 = l_Lean_Elab_addBuiltinMacro(x_2, x_3, x_1);
 return x_4;
diff --git a/stage0/stdlib/Init/Lean/Elab/Level.c b/stage0/stdlib/Init/Lean/Elab/Level.c
index 65f4c83fd6..68c2523844 100644
--- a/stage0/stdlib/Init/Lean/Elab/Level.c
+++ b/stage0/stdlib/Init/Lean/Elab/Level.c
@@ -30,6 +30,7 @@ lean_object* l_Lean_Syntax_getIdAt(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Level_LevelElabM_MonadLog___lambda__3(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Level_max___elambda__1___closed__1;
 lean_object* lean_array_get_size(lean_object*);
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 extern lean_object* l_String_splitAux___main___closed__1;
 lean_object* l___private_Init_Data_Array_Basic_4__foldrRangeMAux___main___at_Lean_Elab_Level_elabLevel___main___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Level_elabLevel(lean_object*, lean_object*, lean_object*);
@@ -95,7 +96,6 @@ lean_object* l_Lean_Elab_Level_LevelElabM_MonadLog___lambda__2___boxed(lean_obje
 lean_object* l_Lean_Elab_throwError___at_Lean_Elab_Level_elabLevel___main___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_numeral(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Level_elabLevel___main___closed__4;
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
 lean_object* l_Lean_Elab_getPos___at_Lean_Elab_Level_elabLevel___main___spec__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Level_elabLevel___main___closed__2;
 lean_object* l_Lean_Elab_Level_elabLevel___main___closed__8;
@@ -1264,7 +1264,7 @@ x_75 = l_Lean_Syntax_getArg(x_1, x_74);
 lean_dec(x_1);
 x_76 = l_Lean_Syntax_getArgs(x_75);
 lean_dec(x_75);
-x_77 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_76);
+x_77 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_76);
 x_78 = l_Lean_Elab_Level_elabLevel___main(x_77, x_2, x_3);
 if (lean_obj_tag(x_78) == 0)
 {
@@ -1330,7 +1330,7 @@ x_93 = l_Lean_Syntax_getArg(x_1, x_92);
 lean_dec(x_1);
 x_94 = l_Lean_Syntax_getArgs(x_93);
 lean_dec(x_93);
-x_95 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_94);
+x_95 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_94);
 x_96 = l_Lean_Elab_Level_elabLevel___main(x_95, x_2, x_3);
 if (lean_obj_tag(x_96) == 0)
 {
diff --git a/stage0/stdlib/Init/Lean/Elab/Quotation.c b/stage0/stdlib/Init/Lean/Elab/Quotation.c
index b3a4ce2fe3..e99f7d8774 100644
--- a/stage0/stdlib/Init/Lean/Elab/Quotation.c
+++ b/stage0/stdlib/Init/Lean/Elab/Quotation.c
@@ -40,7 +40,6 @@ extern lean_object* l___private_Init_Lean_Compiler_InitAttr_2__isUnitType___clos
 lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41;
 lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13;
-lean_object* l_Lean_Parser_mkParserContext(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_declareBuiltinParser___closed__8;
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__2(lean_object*);
@@ -139,6 +138,7 @@ extern lean_object* l_Lean_Parser_Term_num___elambda__1___closed__1;
 lean_object* l_List_range(lean_object*);
 lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__2;
 lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__12;
 extern lean_object* l_String_splitAux___main___closed__1;
 lean_object* l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder;
@@ -267,7 +267,6 @@ extern lean_object* l_Lean_Parser_Syntax_paren___elambda__1___closed__1;
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__4;
 lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__52;
 lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM(lean_object*);
-extern lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__3;
 lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__6(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Unhygienic_run___rarg(lean_object*);
@@ -316,6 +315,7 @@ extern lean_object* l_Lean_Parser_termParser___closed__2;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 extern lean_object* l_Lean_choiceKind;
 lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__2;
+extern lean_object* l_Lean_Parser_darrow___elambda__1___closed__3;
 lean_object* l_Lean_Elab_Term_throwError___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__28;
 extern lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__2;
@@ -361,6 +361,7 @@ extern lean_object* l_Lean_Parser_Term_let___elambda__1___closed__2;
 lean_object* l___regBuiltinTermElab_Lean_Elab_Term_Quotation_elabMatchSyntax(lean_object*);
 lean_object* l_List_redLength___main___rarg(lean_object*);
 lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_getTokenTable(lean_object*);
 lean_object* l_Lean_List_hasQuote(lean_object*);
 lean_object* l_ReaderT_bind___at_Lean_Elab_Term_monadLog___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -381,7 +382,6 @@ extern lean_object* l_Lean_Elab_Term_elabListLit___closed__5;
 extern lean_object* l___private_Init_Lean_Meta_Message_1__run_x3f___rarg___closed__1;
 lean_object* l_Lean_Option_hasQuote(lean_object*);
 uint8_t l_Lean_Syntax_isAtom(lean_object*);
-lean_object* l_Lean_Parser_categoryParserFn(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_nullKind___closed__2;
 extern lean_object* l_Lean_Parser_Term_if___elambda__1___closed__1;
 lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__3___boxed(lean_object*, lean_object*);
@@ -458,6 +458,7 @@ lean_object* l_Lean_Elab_Term_Quotation_oldParseExpr___closed__1;
 lean_object* l_Lean_LocalContext_mkLambda(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__25;
 extern lean_object* l_Lean_mkHole___closed__1;
+lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40;
 lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_adaptExpander(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -595,7 +596,6 @@ lean_object* l_Lean_Elab_Term_Quotation_getAntiquotTerm___boxed(lean_object*);
 lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__1;
 extern lean_object* l_Lean_mkAppStx___closed__1;
 uint8_t l_Lean_Elab_Term_Quotation_HeadInfo_generalizes(lean_object*, lean_object*);
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
 lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_zipWith___main___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8;
@@ -11575,7 +11575,7 @@ lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main__
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_darrow___elambda__1___rarg___closed__3;
+x_1 = l_Lean_Parser_darrow___elambda__1___closed__3;
 x_2 = l_Lean_mkAtom(x_1);
 return x_2;
 }
@@ -25019,47 +25019,52 @@ return x_1;
 lean_object* lean_parse_expr(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; lean_object* x_11; lean_object* x_12; 
+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; 
 x_4 = l_Lean_Elab_Term_Quotation_oldParseExpr___closed__1;
 lean_inc(x_2);
 x_5 = l_Lean_Parser_mkInputContext(x_2, x_4);
-x_6 = l_Lean_Parser_mkParserContext(x_1, x_5);
-x_7 = l_Lean_Parser_mkParserState(x_2);
+x_6 = l_Lean_Parser_mkParserState(x_2);
 lean_dec(x_2);
-x_8 = l_Lean_Parser_ParserState_setPos(x_7, x_3);
-x_9 = l_Lean_Parser_termParser___closed__2;
-x_10 = l_Lean_Parser_appPrec;
-x_11 = l_Lean_Parser_categoryParserFn(x_9, x_10, x_6, x_8);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-x_13 = lean_ctor_get(x_11, 0);
+x_7 = l_Lean_Parser_ParserState_setPos(x_6, x_3);
+x_8 = l_Lean_Parser_getTokenTable(x_1);
+x_9 = l_Lean_Parser_appPrec;
+x_10 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_10, 0, x_5);
+lean_ctor_set(x_10, 1, x_9);
+lean_ctor_set(x_10, 2, x_1);
+lean_ctor_set(x_10, 3, x_8);
+x_11 = l_Lean_Parser_termParser___closed__2;
+x_12 = l_Lean_Parser_categoryParser___elambda__1(x_11, x_9, x_10, x_7);
+x_13 = lean_ctor_get(x_12, 3);
 lean_inc(x_13);
-x_14 = lean_ctor_get(x_11, 1);
+if (lean_obj_tag(x_13) == 0)
+{
+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);
-lean_dec(x_11);
-x_15 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_13);
-lean_dec(x_13);
-x_16 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_16, 0, x_15);
-lean_ctor_set(x_16, 1, x_14);
-x_17 = lean_alloc_ctor(1, 1, 0);
+x_15 = lean_ctor_get(x_12, 1);
+lean_inc(x_15);
+lean_dec(x_12);
+x_16 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_14);
+lean_dec(x_14);
+x_17 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_17, 0, x_16);
-return x_17;
+lean_ctor_set(x_17, 1, x_15);
+x_18 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_18, 0, x_17);
+return x_18;
 }
 else
 {
-lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_dec(x_11);
-x_18 = lean_ctor_get(x_12, 0);
-lean_inc(x_18);
+lean_object* x_19; lean_object* x_20; lean_object* x_21; 
 lean_dec(x_12);
-x_19 = l_Lean_Parser_Error_toString(x_18);
-x_20 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_20, 0, x_19);
-return x_20;
+x_19 = lean_ctor_get(x_13, 0);
+lean_inc(x_19);
+lean_dec(x_13);
+x_20 = l_Lean_Parser_Error_toString(x_19);
+x_21 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_21, 0, x_20);
+return x_21;
 }
 }
 }
diff --git a/stage0/stdlib/Init/Lean/Elab/Syntax.c b/stage0/stdlib/Init/Lean/Elab/Syntax.c
index fb7f13990a..ca3af7d80c 100644
--- a/stage0/stdlib/Init/Lean/Elab/Syntax.c
+++ b/stage0/stdlib/Init/Lean/Elab/Syntax.c
@@ -17,6 +17,7 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__45;
 lean_object* l_Lean_Elab_Command_elabSyntax___closed__11;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__34;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__95;
+extern lean_object* l_Lean_Parser_Syntax_many___elambda__1___closed__1;
 lean_object* l_Lean_Elab_Term_getEnv___rarg(lean_object*);
 extern lean_object* l_Lean_Name_toString___closed__1;
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__2;
@@ -35,6 +36,7 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__12;
 lean_object* l_Lean_Name_eraseMacroScopes(lean_object*);
 lean_object* l_Lean_Syntax_isNatLitAux(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_expandNotation___closed__2;
+extern lean_object* l_Lean_Parser_Syntax_many___elambda__1___closed__2;
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Command_expandNotation___spec__4(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_getOptions(lean_object*, lean_object*);
 extern lean_object* l_Lean_Macro_throwUnsupported___closed__1;
@@ -47,6 +49,7 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__75;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__15;
 lean_object* l___regBuiltinCommandElab_Lean_Elab_Command_elabReserve(lean_object*);
 extern lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__1;
+extern lean_object* l_Lean_Parser_Syntax_many1___elambda__1___closed__1;
 lean_object* l___private_Init_Lean_Elab_Syntax_1__expandOptPrecedence(lean_object*);
 extern lean_object* l_Lean_Elab_Term_elabArrayLit___closed__13;
 lean_object* l_Lean_Elab_Command_elabSyntax___closed__36;
@@ -72,16 +75,15 @@ extern lean_object* l___private_Init_Lean_Elab_TermBinders_10__expandFunBindersA
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__5;
 extern lean_object* l_Lean_Elab_registerBuiltinMacroAttr___lambda__1___closed__5;
 uint8_t lean_name_eq(lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Syntax_many1___elambda__1___closed__2;
 lean_object* l_Lean_Elab_Command_Macro_mkFreshKind(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__104;
 lean_object* l___regBuiltinCommandElab_Lean_Elab_Command_elabReserve___closed__1;
 lean_object* l_Lean_Syntax_getIdAt(lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2;
 extern lean_object* l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__33;
 lean_object* lean_array_fswap(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_identKind___closed__2;
-extern lean_object* l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__13;
 extern lean_object* l_Lean_Elab_Command_runTermElabM___rarg___closed__1;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__23;
@@ -89,8 +91,10 @@ lean_object* l_Lean_Elab_Command_elabSyntax___closed__7;
 lean_object* l_Lean_Elab_Command_expandMacroArgIntoPattern(lean_object*, lean_object*);
 extern lean_object* l_PersistentHashMap_mkCollisionNode___rarg___closed__1;
 lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Syntax_7__antiquote___main___spec__5(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Syntax_orelse___elambda__1___closed__1;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__101;
 extern lean_object* l_Array_empty___closed__1;
+extern lean_object* l_Lean_Parser_unquotedSymbolFn___closed__1;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__46;
 lean_object* l_Array_mapSepElemsM___at_Lean_Elab_Command_elabMacroRulesAux___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltinCommandElab_Lean_Elab_Command_elabReserve___closed__2;
@@ -125,7 +129,6 @@ lean_object* l___private_Init_Lean_Elab_Syntax_8__regTraceClasses(lean_object*);
 lean_object* l_Lean_Elab_Command_elabSyntax___closed__20;
 lean_object* l___regBuiltinCommandElab_Lean_Elab_Command_elabDeclareSyntaxCat___closed__2;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__9;
-extern lean_object* l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Elab_Term_toParserDescrAux(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__81;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__6;
@@ -242,6 +245,7 @@ extern lean_object* l_Lean_strLitKind___closed__1;
 extern lean_object* l___private_Init_Lean_Elab_TermBinders_10__expandFunBindersAux___main___closed__6;
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__32;
+extern lean_object* l_Lean_Parser_Syntax_optional___elambda__1___closed__1;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__10;
 extern lean_object* l_Lean_Elab_Term_mkConst___closed__4;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__1;
@@ -250,7 +254,6 @@ extern lean_object* l_Lean_Unhygienic_MonadQuotation___closed__4;
 lean_object* l___private_Init_LeanInit_14__filterSepElemsMAux___main___at_Lean_Elab_Command_elabNoKindMacroRulesAux___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltinMacro_Lean_Elab_Command_expandNotation___closed__1;
 lean_object* l_Lean_Elab_Command_elabSyntax___closed__29;
-extern lean_object* l_Lean_Parser_unquotedSymbolFn___rarg___closed__1;
 lean_object* l_Array_filterAux___main___at_Lean_Elab_Command_expandNotation___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__20;
 extern lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__4;
@@ -259,7 +262,6 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__56;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__66;
 lean_object* l_Nat_repr(lean_object*);
 extern lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11;
-extern lean_object* l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2;
 extern lean_object* l_Lean_Parser_Command_attrInstance___elambda__1___closed__2;
 extern lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__3;
 lean_object* l_Lean_Elab_Command_elabMacroRules(lean_object*, lean_object*, lean_object*);
@@ -268,7 +270,6 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__37;
 lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux___closed__4;
 lean_object* l___private_Init_Lean_Elab_Command_1__ioErrorToMessage(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getId(lean_object*);
-extern lean_object* l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__7;
 lean_object* l_Lean_Elab_Command_adaptExpander(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabSyntax___closed__33;
@@ -406,12 +407,11 @@ lean_object* l_Lean_Elab_Command_getMainModule(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_Syntax_3__markAsTrailingParser___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__31;
 extern lean_object* l_Lean_Elab_Term_elabArrayLit___closed__12;
-extern lean_object* l_Lean_Parser_mkAntiquotAux___closed__1;
+extern lean_object* l_Lean_Parser_Syntax_optional___elambda__1___closed__2;
 extern lean_object* l_Lean_Parser_Command_reserve___elambda__1___closed__2;
 lean_object* l_Lean_Elab_Command_elabSyntax___closed__8;
 lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__7;
-extern lean_object* l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2;
 lean_object* l_Lean_Syntax_getArgs(lean_object*);
 lean_object* l_Lean_Elab_Term_checkLeftRec___closed__3;
 lean_object* l___regBuiltinCommandElab_Lean_Elab_Command_elabReserve___closed__3;
@@ -550,7 +550,6 @@ extern lean_object* l_Lean_mkAppStx___closed__2;
 extern lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__3;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__23;
 extern lean_object* l_Lean_Elab_mkMacroAttribute___closed__1;
-extern lean_object* l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__2;
 lean_object* l___private_Init_Lean_Elab_Syntax_4__withNotFirst___rarg(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 extern lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6;
@@ -583,6 +582,7 @@ lean_object* l_Lean_Elab_Command_expandNotationItemIntoSyntaxItem___boxed(lean_o
 lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__59;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__82;
 extern lean_object* l_Lean_Parser_Command_declId___elambda__1___closed__2;
+extern lean_object* l_Lean_Parser_mkAntiquot___closed__1;
 lean_object* l_Lean_Elab_Command_logTrace(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_Syntax_1__expandOptPrecedence(lean_object* x_1) {
 _start:
@@ -1594,7 +1594,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__4;
-x_2 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Syntax_optional___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -1604,7 +1604,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__6;
-x_2 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Syntax_optional___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -1669,7 +1669,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__4;
-x_2 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Syntax_many1___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -1679,7 +1679,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__6;
-x_2 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Syntax_many1___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -1744,7 +1744,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__4;
-x_2 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Syntax_many___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -1754,7 +1754,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__6;
-x_2 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Syntax_many___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -2419,7 +2419,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__4;
-x_2 = l_Lean_Parser_unquotedSymbolFn___rarg___closed__1;
+x_2 = l_Lean_Parser_unquotedSymbolFn___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -2429,7 +2429,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__6;
-x_2 = l_Lean_Parser_unquotedSymbolFn___rarg___closed__1;
+x_2 = l_Lean_Parser_unquotedSymbolFn___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -2810,22 +2810,22 @@ x_32 = lean_name_eq(x_6, x_31);
 if (x_32 == 0)
 {
 lean_object* x_33; uint8_t x_34; 
-x_33 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2;
+x_33 = l_Lean_Parser_Syntax_many___elambda__1___closed__2;
 x_34 = lean_name_eq(x_6, x_33);
 if (x_34 == 0)
 {
 lean_object* x_35; uint8_t x_36; 
-x_35 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2;
+x_35 = l_Lean_Parser_Syntax_many1___elambda__1___closed__2;
 x_36 = lean_name_eq(x_6, x_35);
 if (x_36 == 0)
 {
 lean_object* x_37; uint8_t x_38; 
-x_37 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2;
+x_37 = l_Lean_Parser_Syntax_optional___elambda__1___closed__2;
 x_38 = lean_name_eq(x_6, x_37);
 if (x_38 == 0)
 {
 lean_object* x_39; uint8_t x_40; 
-x_39 = l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1;
+x_39 = l_Lean_Parser_Syntax_orelse___elambda__1___closed__1;
 x_40 = lean_name_eq(x_6, x_39);
 if (x_40 == 0)
 {
@@ -12763,7 +12763,7 @@ x_36 = lean_array_push(x_35, x_34);
 x_37 = l_Lean_mkOptionalNode___closed__1;
 x_38 = lean_array_push(x_36, x_37);
 x_39 = lean_array_push(x_38, x_37);
-x_40 = l_Lean_Parser_mkAntiquotAux___closed__1;
+x_40 = l_Lean_Parser_mkAntiquot___closed__1;
 x_41 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_41, 0, x_40);
 lean_ctor_set(x_41, 1, x_39);
@@ -13101,7 +13101,7 @@ x_21 = lean_array_push(x_20, x_19);
 x_22 = l_Lean_mkOptionalNode___closed__1;
 x_23 = lean_array_push(x_21, x_22);
 x_24 = lean_array_push(x_23, x_22);
-x_25 = l_Lean_Parser_mkAntiquotAux___closed__1;
+x_25 = l_Lean_Parser_mkAntiquot___closed__1;
 x_26 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_26, 0, x_25);
 lean_ctor_set(x_26, 1, x_24);
@@ -14065,7 +14065,7 @@ x_14 = lean_array_push(x_13, x_12);
 x_15 = l_Lean_mkOptionalNode___closed__1;
 x_16 = lean_array_push(x_14, x_15);
 x_17 = lean_array_push(x_16, x_15);
-x_18 = l_Lean_Parser_mkAntiquotAux___closed__1;
+x_18 = l_Lean_Parser_mkAntiquot___closed__1;
 x_19 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_19, 0, x_18);
 lean_ctor_set(x_19, 1, x_17);
diff --git a/stage0/stdlib/Init/Lean/Elab/Tactic/Basic.c b/stage0/stdlib/Init/Lean/Elab/Tactic/Basic.c
index 2eaaca0332..7431fc4dd5 100644
--- a/stage0/stdlib/Init/Lean/Elab/Tactic/Basic.c
+++ b/stage0/stdlib/Init/Lean/Elab/Tactic/Basic.c
@@ -217,7 +217,6 @@ lean_object* l___regBuiltinTactic_Lean_Elab_Tactic_evalTraceState___closed__3;
 lean_object* l_Lean_Elab_Tactic_getMainGoal(lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltinTactic_Lean_Elab_Tactic_evalCase___closed__3;
 extern lean_object* l_Lean_Parser_declareBuiltinParser___closed__7;
-extern lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Elab_Tactic_evalTactic___main___spec__8(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_monadLog___closed__8;
 extern lean_object* l_Lean_Parser_Tactic_skip___elambda__1___closed__2;
@@ -328,6 +327,7 @@ uint8_t l_PersistentHashMap_containsAtAux___main___at_Lean_Parser_isValidSyntaxN
 lean_object* l_Lean_Elab_Tactic_addBuiltinTactic(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_modifyMCtx(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_tagUntaggedGoals(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___closed__1;
 lean_object* l_Lean_Elab_Tactic_getOptions___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_declareBuiltinTactic___closed__2;
 lean_object* l_Lean_Elab_Tactic_withMVarContext___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -14896,7 +14896,7 @@ lean_object* l_Lean_Elab_Tactic_evalOrelse(lean_object* x_1, lean_object* x_2, l
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
-x_4 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1;
+x_4 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__1;
 lean_inc(x_1);
 x_5 = l_Lean_Syntax_isOfKind(x_1, x_4);
 if (x_5 == 0)
@@ -15021,7 +15021,7 @@ lean_object* l___regBuiltinTactic_Lean_Elab_Tactic_evalOrelse(lean_object* x_1)
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__1;
 x_3 = l___regBuiltinTactic_Lean_Elab_Tactic_evalOrelse___closed__2;
 x_4 = l___regBuiltinTactic_Lean_Elab_Tactic_evalOrelse___closed__3;
 x_5 = l_Lean_Elab_Tactic_addBuiltinTactic(x_2, x_3, x_4, x_1);
diff --git a/stage0/stdlib/Init/Lean/Elab/Term.c b/stage0/stdlib/Init/Lean/Elab/Term.c
index 4bd6790615..e77774a28f 100644
--- a/stage0/stdlib/Init/Lean/Elab/Term.c
+++ b/stage0/stdlib/Init/Lean/Elab/Term.c
@@ -169,6 +169,7 @@ lean_object* l_Lean_Elab_Term_elabBadCDot___boxed(lean_object*, lean_object*, le
 extern lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
 lean_object* l_Lean_Expr_getAppFn___main(lean_object*);
 lean_object* l_PersistentArray_push___rarg(lean_object*, lean_object*);
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 lean_object* l___regBuiltinTermElab_Lean_Elab_Term_elabTypeStx___closed__2;
 extern lean_object* l_String_splitAux___main___closed__1;
 lean_object* l_Lean_Elab_Term_logTrace___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -331,7 +332,6 @@ lean_object* l___private_Init_Lean_Elab_Term_6__exceptionToSorry___closed__1;
 lean_object* l_Lean_Elab_Term_TermElabM_inhabited(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_mkInstMVar(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_declareBuiltinTermElab___closed__6;
-extern lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__3;
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_levelMVarToParam___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_Term_8__elabTermUsing(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
@@ -384,6 +384,7 @@ lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_getLevel___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__2;
 lean_object* l_Lean_Elab_Term_trySynthInstance___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_darrow___elambda__1___closed__3;
 lean_object* l___regBuiltinTermElab_Lean_Elab_Term_elabRawCharLit(lean_object*);
 lean_object* l___regBuiltinTermElab_Lean_Elab_Term_elabTypeStx(lean_object*);
 lean_object* l_Lean_Elab_Term_isClass___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -797,7 +798,6 @@ lean_object* l_Lean_Elab_Term_getMCtx___rarg(lean_object*);
 extern lean_object* l_Lean_mkAppStx___closed__1;
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Term_3__fromMetaState___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentArray_foldlM___at___private_Init_Lean_Elab_Term_3__fromMetaState___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
 lean_object* l_Lean_Elab_Term_Lean_Elab_MonadMacroAdapter___closed__4;
 lean_object* l_Lean_Elab_Term_monadLog___closed__4;
 lean_object* l_Lean_Meta_isType(lean_object*, lean_object*, lean_object*);
@@ -10646,7 +10646,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_darrow___elambda__1___rarg___closed__3;
+x_2 = l_Lean_Parser_darrow___elambda__1___closed__3;
 x_3 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -18733,7 +18733,7 @@ x_4 = lean_array_get_size(x_1);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
 lean_dec(x_4);
-x_7 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_1);
+x_7 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_1);
 x_8 = l___private_Init_Lean_Elab_Term_10__mkPairsAux___main(x_1, x_6, x_7, x_2, x_3);
 return x_8;
 }
diff --git a/stage0/stdlib/Init/Lean/Elab/TermApp.c b/stage0/stdlib/Init/Lean/Elab/TermApp.c
index 8d3ebb1ce1..2e009ecb35 100644
--- a/stage0/stdlib/Init/Lean/Elab/TermApp.c
+++ b/stage0/stdlib/Init/Lean/Elab/TermApp.c
@@ -234,10 +234,10 @@ lean_object* l___private_Init_Lean_Elab_TermApp_14__resolveLValAux___closed__7;
 lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_TermApp_26__elabAppAux___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_formatEntry___closed__1;
 extern lean_object* l_Lean_Elab_Term_TermElabResult_inhabited;
-extern lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
 uint8_t l_Lean_Expr_Data_binderInfo(uint64_t);
 lean_object* l_Lean_Elab_Term_TermElabM_inhabited___boxed(lean_object*, lean_object*);
 lean_object* l___regBuiltinTermElab_Lean_Elab_Term_elabExplicit___closed__1;
+extern lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_TermApp_26__elabAppAux___closed__3;
 lean_object* l___private_Init_Lean_Elab_TermApp_23__getSuccess(lean_object*);
@@ -369,6 +369,7 @@ lean_object* l_Array_insertAt___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_ReaderT_pure___at___private_Init_Lean_Elab_TermApp_27__expandApp___spec__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_findField_x3f___main(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_TermApp_18__addLValArg___main___closed__6;
+extern lean_object* l_Lean_Parser_Term_sortApp___elambda__1___closed__2;
 lean_object* l_Lean_Name_components(lean_object*);
 lean_object* l_Array_forMAux___main___at___private_Init_Lean_Elab_TermApp_15__resolveLValLoop___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Elab_Term_elabExplicitUniv___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -382,7 +383,6 @@ lean_object* l___private_Init_Lean_Elab_TermApp_14__resolveLValAux___closed__16;
 lean_object* l___private_Init_Lean_Elab_TermApp_14__resolveLValAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Elab_TermApp_18__addLValArg___main___closed__4;
 lean_object* l___private_Init_Lean_Elab_TermApp_7__getForallBody(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2;
 lean_object* l_Lean_Elab_Term_Arg_inhabited;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_getPosition___at___private_Init_Lean_Elab_TermApp_24__toMessageData___spec__1___boxed(lean_object*, lean_object*, lean_object*);
@@ -9380,7 +9380,7 @@ x_186 = l_coeDecidableEq(x_185);
 if (x_186 == 0)
 {
 lean_object* x_187; uint8_t x_188; 
-x_187 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+x_187 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 lean_inc(x_2);
 x_188 = l_Lean_Syntax_isOfKind(x_2, x_187);
 if (x_188 == 0)
@@ -12639,7 +12639,7 @@ lean_object* l___regBuiltinTermElab_Lean_Elab_Term_elabArrayRef(lean_object* x_1
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+x_2 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 x_3 = l___regBuiltinTermElab_Lean_Elab_Term_elabArrayRef___closed__2;
 x_4 = l___regBuiltinTermElab_Lean_Elab_Term_elabArrayRef___closed__3;
 x_5 = l_Lean_Elab_Term_addBuiltinTermElab(x_2, x_3, x_4, x_1);
@@ -12828,7 +12828,7 @@ lean_object* l___regBuiltinTermElab_Lean_Elab_Term_elabSortApp(lean_object* x_1)
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2;
+x_2 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2;
 x_3 = l___regBuiltinTermElab_Lean_Elab_Term_elabSortApp___closed__2;
 x_4 = l___regBuiltinTermElab_Lean_Elab_Term_elabSortApp___closed__3;
 x_5 = l_Lean_Elab_Term_addBuiltinTermElab(x_2, x_3, x_4, x_1);
diff --git a/stage0/stdlib/Init/Lean/Parser/Command.c b/stage0/stdlib/Init/Lean/Parser/Command.c
index 8ac82c4e43..de4a381626 100644
--- a/stage0/stdlib/Init/Lean/Parser/Command.c
+++ b/stage0/stdlib/Init/Lean/Parser/Command.c
@@ -23,7 +23,7 @@ lean_object* l_Lean_Parser_Command_def___closed__5;
 lean_object* l_Lean_Parser_Command_structure___closed__7;
 lean_object* l_Lean_Parser_Command_section___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_open___closed__3;
-lean_object* l_Lean_Parser_Command_check___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_check___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_structImplicitBinder___closed__8;
 lean_object* l_Lean_Parser_Command_structureTk___closed__2;
@@ -36,15 +36,15 @@ lean_object* l_Lean_Parser_Command_extends___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_structure___closed__3;
 lean_object* l_Lean_Parser_Command_def___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_constant___closed__6;
-lean_object* l_Lean_Parser_Command_visibility___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_visibility___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structExplicitBinder___closed__8;
 lean_object* l_Lean_Parser_Command_protected___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_declSig___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_openRenamingItem___closed__6;
 lean_object* l_Lean_Parser_Command_axiom___closed__5;
 lean_object* l_Lean_Parser_Command_section___closed__3;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_exit___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_exit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_abbrev___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_extends___closed__2;
 lean_object* l_Lean_Parser_Command_open___closed__5;
@@ -55,14 +55,14 @@ lean_object* l_Lean_Parser_regBuiltinCommandParserAttr___closed__1;
 lean_object* l_Lean_Parser_Command_instance___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_variable(lean_object*);
 lean_object* l_Lean_Parser_Command_visibility;
-lean_object* l_Lean_Parser_Command_inductive___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_inductive___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_stxQuot___closed__8;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_matchAlt___closed__3;
 lean_object* l_Lean_Parser_Command_structImplicitBinder___closed__2;
 lean_object* l_Lean_Parser_Command_extends___elambda__1___closed__7;
-lean_object* l_Lean_Parser_Command_end___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_end___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_extends___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_section(lean_object*);
@@ -92,14 +92,14 @@ lean_object* l_Lean_Parser_Command_structCtor___closed__4;
 lean_object* l_Lean_Parser_Command_resolve__name___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_protected___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__6;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_haveAssign___closed__2;
 lean_object* l_Lean_Parser_Command_structExplicitBinder___closed__11;
 lean_object* l_Lean_Parser_Command_declId___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_openRenaming;
 lean_object* l_Lean_Parser_Command_variables___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_partial___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Command_classInductive___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_classInductive___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_openHiding;
 lean_object* l_Lean_Parser_Command_synth___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_declModifiers___closed__8;
@@ -110,7 +110,7 @@ lean_object* l_Lean_Parser_Command_partial___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_export___closed__8;
 lean_object* l_Lean_Parser_Command_structFields___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_structInstBinder___closed__5;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_extends___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_example___closed__5;
 lean_object* l_Lean_Parser_Command_openOnly;
@@ -119,11 +119,11 @@ lean_object* l_Lean_Parser_Command_export___closed__7;
 lean_object* l_Lean_Parser_Command_open___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_attrInstance___closed__4;
 lean_object* l_Lean_Parser_Command_resolve__name___elambda__1___closed__2;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structFields___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structFields___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_introRule___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_init__quot___closed__5;
 lean_object* l_Lean_Parser_Command_extends___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Command_synth___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_synth___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_unsafe___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_inductive___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_declaration___closed__7;
@@ -135,12 +135,13 @@ lean_object* l_Lean_Parser_Command_extends___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_antiquot___closed__1;
 lean_object* l_Lean_Parser_Command_exit___closed__1;
 lean_object* l_Lean_Parser_Command_export___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Command_declVal___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_declVal___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_unsafe___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_structureTk___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_openRenaming___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_openRenamingItem___closed__3;
 lean_object* l_Lean_Parser_Command_structInstBinder___closed__3;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Command_export___elambda__1___closed__3;
 extern lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_attribute___elambda__1___closed__12;
@@ -154,6 +155,7 @@ lean_object* l_Lean_Parser_Command_declaration___closed__3;
 lean_object* l_Lean_Parser_Command_theorem___elambda__1___closed__9;
 lean_object* l_Lean_Parser_ParserState_pushSyntax(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_abbrev;
+extern lean_object* l_Lean_Parser_ident;
 lean_object* l_Lean_Parser_Command_private___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_instance___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_export___elambda__1___closed__7;
@@ -178,7 +180,7 @@ lean_object* l_Lean_Parser_ParserState_mkNode(lean_object*, lean_object*, lean_o
 lean_object* l_Lean_Parser_Command_visibility___closed__1;
 lean_object* l_Lean_Parser_Command_universes___closed__2;
 lean_object* l_Lean_Parser_Command_exit___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Command_declValSimple___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_declValSimple___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Command_export(lean_object*);
 lean_object* l_Lean_Parser_Command_inductive___closed__5;
 lean_object* l_Lean_Parser_Command_section___closed__4;
@@ -198,19 +200,18 @@ lean_object* l_Lean_Parser_Command_structure___closed__1;
 lean_object* l_Lean_Parser_Command_structureTk___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_check___closed__5;
 lean_object* l_Lean_Parser_Command_def___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Command_attrArg___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_attrArg___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_stxQuot___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_classInductive___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_exit___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__3;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_example;
 lean_object* l_Lean_Parser_Command_classTk___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_theorem___closed__3;
 lean_object* l_Lean_Parser_registerBuiltinDynamicParserAttribute(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_visibility___closed__2;
 lean_object* l_Lean_Parser_Command_classInductive___elambda__1___closed__3;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_declId___closed__4;
 lean_object* l_Lean_Parser_Command_end;
 lean_object* l_Lean_Parser_Command_antiquot;
@@ -223,24 +224,25 @@ lean_object* l_Lean_Parser_Command_abbrev___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_openRenaming___closed__4;
 lean_object* l_Lean_Parser_Command_example___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_attribute___closed__10;
-lean_object* l_Lean_Parser_addBuiltinParser(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_addBuiltinParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_attrInstance___elambda__1___closed__4;
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Lean_Parser_Command_structFields;
 lean_object* l_Lean_Parser_Command_abbrev___closed__3;
 lean_object* l_Lean_Parser_Command_declId___closed__9;
-lean_object* l_Lean_Parser_Command_strictInferMod___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_strictInferMod___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_declId___closed__8;
 lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_declValEqns___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_abbrev___closed__7;
 lean_object* l_Lean_Parser_tokenFn(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_stxQuot___elambda__1___closed__1;
 extern lean_object* l_Lean_Parser_Term_listLit___closed__4;
 lean_object* l_Lean_Parser_Command_section___elambda__1___closed__8;
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_Command_declModifiers___closed__13;
 lean_object* l_Lean_Parser_Command_universes___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_declaration___closed__10;
@@ -258,17 +260,16 @@ lean_object* l_Lean_Parser_Command_openSimple;
 lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__1;
 extern lean_object* l_Lean_Syntax_termIdToAntiquot___closed__1;
 lean_object* l_Lean_Parser_Command_instance;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_instance___closed__8;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_openOnly___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_structFields___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_attrInstance___elambda__1___closed__5;
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_openOnly___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_structFields___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_export___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_variables___closed__1;
 lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_synth___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Command_instance___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_instance___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_docComment___closed__2;
 lean_object* l_Lean_Parser_regBuiltinCommandParserAttr___closed__2;
 lean_object* l_Lean_Parser_Command_constant___closed__1;
@@ -276,7 +277,7 @@ lean_object* l_Lean_Parser_Command_strictInferMod___closed__1;
 lean_object* l_Lean_Parser_Command_structFields___elambda__1___closed__1;
 extern lean_object* l_Lean_mkAppStx___closed__4;
 lean_object* l_Lean_Parser_ParserState_mkErrorsAt(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_resolve__name___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_resolve__name___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_openSimple___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_set__option___closed__7;
@@ -305,15 +306,14 @@ lean_object* l_Lean_Parser_Term_stxQuot___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_declId___closed__3;
 lean_object* l_Lean_Parser_Command_namespace___closed__3;
 lean_object* l_Lean_Parser_Command_openHiding___closed__3;
-lean_object* l_Lean_Parser_Command_init__quot___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_init__quot___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_openHiding___closed__5;
 lean_object* l_Lean_Parser_Command_protected___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_introRule___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_openSimple___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Command_introRule___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_introRule___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_example___elambda__1___closed__1;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structFields___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_openRenamingItem___closed__4;
 lean_object* l_Lean_Parser_Command_open___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_extends___closed__5;
@@ -323,17 +323,17 @@ lean_object* l_Lean_Parser_Command_resolve__name___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_variables___closed__6;
 lean_object* l_Lean_Parser_Command_attribute___elambda__1___closed__7;
 lean_object* l_Lean_Parser_finishCommentBlock___main(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_declId___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_declId___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_declaration___closed__12;
 lean_object* l_Lean_Parser_Command_strictInferMod___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_protected;
 lean_object* l_Lean_Parser_Command_universes___closed__6;
 lean_object* l_Lean_Parser_Command_namespace___closed__2;
 lean_object* l_Lean_Parser_Command_strictInferMod___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Command_openRenaming___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_openRenaming___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_theorem___closed__6;
 lean_object* l_Lean_Parser_Command_openHiding___closed__4;
-lean_object* l_Lean_Parser_Command_docComment___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_docComment___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_inductive___closed__7;
 lean_object* l_Lean_Parser_Command_unsafe;
 lean_object* l_Lean_Parser_Command_structure___closed__6;
@@ -346,12 +346,11 @@ lean_object* l_Lean_Parser_Command_variables___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_structure;
 lean_object* l_Lean_Parser_Command_declModifiers___closed__6;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_declaration(lean_object*);
+lean_object* l_Lean_Parser_strLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_openRenamingItem___closed__7;
-extern lean_object* l_Lean_Parser_unicodeSymbolFn___rarg___closed__1;
 lean_object* l_Lean_Parser_Command_attribute___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Command_protected___elambda__1___closed__9;
-extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_check___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__8;
@@ -364,7 +363,7 @@ lean_object* l_Lean_Parser_Command_abbrev___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_variables___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_inferMod___closed__3;
 lean_object* l_Lean_Parser_Command_openHiding___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Command_noncomputable___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_noncomputable___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_resolve__name___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_variables___closed__5;
 lean_object* l_Lean_Parser_Command_attributes___elambda__1___closed__3;
@@ -375,13 +374,13 @@ extern lean_object* l_Lean_Parser_Term_binderDefault;
 lean_object* l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_def___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_resolve__name;
-lean_object* l_Lean_Parser_Command_declValEqns___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_declValEqns___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structExplicitBinder___closed__9;
 lean_object* l_Lean_Parser_Command_attribute___closed__6;
 lean_object* l_Lean_Parser_Command_variables___elambda__1___closed__9;
 extern lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_attrArg___closed__4;
-lean_object* l_Lean_Parser_Command_declaration___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_declaration___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_check(lean_object*);
 lean_object* l_Lean_Parser_Command_exit___elambda__1___closed__2;
@@ -392,7 +391,7 @@ lean_object* l_Lean_Parser_Command_structInstBinder___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_openSimple___closed__1;
 lean_object* l_Lean_Parser_Command_declaration___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_structInstBinder;
-lean_object* l_Lean_Parser_manyAux___main(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_attribute;
 lean_object* l_Lean_Parser_Command_docComment___closed__4;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
@@ -414,7 +413,6 @@ lean_object* l_Lean_Parser_Command_synth___closed__3;
 lean_object* l_Lean_Parser_nodeInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_exit___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_attribute___closed__3;
-lean_object* l_Lean_Parser_commandParser___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_abbrev___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_declModifiers___closed__5;
@@ -431,20 +429,20 @@ lean_object* l_Lean_Parser_Command_export___closed__9;
 lean_object* l_Lean_Parser_noFirstTokenInfo(lean_object*);
 lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__2;
 lean_object* l_Lean_Parser_nonReservedSymbolInfo(lean_object*, uint8_t);
-lean_object* l_Lean_Parser_Command_example___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_example___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_declId___closed__1;
 lean_object* l_Lean_Parser_Command_declModifiers___closed__15;
-lean_object* l_Lean_Parser_Command_attributes___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_attributes___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Command_export___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_commandParser(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_Command_export___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_commandParser(lean_object*);
 lean_object* l_Lean_Parser_Command_classTk___closed__1;
 lean_object* l_Lean_Parser_Command_structInstBinder___elambda__1___closed__3;
 lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_export___closed__4;
 lean_object* l_Lean_Parser_Command_abbrev___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_introRule___closed__1;
-lean_object* l_Lean_Parser_Command_openHiding___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_openHiding___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_docComment___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_universe___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__3;
@@ -457,7 +455,7 @@ lean_object* l_Lean_Parser_Command_classInductive___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_declValSimple___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_protected___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_structFields___elambda__1___closed__2;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_universes___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_structExplicitBinder;
 lean_object* l_Lean_Parser_Command_axiom___closed__7;
@@ -472,7 +470,7 @@ lean_object* l_Lean_Parser_Command_def___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_classTk___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_variable___closed__1;
 lean_object* l_Lean_Parser_regCommandParserAttribute___closed__2;
-lean_object* l_Lean_Parser_Command_namespace___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_namespace___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_section___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_attrArg;
 lean_object* l_Lean_Parser_Command_variables___closed__4;
@@ -485,7 +483,7 @@ lean_object* l_Lean_Parser_Command_unsafe___closed__5;
 lean_object* l_Lean_Parser_Command_classInductive___closed__3;
 lean_object* l_Lean_Parser_Command_optDeclSig;
 lean_object* l_Lean_Parser_Command_def___closed__3;
-lean_object* l_Lean_Parser_Command_extends___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_extends___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_namespace___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_section___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_introRule___closed__4;
@@ -494,17 +492,18 @@ lean_object* l_Lean_Parser_Command_extends___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_inductive___closed__2;
 lean_object* l_Lean_Parser_Command_structure___closed__11;
 lean_object* l_Lean_Parser_Command_axiom___closed__3;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_protected___closed__1;
 lean_object* l_Lean_Parser_Command_docComment___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_declValEqns___closed__2;
-lean_object* l_Lean_Parser_Command_abbrev___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_abbrev___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_instance___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_declModifiers___closed__3;
 lean_object* l_Lean_Parser_Command_classInductive___closed__1;
 extern lean_object* l_Char_HasRepr___closed__1;
 lean_object* l_Lean_Parser_Command_structureTk___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_export___closed__1;
-lean_object* l_Lean_Parser_Command_set__option___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_set__option___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_section___closed__2;
 lean_object* l_Lean_Parser_Command_attrInstance___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_structInstBinder___closed__8;
@@ -513,11 +512,11 @@ lean_object* l_Lean_Parser_Command_docComment___elambda__1___closed__4;
 lean_object* l_Lean_Parser_regCommandParserAttribute___closed__1;
 lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__14;
 lean_object* l_Lean_Parser_Command_structImplicitBinder___closed__5;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_variable___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_variable___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_synth___closed__6;
 lean_object* l_Lean_Parser_orelseInfo(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_attrInstance___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_attrInstance___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structCtor___closed__2;
 lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__5;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_namespace(lean_object*);
@@ -540,7 +539,6 @@ lean_object* l_Lean_Parser_Command_example___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_variable___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_strictInferMod___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_partial___closed__3;
-extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_structExplicitBinder___closed__2;
 lean_object* l_Lean_Parser_Command_openRenaming___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_stxQuot___closed__2;
@@ -550,7 +548,7 @@ lean_object* l_Lean_Parser_Command_namespace___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_partial___closed__5;
 lean_object* l_Lean_Parser_Command_classTk___closed__2;
 lean_object* l_Lean_Parser_Command_variable___elambda__1___closed__9;
-lean_object* l_Lean_Parser_rawIdent(uint8_t);
+extern lean_object* l_Lean_Parser_rawIdent;
 lean_object* l_Lean_Parser_Command_set__option___closed__5;
 lean_object* l_Lean_Parser_Command_open___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_universe___elambda__1___closed__6;
@@ -559,7 +557,6 @@ lean_object* l_Lean_Parser_Command_declaration___closed__11;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_antiquot___closed__2;
 extern lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_declVal___closed__2;
-extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__11;
 lean_object* l_Lean_Parser_Command_structImplicitBinder___closed__3;
 lean_object* l_Lean_Parser_Command_open___closed__7;
 lean_object* l_Lean_Parser_Command_structCtor___closed__1;
@@ -608,13 +605,13 @@ lean_object* l_Lean_Parser_Command_inductive___closed__6;
 lean_object* l_Lean_Parser_registerBuiltinParserAttribute(lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Parser_Command_structCtor___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_resolve__name___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Command_commentBody___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_commentBody___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_open___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_attributes___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_declModifiers;
 lean_object* l_Lean_Parser_Command_exit___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_structFields___closed__3;
-lean_object* l_Lean_Parser_Command_commentBody___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_commentBody___elambda__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_explicitUniv___closed__4;
 lean_object* l_Lean_Parser_Command_declModifiers___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_inductive___elambda__1___closed__5;
@@ -633,28 +630,27 @@ lean_object* l_Lean_Parser_Command_noncomputable___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_structFields___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_open___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_openRenaming___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Command_theorem___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_theorem___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_attributes___closed__8;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_set__option(lean_object*);
 lean_object* l_Lean_Parser_Command_private___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Command_inferMod___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_inferMod___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_end___closed__4;
 lean_object* l_Lean_Parser_Command_variable;
 lean_object* l_Lean_Parser_Command_universes___closed__4;
 lean_object* l_Lean_Parser_Command_classTk___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_constant___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Command_declSig___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_declSig___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-extern lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_theorem___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_abbrev___closed__8;
 lean_object* l_Lean_Parser_Command_inductive___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_open___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Command_classTk___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_classTk___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_restore(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_variable___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Command_optDeclSig___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_optDeclSig___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_variable___closed__6;
 lean_object* l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_extends___elambda__1___closed__9;
@@ -680,7 +676,7 @@ lean_object* l_Lean_Parser_Command_export;
 lean_object* l_Lean_Parser_Command_openRenaming___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_init__quot(lean_object*);
 lean_object* l_Lean_Parser_Command_namespace___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_axiom___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_abbrev___closed__2;
 lean_object* l_Lean_Parser_Command_unsafe___elambda__1___closed__5;
@@ -691,7 +687,7 @@ lean_object* l_Lean_Parser_Command_example___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_namespace___elambda__1___closed__5;
 extern lean_object* l_Lean_Parser_Term_letIdLhs___closed__1;
 lean_object* l_Lean_Parser_Command_init__quot___elambda__1___closed__7;
-lean_object* l_Lean_Parser_Term_optType___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_optType___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__12;
 lean_object* l_Lean_Parser_Term_stxQuot___closed__3;
 lean_object* l_Lean_Parser_Command_synth___elambda__1___closed__9;
@@ -700,12 +696,11 @@ lean_object* l_Lean_Parser_Command_noncomputable___closed__3;
 lean_object* l_Lean_Parser_Command_private___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_resolve__name___closed__3;
 lean_object* l_Lean_Parser_Command_structImplicitBinder___closed__6;
-lean_object* l_Lean_Parser_Command_def___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_def___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_abbrev___closed__4;
 lean_object* l_Lean_Parser_Command_check___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_structInstBinder___closed__1;
 extern lean_object* l_Lean_Parser_Term_letIdLhs___closed__2;
-lean_object* l_Lean_Parser_categoryParserFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_noncomputable___closed__5;
 lean_object* l_Lean_Parser_Command_structCtor___closed__7;
 lean_object* l_Lean_Parser_Command_relaxedInferMod___closed__5;
@@ -731,7 +726,6 @@ lean_object* l_Lean_Parser_Command_unsafe___closed__3;
 lean_object* l_Lean_Parser_Command_set__option___closed__9;
 lean_object* l_Lean_Parser_Term_stxQuot___closed__5;
 lean_object* l_Lean_Parser_Command_universe___elambda__1___closed__2;
-lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_declValEqns___closed__3;
 lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_universe___closed__4;
@@ -739,9 +733,10 @@ lean_object* l_Lean_Parser_Command_declModifiers___closed__10;
 lean_object* l_Lean_Parser_Command_resolve__name___closed__2;
 lean_object* l_Lean_Parser_Command_openRenamingItem;
 lean_object* l_Lean_Parser_Command_attributes___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Command_partial___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_partial___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_synth___closed__1;
 lean_object* l_Lean_Parser_Command_openOnly___elambda__1___closed__4;
+lean_object* l_Lean_Parser_ident___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_set__option___closed__4;
 lean_object* l_Lean_Parser_Command_example___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_declVal___closed__1;
@@ -750,6 +745,7 @@ lean_object* l_Lean_Parser_Command_strictInferMod___closed__3;
 extern lean_object* l_Bool_HasRepr___closed__1;
 lean_object* l_Lean_Parser_Command_check;
 lean_object* l_Lean_Parser_Command_inductive___elambda__1___closed__4;
+extern lean_object* l_Lean_Parser_numLit;
 lean_object* l_Lean_Parser_Command_noncomputable___closed__1;
 lean_object* l_Lean_Parser_Command_openRenamingItem___closed__5;
 lean_object* l_Lean_Parser_Command_universe___elambda__1___closed__8;
@@ -763,6 +759,7 @@ lean_object* l_Lean_Parser_Command_universes___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_declSig___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_attribute___closed__1;
 lean_object* l_Lean_Parser_Command_end___elambda__1___closed__2;
+lean_object* l_Lean_Parser_numLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_abbrev___closed__1;
 lean_object* l_Lean_Parser_Command_open___closed__1;
 lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__1;
@@ -773,8 +770,8 @@ lean_object* l_Lean_Parser_Command_set__option___closed__8;
 lean_object* l_Lean_Parser_Command_attributes___closed__3;
 lean_object* l_Lean_Parser_Command_axiom___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_private___closed__1;
-lean_object* l_Lean_Parser_Command_universe___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_binderDefault___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_universe___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_binderDefault___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_constant___closed__3;
 lean_object* l_Lean_Parser_Command_classInductive___closed__6;
 lean_object* l_Lean_Parser_Command_end___elambda__1___closed__1;
@@ -800,13 +797,13 @@ lean_object* l_Lean_Parser_Command_constant___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_openHiding___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_resolve__name___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_private___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Command_declModifiers___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_declModifiers___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_constant___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_inductive___elambda__1___closed__9;
-lean_object* l_Lean_Parser_Command_attrInstance___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_attrInstance___elambda__1(lean_object*, lean_object*);
 extern lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_object* l_Lean_Parser_categoryParser(uint8_t, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_structImplicitBinder___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParser(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_structImplicitBinder___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structure___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_structCtor___closed__3;
 lean_object* l_Lean_Parser_Command_noncomputable___elambda__1___closed__4;
@@ -816,22 +813,22 @@ lean_object* l_Lean_Parser_Command_end___closed__6;
 extern lean_object* l_Bool_HasRepr___closed__2;
 lean_object* l_Lean_Parser_Command_instance___closed__6;
 lean_object* l_Lean_Parser_Command_namespace___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Command_openSimple___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_openSimple___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structureTk___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_declSig___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_universe___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_declaration;
 lean_object* l_Lean_Parser_Command_structExplicitBinder___closed__6;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_declId___closed__7;
 lean_object* l_Lean_Parser_Command_openOnly___elambda__1___closed__3;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structInstBinder___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_introRule___closed__6;
 lean_object* l_Lean_Parser_Command_protected___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_attributes___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_declaration___closed__1;
 lean_object* l_Lean_Parser_Command_declSig___elambda__1___closed__1;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_inductive___closed__1;
 lean_object* l_Lean_Parser_Command_declValSimple___closed__4;
 lean_object* l_Lean_Parser_Command_theorem___closed__1;
@@ -843,7 +840,7 @@ lean_object* l_Lean_Parser_Command_openSimple___closed__2;
 lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_classTk;
 lean_object* l_Lean_Parser_Command_end___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Command_axiom___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_axiom___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_openRenaming___closed__8;
 lean_object* l_Lean_Parser_Command_docComment;
 extern lean_object* l_Lean_Parser_Term_explicitUniv___closed__2;
@@ -862,9 +859,10 @@ lean_object* l_Lean_Parser_Command_declModifiers___closed__12;
 extern lean_object* l_Lean_Parser_Term_letEqnsDecl___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_noncomputable___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_attribute___closed__8;
-lean_object* l_Lean_Parser_Command_structureTk___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_open___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_structureTk___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_open___elambda__1(lean_object*, lean_object*);
 extern lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_variable___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_classInductive___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_end___elambda__1___closed__9;
@@ -881,14 +879,15 @@ lean_object* l_Lean_Parser_Command_structure___closed__9;
 lean_object* l_Lean_Parser_Command_declaration___closed__2;
 lean_object* l_Lean_Parser_Command_end___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_constant___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Command_attribute___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_attribute___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structureTk___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_variable___closed__3;
 lean_object* l_Lean_Parser_Command_check___closed__3;
 lean_object* l_Lean_Parser_Command_universes___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_synth___closed__5;
 lean_object* l_Lean_Parser_Command_openOnly___closed__2;
-lean_object* l_Lean_Parser_Term_stxQuot___elambda__1(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_unicodeSymbolFn___closed__1;
+lean_object* l_Lean_Parser_Term_stxQuot___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structureTk___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_section___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__12;
@@ -911,16 +910,14 @@ lean_object* l_Lean_Parser_Command_universe___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_structureTk___closed__3;
 lean_object* l_Lean_Parser_Command_constant___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_universes___elambda__1___closed__2;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_openRenaming___closed__2;
-extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
 lean_object* l_Lean_Parser_Command_openHiding___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_declaration___closed__8;
 lean_object* l_Lean_Parser_Command_optDeclSig___elambda__1___closed__4;
 lean_object* l_String_trim(lean_object*);
-lean_object* l_Lean_Parser_Command_structure___elambda__1(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__8;
+lean_object* l_Lean_Parser_Command_structure___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_introRule___closed__3;
 lean_object* l_Lean_Parser_Command_axiom___closed__4;
 lean_object* l_Lean_Parser_Command_exit___closed__5;
@@ -933,8 +930,8 @@ lean_object* l_Lean_Parser_Command_declaration___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_attribute___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_axiom___closed__1;
 lean_object* l_Lean_Parser_Command_exit___closed__3;
-lean_object* l_Lean_Parser_Command_unsafe___elambda__1(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Term_typeAscription___closed__2;
+lean_object* l_Lean_Parser_Command_unsafe___elambda__1(lean_object*, lean_object*);
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_private___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_noncomputable___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_structure___closed__13;
@@ -947,7 +944,7 @@ lean_object* l_Lean_Parser_Command_structureTk___closed__5;
 lean_object* l_Lean_Parser_Command_universes___elambda__1___closed__9;
 extern lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_set__option___closed__1;
-lean_object* l_Lean_Parser_Command_protected___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_protected___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_introRule___closed__5;
 lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_relaxedInferMod___closed__2;
@@ -965,6 +962,7 @@ lean_object* l_Lean_Parser_Term_stxQuot___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_declValSimple___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_set__option___closed__2;
 lean_object* l_Lean_Parser_Command_init__quot___elambda__1___closed__6;
+lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux(lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_openSimple___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_openOnly___closed__1;
 lean_object* l_Lean_Parser_Command_openRenamingItem___closed__1;
@@ -973,11 +971,11 @@ lean_object* l_Lean_Parser_Command_universe___closed__6;
 lean_object* l_Lean_Parser_Command_universes;
 lean_object* l_Lean_Parser_Command_attribute___closed__11;
 lean_object* l_Lean_Parser_Command_attribute___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Command_relaxedInferMod___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_relaxedInferMod___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_variables;
 lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Command_universes___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Term_typeSpec___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_typeSpec___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structCtor___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_variables___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_structureTk;
@@ -986,10 +984,10 @@ lean_object* l___regBuiltinParser_Lean_Parser_Command_open(lean_object*);
 lean_object* l_Lean_Parser_Command_variable___closed__5;
 lean_object* l_Lean_Parser_Command_variable___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_def___closed__2;
-lean_object* l_Lean_Parser_mkAntiquot(uint8_t, lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_Parser_mkAntiquot(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Parser_Command_init__quot___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_optDeclSig___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Command_variables___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_variables___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_export___closed__6;
 lean_object* l_Lean_Parser_Command_declSig___closed__3;
 lean_object* l_Lean_Parser_Command_attributes___closed__6;
@@ -999,7 +997,7 @@ lean_object* l_Lean_Parser_Command_openRenaming___elambda__1___closed__6;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_end(lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Command_antiquot(lean_object*);
 lean_object* l_Lean_Parser_Command_openHiding___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Command_structCtor___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_structCtor___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_partial;
 lean_object* l_Lean_Parser_Command_declId___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_strictInferMod___closed__5;
@@ -1010,7 +1008,7 @@ lean_object* l_Lean_Parser_Command_declaration___closed__6;
 lean_object* l_Lean_Parser_Command_private___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_openHiding___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_optDeclSig___closed__3;
-lean_object* l_Lean_Parser_Command_structExplicitBinder___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_structExplicitBinder___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_attrArg___closed__2;
 lean_object* l_Lean_Parser_Command_declaration___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_attribute___elambda__1___closed__9;
@@ -1023,7 +1021,7 @@ lean_object* l_Lean_Parser_Command_namespace___closed__1;
 lean_object* l_Lean_Parser_Command_partial___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_namespace;
 lean_object* l_Lean_Parser_Command_axiom___closed__2;
-lean_object* l_Lean_Parser_Command_constant___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_constant___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structure___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_check___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_declValSimple___closed__3;
@@ -1034,6 +1032,7 @@ lean_object* l_Lean_Parser_Command_partial___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_attribute___elambda__1___closed__14;
 lean_object* l_Lean_Parser_Command_attrArg___closed__3;
 lean_object* l_Lean_Parser_Command_export___elambda__1___closed__6;
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_def___closed__4;
 lean_object* l_Lean_Parser_Command_declaration___closed__5;
 lean_object* l_Lean_Parser_Command_extends___closed__6;
@@ -1069,7 +1068,7 @@ lean_object* l_Lean_Parser_Command_docComment___closed__6;
 lean_object* l_Lean_Parser_Command_instance___closed__5;
 lean_object* l_Lean_Parser_Command_theorem___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_partial___elambda__1___closed__4;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_universes___closed__5;
 lean_object* l_Lean_Parser_Command_attrInstance___closed__1;
 lean_object* l_Lean_Parser_Command_openOnly___closed__3;
@@ -1110,14 +1109,14 @@ lean_object* l_Lean_Parser_Command_constant___elambda__1___closed__2;
 lean_object* l_Lean_Parser_regBuiltinCommandParserAttr___closed__3;
 lean_object* l_Lean_Parser_unicodeSymbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_attributes___closed__2;
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
-lean_object* l_Lean_Parser_Command_private___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_section___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_private___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_section___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_universes___closed__3;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_attrInstance___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_rawIdent___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_docComment___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_export___closed__5;
 lean_object* l_Lean_Parser_Command_check___closed__1;
+extern lean_object* l_Lean_Parser_strLit;
 lean_object* l_Lean_Parser_Command_exit___closed__4;
 lean_object* l_Lean_Parser_Command_theorem___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_commentBody;
@@ -1125,12 +1124,12 @@ lean_object* l_Lean_Parser_Command_set__option___closed__6;
 lean_object* l_Lean_Parser_Command_partial___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_constant___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_structCtor___elambda__1___closed__6;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_universe___closed__3;
 lean_object* l_Lean_Parser_Command_structure___closed__12;
-lean_object* l_Lean_Parser_Command_structInstBinder___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_structInstBinder___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_structExplicitBinder___closed__10;
-lean_object* l_Lean_Parser_Command_universes___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_universes___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_declValEqns;
 lean_object* l_Lean_Parser_Command_declModifiers___closed__9;
 lean_object* l_Lean_Parser_Command_declaration___closed__14;
@@ -1232,85 +1231,75 @@ x_4 = l_Lean_Parser_registerBuiltinDynamicParserAttribute(x_2, x_3, x_1);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_commandParser(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_commandParser(lean_object* x_1) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; 
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_3, x_2);
-return x_4;
+lean_object* x_2; lean_object* x_3; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_categoryParser(x_2, x_1);
+return x_3;
 }
 }
-lean_object* l_Lean_Parser_commandParser___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_commandParser(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(uint8_t 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; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-x_8 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_9 = lean_unsigned_to_nat(0u);
+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; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-x_10 = l_Lean_Parser_categoryParserFn(x_8, x_9, x_3, x_4);
-x_11 = lean_ctor_get(x_10, 3);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+x_6 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_7 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_8 = l_Lean_Parser_categoryParser___elambda__1(x_6, x_7, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_object* x_12; uint8_t x_13; 
-lean_dec(x_6);
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_7, x_12);
-lean_dec(x_12);
-lean_dec(x_7);
-if (x_13 == 0)
+lean_object* x_10; uint8_t x_11; 
+lean_dec(x_4);
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+x_11 = lean_nat_dec_eq(x_5, x_10);
+lean_dec(x_10);
+lean_dec(x_5);
+if (x_11 == 0)
 {
-x_4 = x_10;
+x_2 = x_8;
 goto _start;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; 
-lean_dec(x_3);
-x_15 = l_Lean_Parser_manyAux___main___closed__1;
-x_16 = l_Lean_Parser_ParserState_mkUnexpectedError(x_10, x_15);
-return x_16;
+lean_object* x_13; lean_object* x_14; 
+lean_dec(x_1);
+x_13 = l_Lean_Parser_manyAux___main___closed__1;
+x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
+return x_14;
 }
 }
 else
 {
-lean_object* x_17; uint8_t x_18; 
-lean_dec(x_11);
-lean_dec(x_3);
-x_17 = lean_ctor_get(x_10, 1);
-lean_inc(x_17);
-x_18 = lean_nat_dec_eq(x_7, x_17);
-lean_dec(x_17);
-if (x_18 == 0)
+lean_object* x_15; uint8_t x_16; 
+lean_dec(x_9);
+lean_dec(x_1);
+x_15 = lean_ctor_get(x_8, 1);
+lean_inc(x_15);
+x_16 = lean_nat_dec_eq(x_5, x_15);
+lean_dec(x_15);
+if (x_16 == 0)
 {
-lean_dec(x_7);
-lean_dec(x_6);
-return x_10;
+lean_dec(x_5);
+lean_dec(x_4);
+return x_8;
 }
 else
 {
-lean_object* x_19; 
-x_19 = l_Lean_Parser_ParserState_restore(x_10, x_6, x_7);
-lean_dec(x_6);
-return x_19;
+lean_object* x_17; 
+x_17 = l_Lean_Parser_ParserState_restore(x_8, x_4, x_5);
+lean_dec(x_4);
+return x_17;
 }
 }
 }
@@ -1346,13 +1335,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_stxQuot___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_stxQuot___elambda__1___closed__5() {
@@ -1404,352 +1392,343 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_stxQuot___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_stxQuot___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_stxQuot___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_49; lean_object* x_91; lean_object* x_92; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_91 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_92 = lean_ctor_get(x_91, 3);
-lean_inc(x_92);
-if (lean_obj_tag(x_92) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_48; lean_object* x_89; lean_object* x_90; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_89 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_90 = lean_ctor_get(x_89, 3);
+lean_inc(x_90);
+if (lean_obj_tag(x_90) == 0)
 {
-lean_object* x_93; lean_object* x_94; 
-x_93 = lean_ctor_get(x_91, 0);
+lean_object* x_91; lean_object* x_92; 
+x_91 = lean_ctor_get(x_89, 0);
+lean_inc(x_91);
+x_92 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_91);
+lean_dec(x_91);
+if (lean_obj_tag(x_92) == 2)
+{
+lean_object* x_93; lean_object* x_94; uint8_t x_95; 
+x_93 = lean_ctor_get(x_92, 1);
 lean_inc(x_93);
-x_94 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_93);
+lean_dec(x_92);
+x_94 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__6;
+x_95 = lean_string_dec_eq(x_93, x_94);
 lean_dec(x_93);
-if (lean_obj_tag(x_94) == 2)
+if (x_95 == 0)
 {
-lean_object* x_95; lean_object* x_96; uint8_t x_97; 
-x_95 = lean_ctor_get(x_94, 1);
-lean_inc(x_95);
-lean_dec(x_94);
-x_96 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__6;
-x_97 = lean_string_dec_eq(x_95, x_96);
-lean_dec(x_95);
-if (x_97 == 0)
+lean_object* x_96; lean_object* x_97; 
+x_96 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
+lean_inc(x_7);
+x_97 = l_Lean_Parser_ParserState_mkErrorsAt(x_89, x_96, x_7);
+x_48 = x_97;
+goto block_88;
+}
+else
+{
+x_48 = x_89;
+goto block_88;
+}
+}
+else
 {
 lean_object* x_98; lean_object* x_99; 
+lean_dec(x_92);
 x_98 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-lean_inc(x_8);
-x_99 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_98, x_8);
-x_49 = x_99;
-goto block_90;
-}
-else
-{
-x_49 = x_91;
-goto block_90;
+lean_inc(x_7);
+x_99 = l_Lean_Parser_ParserState_mkErrorsAt(x_89, x_98, x_7);
+x_48 = x_99;
+goto block_88;
 }
 }
 else
 {
 lean_object* x_100; lean_object* x_101; 
-lean_dec(x_94);
+lean_dec(x_90);
 x_100 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-lean_inc(x_8);
-x_101 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_100, x_8);
-x_49 = x_101;
-goto block_90;
+lean_inc(x_7);
+x_101 = l_Lean_Parser_ParserState_mkErrorsAt(x_89, x_100, x_7);
+x_48 = x_101;
+goto block_88;
 }
-}
-else
+block_47:
 {
-lean_object* x_102; lean_object* x_103; 
-lean_dec(x_92);
-x_102 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-lean_inc(x_8);
-x_103 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_102, x_8);
-x_49 = x_103;
-goto block_90;
-}
-block_48:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_16, 1);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_19 = l_Lean_Parser_tokenFn(x_1, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = lean_ctor_get(x_17, 1);
-lean_inc(x_19);
-x_20 = l_Lean_Parser_tokenFn(x_2, x_17);
-x_21 = lean_ctor_get(x_20, 3);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_object* x_22; lean_object* x_23; 
-x_22 = lean_ctor_get(x_20, 0);
-lean_inc(x_22);
-x_23 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_22);
-lean_dec(x_22);
-if (lean_obj_tag(x_23) == 2)
-{
-lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_24 = lean_ctor_get(x_23, 1);
-lean_inc(x_24);
-lean_dec(x_23);
-x_25 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_26 = lean_string_dec_eq(x_24, x_25);
-lean_dec(x_24);
-if (x_26 == 0)
-{
-lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_27 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_27, x_19);
-x_29 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-lean_dec(x_19);
-x_32 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_20, x_32, x_16);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_8);
-lean_dec(x_8);
-return x_34;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_23);
-x_35 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_35, x_19);
-x_37 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_16);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_8);
-lean_dec(x_8);
-return x_39;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
 lean_dec(x_21);
-x_40 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_40, x_19);
-x_42 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_16);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_11, x_8);
-lean_dec(x_8);
-return x_44;
-}
+if (lean_obj_tag(x_22) == 2)
+{
+lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 1);
+lean_inc(x_23);
+lean_dec(x_22);
+x_24 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_25 = lean_string_dec_eq(x_23, x_24);
+lean_dec(x_23);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_26 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18);
+x_28 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
 lean_dec(x_18);
-lean_dec(x_2);
-x_45 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_17, x_45, x_16);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_11, x_8);
-lean_dec(x_8);
-return x_47;
+x_31 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_19, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
 }
 }
-block_90:
+else
 {
-lean_object* x_50; 
-x_50 = lean_ctor_get(x_49, 3);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_22);
+x_34 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_34, x_18);
+x_36 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_20);
+x_39 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_39, x_18);
+x_41 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_44 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_16, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+block_88:
+{
+lean_object* x_49; 
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+x_50 = lean_ctor_get(x_48, 0);
 lean_inc(x_50);
-if (lean_obj_tag(x_50) == 0)
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-x_51 = lean_ctor_get(x_49, 0);
-lean_inc(x_51);
-x_52 = lean_array_get_size(x_51);
-lean_dec(x_51);
-x_53 = lean_ctor_get(x_49, 1);
-lean_inc(x_53);
-x_54 = l_Lean_Parser_termParser___closed__2;
-x_55 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_categoryParserFn(x_54, x_55, x_2, x_49);
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
-{
-lean_dec(x_53);
-lean_dec(x_52);
-lean_dec(x_1);
-x_17 = x_56;
-goto block_48;
-}
-else
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_58 = lean_ctor_get(x_57, 0);
-lean_inc(x_58);
-lean_dec(x_57);
-x_59 = lean_ctor_get(x_56, 1);
-lean_inc(x_59);
-x_60 = lean_nat_dec_eq(x_59, x_53);
-lean_dec(x_59);
-if (x_60 == 0)
-{
-lean_dec(x_58);
-lean_dec(x_53);
-lean_dec(x_52);
-lean_dec(x_1);
-x_17 = x_56;
-goto block_48;
-}
-else
-{
-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_inc(x_53);
-x_61 = l_Lean_Parser_ParserState_restore(x_56, x_52, x_53);
-lean_dec(x_52);
-x_62 = lean_ctor_get(x_61, 0);
-lean_inc(x_62);
-x_63 = lean_array_get_size(x_62);
-lean_dec(x_62);
-x_64 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-lean_inc(x_2);
-x_65 = l_Lean_Parser_categoryParserFn(x_64, x_55, x_2, x_61);
-x_66 = lean_ctor_get(x_65, 3);
-lean_inc(x_66);
-if (lean_obj_tag(x_66) == 0)
-{
-uint8_t x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; uint8_t x_73; 
-x_67 = 0;
-lean_inc(x_2);
-x_68 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(x_67, x_1, x_2, x_65);
-lean_dec(x_1);
-x_69 = lean_ctor_get(x_68, 0);
-lean_inc(x_69);
-x_70 = lean_array_get_size(x_69);
-lean_dec(x_69);
-x_71 = lean_nat_sub(x_70, x_63);
-lean_dec(x_70);
-x_72 = lean_unsigned_to_nat(1u);
-x_73 = lean_nat_dec_eq(x_71, x_72);
-lean_dec(x_71);
-if (x_73 == 0)
-{
-lean_object* x_74; lean_object* x_75; lean_object* x_76; 
-x_74 = l_Lean_nullKind;
-x_75 = l_Lean_Parser_ParserState_mkNode(x_68, x_74, x_63);
-x_76 = l_Lean_Parser_mergeOrElseErrors(x_75, x_58, x_53);
-lean_dec(x_53);
-x_17 = x_76;
-goto block_48;
-}
-else
-{
-lean_object* x_77; 
-lean_dec(x_63);
-x_77 = l_Lean_Parser_mergeOrElseErrors(x_68, x_58, x_53);
-lean_dec(x_53);
-x_17 = x_77;
-goto block_48;
-}
-}
-else
-{
-lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; 
-lean_dec(x_66);
-lean_dec(x_1);
-x_78 = lean_ctor_get(x_65, 0);
-lean_inc(x_78);
-x_79 = lean_array_get_size(x_78);
-lean_dec(x_78);
-x_80 = lean_nat_sub(x_79, x_63);
-lean_dec(x_79);
-x_81 = lean_unsigned_to_nat(1u);
-x_82 = lean_nat_dec_eq(x_80, x_81);
-lean_dec(x_80);
-if (x_82 == 0)
-{
-lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_83 = l_Lean_nullKind;
-x_84 = l_Lean_Parser_ParserState_mkNode(x_65, x_83, x_63);
-x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_58, x_53);
-lean_dec(x_53);
-x_17 = x_85;
-goto block_48;
-}
-else
-{
-lean_object* x_86; 
-lean_dec(x_63);
-x_86 = l_Lean_Parser_mergeOrElseErrors(x_65, x_58, x_53);
-lean_dec(x_53);
-x_17 = x_86;
-goto block_48;
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_87; lean_object* x_88; lean_object* x_89; 
+x_51 = lean_array_get_size(x_50);
 lean_dec(x_50);
-lean_dec(x_2);
+x_52 = lean_ctor_get(x_48, 1);
+lean_inc(x_52);
+x_53 = l_Lean_Parser_termParser___closed__2;
+x_54 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_48);
+x_56 = lean_ctor_get(x_55, 3);
+lean_inc(x_56);
+if (lean_obj_tag(x_56) == 0)
+{
+lean_dec(x_52);
+lean_dec(x_51);
+x_16 = x_55;
+goto block_47;
+}
+else
+{
+lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+x_57 = lean_ctor_get(x_56, 0);
+lean_inc(x_57);
+lean_dec(x_56);
+x_58 = lean_ctor_get(x_55, 1);
+lean_inc(x_58);
+x_59 = lean_nat_dec_eq(x_58, x_52);
+lean_dec(x_58);
+if (x_59 == 0)
+{
+lean_dec(x_57);
+lean_dec(x_52);
+lean_dec(x_51);
+x_16 = x_55;
+goto block_47;
+}
+else
+{
+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_inc(x_52);
+x_60 = l_Lean_Parser_ParserState_restore(x_55, x_51, x_52);
+lean_dec(x_51);
+x_61 = lean_ctor_get(x_60, 0);
+lean_inc(x_61);
+x_62 = lean_array_get_size(x_61);
+lean_dec(x_61);
+x_63 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+lean_inc(x_1);
+x_64 = l_Lean_Parser_categoryParser___elambda__1(x_63, x_54, x_1, x_60);
+x_65 = lean_ctor_get(x_64, 3);
+lean_inc(x_65);
+if (lean_obj_tag(x_65) == 0)
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+lean_inc(x_1);
+x_66 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(x_1, x_64);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_62);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(1u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_62);
+x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_57, x_52);
+lean_dec(x_52);
+x_16 = x_74;
+goto block_47;
+}
+else
+{
+lean_object* x_75; 
+lean_dec(x_62);
+x_75 = l_Lean_Parser_mergeOrElseErrors(x_66, x_57, x_52);
+lean_dec(x_52);
+x_16 = x_75;
+goto block_47;
+}
+}
+else
+{
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; uint8_t x_80; 
+lean_dec(x_65);
+x_76 = lean_ctor_get(x_64, 0);
+lean_inc(x_76);
+x_77 = lean_array_get_size(x_76);
+lean_dec(x_76);
+x_78 = lean_nat_sub(x_77, x_62);
+lean_dec(x_77);
+x_79 = lean_unsigned_to_nat(1u);
+x_80 = lean_nat_dec_eq(x_78, x_79);
+lean_dec(x_78);
+if (x_80 == 0)
+{
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+x_81 = l_Lean_nullKind;
+x_82 = l_Lean_Parser_ParserState_mkNode(x_64, x_81, x_62);
+x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_57, x_52);
+lean_dec(x_52);
+x_16 = x_83;
+goto block_47;
+}
+else
+{
+lean_object* x_84; 
+lean_dec(x_62);
+x_84 = l_Lean_Parser_mergeOrElseErrors(x_64, x_57, x_52);
+lean_dec(x_52);
+x_16 = x_84;
+goto block_47;
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_85; lean_object* x_86; lean_object* x_87; 
+lean_dec(x_49);
 lean_dec(x_1);
-x_87 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
-x_88 = l_Lean_Parser_ParserState_mkNode(x_49, x_87, x_16);
-x_89 = l_Lean_Parser_mergeOrElseErrors(x_88, x_11, x_8);
-lean_dec(x_8);
-return x_89;
+x_85 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
+x_86 = l_Lean_Parser_ParserState_mkNode(x_48, x_85, x_15);
+x_87 = l_Lean_Parser_mergeOrElseErrors(x_86, x_10, x_7);
+lean_dec(x_7);
+return x_87;
 }
 }
 }
@@ -1769,12 +1748,11 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_2 = lean_unsigned_to_nat(0u);
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__3() {
@@ -1784,7 +1762,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = l_Lean_Parser_Term_stxQuot___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_4 = lean_ctor_get(x_3, 0);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_orelseInfo(x_4, x_2);
@@ -1796,7 +1774,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_stxQuot___closed__3;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
@@ -1837,7 +1815,7 @@ lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_stxQuot___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_stxQuot___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1861,24 +1839,13 @@ x_1 = l_Lean_Parser_Term_stxQuot___closed__9;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_6;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Term_stxQuot(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_stxQuot;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -1887,13 +1854,12 @@ return x_6;
 lean_object* _init_l_Lean_Parser_Command_antiquot___closed__1() {
 _start:
 {
-lean_object* x_1; uint8_t x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
 x_1 = lean_box(0);
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_2, x_3, x_1, x_4);
-return x_5;
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_2, x_1, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_antiquot() {
@@ -1935,37 +1901,37 @@ return x_3;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_antiquot(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l___regBuiltinParser_Lean_Parser_Command_antiquot___closed__3;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l___regBuiltinParser_Lean_Parser_Command_antiquot___closed__3;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_antiquot;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_Command_commentBody___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_commentBody___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_4 = lean_ctor_get(x_3, 1);
-lean_inc(x_4);
-x_5 = lean_unsigned_to_nat(1u);
-x_6 = l_Lean_Parser_finishCommentBlock___main(x_5, x_2, x_3);
-x_7 = lean_ctor_get(x_6, 3);
-lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_3 = lean_ctor_get(x_2, 1);
+lean_inc(x_3);
+x_4 = lean_unsigned_to_nat(1u);
+x_5 = l_Lean_Parser_finishCommentBlock___main(x_4, x_1, x_2);
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
 {
-uint8_t x_8; lean_object* x_9; 
-x_8 = 1;
-x_9 = l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(x_4, x_8, x_1, x_2, x_6);
-return x_9;
+uint8_t x_7; lean_object* x_8; 
+x_7 = 1;
+x_8 = l___private_Init_Lean_Parser_Parser_3__rawAux(x_3, x_7, x_1, x_5);
+return x_8;
 }
 else
 {
-lean_dec(x_7);
-lean_dec(x_4);
-return x_6;
+lean_dec(x_6);
+lean_dec(x_3);
+return x_5;
 }
 }
 }
@@ -1973,7 +1939,7 @@ lean_object* _init_l_Lean_Parser_Command_commentBody___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_commentBody___elambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_commentBody___elambda__1___boxed), 2, 0);
 return x_1;
 }
 }
@@ -1997,14 +1963,13 @@ x_1 = l_Lean_Parser_Command_commentBody___closed__2;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_commentBody___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_commentBody___elambda__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; 
-x_4 = l_Lean_Parser_Command_commentBody___elambda__1(x_1, x_2, x_3);
-lean_dec(x_2);
+lean_object* x_3; 
+x_3 = l_Lean_Parser_Command_commentBody___elambda__1(x_1, x_2);
 lean_dec(x_1);
-return x_4;
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_docComment___elambda__1___closed__1() {
@@ -2038,13 +2003,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_docComment___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_docComment___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_docComment___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_docComment___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_docComment___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_docComment___elambda__1___closed__5() {
@@ -2096,145 +2060,140 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_docComment___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_docComment___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_docComment___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_docComment___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_27; lean_object* x_28; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_27 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_28 = lean_ctor_get(x_27, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_26; lean_object* x_27; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
+{
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
 lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = lean_ctor_get(x_27, 0);
-lean_inc(x_29);
-x_30 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_29);
-lean_dec(x_29);
-if (lean_obj_tag(x_30) == 2)
-{
-lean_object* x_31; lean_object* x_32; uint8_t x_33; 
-x_31 = lean_ctor_get(x_30, 1);
-lean_inc(x_31);
-lean_dec(x_30);
-x_32 = l_Lean_Parser_Command_docComment___elambda__1___closed__6;
-x_33 = lean_string_dec_eq(x_31, x_32);
-lean_dec(x_31);
-if (x_33 == 0)
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = l_Lean_Parser_Command_docComment___elambda__1___closed__9;
-lean_inc(x_8);
-x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_8);
-x_17 = x_35;
-goto block_26;
-}
-else
-{
-x_17 = x_27;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-lean_dec(x_30);
-x_36 = l_Lean_Parser_Command_docComment___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_36, x_8);
-x_17 = x_37;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
 lean_dec(x_28);
-x_38 = l_Lean_Parser_Command_docComment___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_38, x_8);
-x_17 = x_39;
-goto block_26;
-}
-block_26:
+if (lean_obj_tag(x_29) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
+lean_inc(x_30);
+lean_dec(x_29);
+x_31 = l_Lean_Parser_Command_docComment___elambda__1___closed__6;
+x_32 = lean_string_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = l_Lean_Parser_Command_commentBody___elambda__1(x_1, x_2, x_17);
-lean_dec(x_2);
-lean_dec(x_1);
-x_20 = l_Lean_Parser_Command_docComment___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_Parser_Command_docComment___elambda__1___closed__9;
+lean_inc(x_7);
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_7);
+x_16 = x_34;
+goto block_25;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-lean_dec(x_18);
-lean_dec(x_2);
+x_16 = x_26;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_29);
+x_35 = l_Lean_Parser_Command_docComment___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_7);
+x_16 = x_36;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_27);
+x_37 = l_Lean_Parser_Command_docComment___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_7);
+x_16 = x_38;
+goto block_25;
+}
+block_25:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_Command_commentBody___elambda__1(x_1, x_16);
 lean_dec(x_1);
-x_23 = l_Lean_Parser_Command_docComment___elambda__1___closed__2;
-x_24 = l_Lean_Parser_ParserState_mkNode(x_17, x_23, x_16);
-x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_11, x_8);
-lean_dec(x_8);
-return x_25;
+x_19 = l_Lean_Parser_Command_docComment___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_22 = l_Lean_Parser_Command_docComment___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -2289,7 +2248,7 @@ lean_object* _init_l_Lean_Parser_Command_docComment___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_docComment___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_docComment___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2313,120 +2272,99 @@ x_1 = l_Lean_Parser_Command_docComment___closed__6;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_attrArg___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_attrArg___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-x_4 = l_Lean_Parser_Term_str___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Level_num___elambda__1___closed__5;
-x_7 = lean_ctor_get(x_6, 1);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_ident___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
 lean_inc(x_7);
-x_8 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_9 = lean_ctor_get(x_8, 1);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
+lean_inc(x_8);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_ctor_get(x_3, 0);
-lean_inc(x_10);
-x_11 = lean_array_get_size(x_10);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_3, 1);
-lean_inc(x_12);
-lean_inc(x_2);
-lean_inc(x_1);
-x_13 = lean_apply_3(x_9, x_1, x_2, x_3);
-x_14 = lean_ctor_get(x_13, 3);
-lean_inc(x_14);
-if (lean_obj_tag(x_14) == 0)
+x_10 = lean_nat_dec_eq(x_9, x_5);
+lean_dec(x_9);
+if (x_10 == 0)
 {
-lean_dec(x_12);
-lean_dec(x_11);
-lean_dec(x_7);
+lean_dec(x_8);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_13;
+return x_6;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; uint8_t x_17; 
-x_15 = lean_ctor_get(x_14, 0);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = lean_ctor_get(x_11, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+lean_inc(x_1);
+x_14 = l_Lean_Parser_strLit___elambda__1(x_1, x_11);
+x_15 = lean_ctor_get(x_14, 3);
 lean_inc(x_15);
-lean_dec(x_14);
-x_16 = lean_ctor_get(x_13, 1);
-lean_inc(x_16);
-x_17 = lean_nat_dec_eq(x_16, x_12);
-lean_dec(x_16);
-if (x_17 == 0)
+if (lean_obj_tag(x_15) == 0)
 {
-lean_dec(x_15);
-lean_dec(x_12);
-lean_dec(x_11);
-lean_dec(x_7);
+lean_object* x_16; 
+lean_dec(x_13);
+lean_dec(x_1);
+x_16 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_5);
 lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_13;
+return x_16;
 }
 else
 {
-lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-lean_inc(x_12);
-x_18 = l_Lean_Parser_ParserState_restore(x_13, x_11, x_12);
-lean_dec(x_11);
-x_19 = lean_ctor_get(x_18, 0);
-lean_inc(x_19);
-x_20 = lean_array_get_size(x_19);
-lean_dec(x_19);
-lean_inc(x_2);
-lean_inc(x_1);
-x_21 = lean_apply_3(x_5, x_1, x_2, x_18);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
+lean_object* x_17; lean_object* x_18; uint8_t x_19; 
+x_17 = lean_ctor_get(x_15, 0);
+lean_inc(x_17);
+lean_dec(x_15);
+x_18 = lean_ctor_get(x_14, 1);
+lean_inc(x_18);
+x_19 = lean_nat_dec_eq(x_18, x_5);
+lean_dec(x_18);
+if (x_19 == 0)
 {
-lean_object* x_23; 
-lean_dec(x_20);
-lean_dec(x_7);
-lean_dec(x_2);
+lean_object* x_20; 
+lean_dec(x_17);
+lean_dec(x_13);
 lean_dec(x_1);
-x_23 = l_Lean_Parser_mergeOrElseErrors(x_21, x_15, x_12);
-lean_dec(x_12);
-return x_23;
+x_20 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_5);
+lean_dec(x_5);
+return x_20;
 }
 else
 {
-lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-lean_dec(x_22);
-x_25 = lean_ctor_get(x_21, 1);
-lean_inc(x_25);
-x_26 = lean_nat_dec_eq(x_25, x_12);
-lean_dec(x_25);
-if (x_26 == 0)
-{
-lean_object* x_27; 
-lean_dec(x_24);
-lean_dec(x_20);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_21, x_15, x_12);
-lean_dec(x_12);
-return x_27;
-}
-else
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-lean_inc(x_12);
-x_28 = l_Lean_Parser_ParserState_restore(x_21, x_20, x_12);
-lean_dec(x_20);
-x_29 = lean_apply_3(x_7, x_1, x_2, x_28);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_24, x_12);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_15, x_12);
-lean_dec(x_12);
-return x_31;
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_inc(x_5);
+x_21 = l_Lean_Parser_ParserState_restore(x_14, x_13, x_5);
+lean_dec(x_13);
+x_22 = l_Lean_Parser_numLit___elambda__1(x_1, x_21);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_17, x_5);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_8, x_5);
+lean_dec(x_5);
+return x_24;
 }
 }
 }
@@ -2437,10 +2375,10 @@ lean_object* _init_l_Lean_Parser_Command_attrArg___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Term_str___elambda__1___closed__5;
+x_1 = l_Lean_Parser_strLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_Level_num___elambda__1___closed__5;
+x_3 = l_Lean_Parser_numLit;
 x_4 = lean_ctor_get(x_3, 0);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_orelseInfo(x_2, x_4);
@@ -2451,7 +2389,7 @@ lean_object* _init_l_Lean_Parser_Command_attrArg___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_attrArg___closed__1;
@@ -2463,7 +2401,7 @@ lean_object* _init_l_Lean_Parser_Command_attrArg___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_attrArg___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_attrArg___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2487,67 +2425,64 @@ x_1 = l_Lean_Parser_Command_attrArg___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_attrInstance___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_attrInstance___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-lean_inc(x_2);
-x_8 = l_Lean_Parser_Command_attrArg___elambda__1(x_2, x_3, x_4);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Command_attrArg___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_10; uint8_t x_11; 
-lean_dec(x_6);
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_7, x_10);
-lean_dec(x_10);
-lean_dec(x_7);
-if (x_11 == 0)
+lean_object* x_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
+lean_dec(x_5);
+if (x_9 == 0)
 {
-x_4 = x_8;
+x_2 = x_6;
 goto _start;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_13 = l_Lean_Parser_manyAux___main___closed__1;
-x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
-return x_14;
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_15; uint8_t x_16; 
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_15 = lean_ctor_get(x_8, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_7, x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+lean_object* x_13; uint8_t x_14; 
 lean_dec(x_7);
-lean_dec(x_6);
-return x_8;
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_17;
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+return x_15;
 }
 }
 }
@@ -2583,117 +2518,96 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_attrInstance___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Command_attrInstance___elambda__1___closed__5() {
+lean_object* l_Lean_Parser_Command_attrInstance___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_rawIdent(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Command_attrInstance___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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
 lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_16 = l_Lean_Parser_rawIdent___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_21; lean_object* x_22; uint8_t 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; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = 0;
-x_24 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_attrInstance___elambda__1___spec__1(x_23, x_1, x_2, x_19);
-x_25 = l_Lean_nullKind;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_22);
-x_27 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_18);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_13, x_10);
-lean_dec(x_10);
-return x_29;
+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; 
+x_18 = lean_ctor_get(x_16, 0);
+lean_inc(x_18);
+x_19 = lean_array_get_size(x_18);
+lean_dec(x_18);
+x_20 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_attrInstance___elambda__1___spec__1(x_1, x_16);
+x_21 = l_Lean_nullKind;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_19);
+x_23 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_30 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_18);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_13, x_10);
-lean_dec(x_10);
-return x_32;
+x_26 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_16, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 }
@@ -2714,7 +2628,7 @@ lean_object* _init_l_Lean_Parser_Command_attrInstance___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Command_attrInstance___elambda__1___closed__5;
+x_1 = l_Lean_Parser_rawIdent;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_attrInstance___closed__1;
@@ -2748,7 +2662,7 @@ lean_object* _init_l_Lean_Parser_Command_attrInstance___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_attrInstance___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_attrInstance___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2772,226 +2686,213 @@ x_1 = l_Lean_Parser_Command_attrInstance___closed__6;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_attrInstance___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_attrInstance___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-return x_6;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
-lean_dec(x_9);
-x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_5);
+x_10 = l_Lean_Parser_Command_attrInstance___elambda__1(x_5, x_6);
+x_11 = lean_ctor_get(x_10, 3);
 lean_inc(x_11);
-lean_inc(x_7);
-lean_inc(x_6);
-x_12 = l_Lean_Parser_Command_attrInstance___elambda__1(x_6, x_7, x_8);
-x_13 = lean_ctor_get(x_12, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+if (lean_obj_tag(x_11) == 0)
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_14 = lean_ctor_get(x_12, 0);
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_12 = lean_ctor_get(x_10, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+x_14 = lean_ctor_get(x_10, 1);
 lean_inc(x_14);
-x_15 = lean_array_get_size(x_14);
-lean_dec(x_14);
-x_16 = lean_ctor_get(x_12, 1);
-lean_inc(x_16);
-lean_inc(x_7);
-x_31 = l_Lean_Parser_tokenFn(x_7, x_12);
-x_32 = lean_ctor_get(x_31, 3);
-lean_inc(x_32);
-if (lean_obj_tag(x_32) == 0)
+lean_inc(x_5);
+x_29 = l_Lean_Parser_tokenFn(x_5, x_10);
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_31, 0);
+lean_object* x_31; lean_object* x_32; 
+x_31 = lean_ctor_get(x_29, 0);
+lean_inc(x_31);
+x_32 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_31);
+lean_dec(x_31);
+if (lean_obj_tag(x_32) == 2)
+{
+lean_object* x_33; lean_object* x_34; uint8_t x_35; 
+x_33 = lean_ctor_get(x_32, 1);
 lean_inc(x_33);
-x_34 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_33);
+lean_dec(x_32);
+x_34 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_35 = lean_string_dec_eq(x_33, x_34);
 lean_dec(x_33);
-if (lean_obj_tag(x_34) == 2)
+if (x_35 == 0)
 {
-lean_object* x_35; lean_object* x_36; uint8_t x_37; 
-x_35 = lean_ctor_get(x_34, 1);
-lean_inc(x_35);
-lean_dec(x_34);
-x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_37 = lean_string_dec_eq(x_35, x_36);
-lean_dec(x_35);
-if (x_37 == 0)
-{
-lean_object* x_38; lean_object* x_39; 
-x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_16);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_16);
-x_17 = x_39;
-goto block_30;
+lean_object* x_36; lean_object* x_37; 
+x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_14);
+x_15 = x_37;
+goto block_28;
 }
 else
 {
-x_17 = x_31;
-goto block_30;
+x_15 = x_29;
+goto block_28;
+}
+}
+else
+{
+lean_object* x_38; lean_object* x_39; 
+lean_dec(x_32);
+x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_14);
+x_15 = x_39;
+goto block_28;
 }
 }
 else
 {
 lean_object* x_40; lean_object* x_41; 
-lean_dec(x_34);
+lean_dec(x_30);
 x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_14);
+x_15 = x_41;
+goto block_28;
+}
+block_28:
+{
+lean_object* x_16; 
+x_16 = lean_ctor_get(x_15, 3);
 lean_inc(x_16);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_16);
-x_17 = x_41;
-goto block_30;
-}
-}
-else
+if (lean_obj_tag(x_16) == 0)
 {
-lean_object* x_42; lean_object* x_43; 
-lean_dec(x_32);
-x_42 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_16);
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_16);
-x_17 = x_43;
-goto block_30;
-}
-block_30:
+lean_dec(x_14);
+lean_dec(x_13);
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_dec(x_16);
-lean_dec(x_15);
-{
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_17;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_15;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-lean_dec(x_18);
-lean_dec(x_7);
-lean_dec(x_6);
-x_20 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
-lean_dec(x_15);
-x_21 = lean_ctor_get(x_20, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+lean_dec(x_16);
+lean_dec(x_5);
+x_18 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
+lean_dec(x_13);
+x_19 = lean_ctor_get(x_18, 0);
+lean_inc(x_19);
+x_20 = lean_array_get_size(x_19);
+lean_dec(x_19);
+x_21 = lean_nat_sub(x_20, x_2);
+lean_dec(x_20);
+x_22 = lean_unsigned_to_nat(1u);
+x_23 = lean_nat_dec_eq(x_21, x_22);
 lean_dec(x_21);
-x_23 = lean_nat_sub(x_22, x_3);
-lean_dec(x_22);
-x_24 = lean_unsigned_to_nat(1u);
-x_25 = lean_nat_dec_eq(x_23, x_24);
-lean_dec(x_23);
-if (x_25 == 0)
+if (x_23 == 0)
+{
+lean_object* x_24; lean_object* x_25; 
+x_24 = l_Lean_nullKind;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_2);
+return x_25;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_26; lean_object* x_27; 
 x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_3);
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_2);
 return x_27;
 }
 else
 {
+lean_dec(x_2);
+return x_18;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_11);
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_3);
-return x_29;
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_42 = lean_box(0);
+x_43 = l_Lean_Parser_ParserState_pushSyntax(x_10, x_42);
+x_44 = l_Lean_nullKind;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_2);
+return x_45;
 }
 else
 {
-lean_dec(x_3);
-return x_20;
-}
-}
-}
-}
-}
-else
-{
-lean_dec(x_13);
-lean_dec(x_7);
-lean_dec(x_6);
-if (x_5 == 0)
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_44 = lean_box(0);
-x_45 = l_Lean_Parser_ParserState_pushSyntax(x_12, x_44);
-x_46 = l_Lean_nullKind;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_3);
-return x_47;
-}
-else
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
-x_48 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_11);
-lean_dec(x_10);
-x_49 = lean_ctor_get(x_48, 0);
-lean_inc(x_49);
-x_50 = lean_array_get_size(x_49);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; 
+x_46 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_47 = lean_ctor_get(x_46, 0);
+lean_inc(x_47);
+x_48 = lean_array_get_size(x_47);
+lean_dec(x_47);
+x_49 = lean_nat_sub(x_48, x_2);
+lean_dec(x_48);
+x_50 = lean_unsigned_to_nat(2u);
+x_51 = lean_nat_dec_eq(x_49, x_50);
 lean_dec(x_49);
-x_51 = lean_nat_sub(x_50, x_3);
-lean_dec(x_50);
-x_52 = lean_unsigned_to_nat(2u);
-x_53 = lean_nat_dec_eq(x_51, x_52);
-lean_dec(x_51);
-if (x_53 == 0)
+if (x_51 == 0)
+{
+lean_object* x_52; lean_object* x_53; 
+x_52 = l_Lean_nullKind;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_46, x_52, x_2);
+return x_53;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_54; lean_object* x_55; 
 x_54 = l_Lean_nullKind;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_3);
+x_55 = l_Lean_Parser_ParserState_mkNode(x_46, x_54, x_2);
 return x_55;
 }
 else
 {
-if (x_4 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_3);
-return x_57;
-}
-else
-{
-lean_object* x_58; 
-lean_dec(x_3);
-x_58 = l_Lean_Parser_ParserState_popSyntax(x_48);
-return x_58;
+lean_object* x_56; 
+lean_dec(x_2);
+x_56 = l_Lean_Parser_ParserState_popSyntax(x_46);
+return x_56;
 }
 }
 }
 }
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = 0;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2(x_1, x_2, x_8, x_3, x_9, x_4, x_5, x_6);
-return x_10;
+lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = 0;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2(x_1, x_6, x_2, x_7, x_3, x_4);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_attributes___elambda__1___closed__1() {
@@ -3025,13 +2926,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_attributes___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_attributes___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_attributes___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_attributes___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_attributes___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_attributes___elambda__1___closed__5() {
@@ -3083,226 +2983,221 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_attributes___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_attributes___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_attributes___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_attributes___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_56; lean_object* x_57; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_54; lean_object* x_55; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_54 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_55 = lean_ctor_get(x_54, 3);
+lean_inc(x_55);
+if (lean_obj_tag(x_55) == 0)
 {
-lean_object* x_58; lean_object* x_59; 
-x_58 = lean_ctor_get(x_56, 0);
+lean_object* x_56; lean_object* x_57; 
+x_56 = lean_ctor_get(x_54, 0);
+lean_inc(x_56);
+x_57 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_56);
+lean_dec(x_56);
+if (lean_obj_tag(x_57) == 2)
+{
+lean_object* x_58; lean_object* x_59; uint8_t x_60; 
+x_58 = lean_ctor_get(x_57, 1);
 lean_inc(x_58);
-x_59 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_58);
+lean_dec(x_57);
+x_59 = l_Lean_Parser_Command_attributes___elambda__1___closed__6;
+x_60 = lean_string_dec_eq(x_58, x_59);
 lean_dec(x_58);
-if (lean_obj_tag(x_59) == 2)
+if (x_60 == 0)
 {
-lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_60 = lean_ctor_get(x_59, 1);
-lean_inc(x_60);
-lean_dec(x_59);
-x_61 = l_Lean_Parser_Command_attributes___elambda__1___closed__6;
-x_62 = lean_string_dec_eq(x_60, x_61);
-lean_dec(x_60);
-if (x_62 == 0)
+lean_object* x_61; lean_object* x_62; 
+x_61 = l_Lean_Parser_Command_attributes___elambda__1___closed__9;
+lean_inc(x_7);
+x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_7);
+x_16 = x_62;
+goto block_53;
+}
+else
+{
+x_16 = x_54;
+goto block_53;
+}
+}
+else
 {
 lean_object* x_63; lean_object* x_64; 
+lean_dec(x_57);
 x_63 = l_Lean_Parser_Command_attributes___elambda__1___closed__9;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_8);
-x_17 = x_64;
-goto block_55;
-}
-else
-{
-x_17 = x_56;
-goto block_55;
+lean_inc(x_7);
+x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_63, x_7);
+x_16 = x_64;
+goto block_53;
 }
 }
 else
 {
 lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
+lean_dec(x_55);
 x_65 = l_Lean_Parser_Command_attributes___elambda__1___closed__9;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_8);
-x_17 = x_66;
-goto block_55;
+lean_inc(x_7);
+x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_65, x_7);
+x_16 = x_66;
+goto block_53;
 }
-}
-else
+block_53:
 {
-lean_object* x_67; lean_object* x_68; 
-lean_dec(x_57);
-x_67 = l_Lean_Parser_Command_attributes___elambda__1___closed__9;
-lean_inc(x_8);
-x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_8);
-x_17 = x_68;
-goto block_55;
-}
-block_55:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+uint8_t x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = 0;
+lean_inc(x_1);
+x_19 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(x_18, x_18, x_1, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-uint8_t x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = 0;
-x_20 = 0;
-lean_inc(x_2);
-x_21 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(x_19, x_20, x_20, x_1, x_2, x_17);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_19, 1);
+lean_inc(x_21);
+x_22 = l_Lean_Parser_tokenFn(x_1, x_19);
+x_23 = lean_ctor_get(x_22, 3);
 lean_inc(x_23);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
+if (lean_obj_tag(x_23) == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
+lean_object* x_24; lean_object* x_25; 
+x_24 = lean_ctor_get(x_22, 0);
+lean_inc(x_24);
+x_25 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_24);
+lean_dec(x_24);
+if (lean_obj_tag(x_25) == 2)
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_25, 1);
 lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
-{
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_31 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
-x_33 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_16);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_8);
-lean_dec(x_8);
-return x_38;
-}
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_39 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
-x_41 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
 lean_dec(x_25);
-x_44 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
-x_46 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
+x_27 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
+x_28 = lean_string_dec_eq(x_26, x_27);
+lean_dec(x_26);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_29 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+x_31 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_21);
+x_34 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
 }
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_22);
-lean_dec(x_2);
-x_49 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_16);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_11, x_8);
-lean_dec(x_8);
-return x_51;
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_25);
+x_37 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
+x_39 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_23);
+x_42 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
+x_44 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_20);
 lean_dec(x_1);
-x_52 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_17, x_52, x_16);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_8);
-lean_dec(x_8);
-return x_54;
+x_47 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_50 = l_Lean_Parser_Command_attributes___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_16, x_50, x_15);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_10, x_7);
+lean_dec(x_7);
+return x_52;
 }
 }
 }
@@ -3377,7 +3272,7 @@ lean_object* _init_l_Lean_Parser_Command_attributes___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_attributes___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_attributes___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3401,36 +3296,32 @@ x_1 = l_Lean_Parser_Command_attributes___closed__8;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
-lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-return x_13;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
 x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_8 = lean_unbox(x_2);
-lean_dec(x_2);
-x_9 = lean_unbox(x_3);
+x_8 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(x_7, x_8, x_9, x_4, x_5, x_6);
+x_9 = lean_unbox(x_4);
+lean_dec(x_4);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_attributes___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
 return x_10;
 }
 }
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox(x_1);
+lean_dec(x_1);
+x_6 = lean_unbox(x_2);
+lean_dec(x_2);
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(x_5, x_6, x_3, x_4);
+return x_7;
+}
+}
 lean_object* _init_l_Lean_Parser_Command_private___elambda__1___closed__1() {
 _start:
 {
@@ -3462,13 +3353,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_private___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_private___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_private___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_private___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_private___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_private___elambda__1___closed__5() {
@@ -3520,125 +3410,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_private___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_private___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_private___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_private___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_private___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_private___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_private___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_private___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_private___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_private___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_private___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_private___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_private___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_private___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_private___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_private___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_private___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_private___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_private___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_private___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -3680,7 +3570,7 @@ lean_object* _init_l_Lean_Parser_Command_private___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_private___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_private___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3735,13 +3625,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_protected___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_protected___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_protected___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_protected___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_protected___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_protected___elambda__1___closed__5() {
@@ -3793,125 +3682,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_protected___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_protected___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_protected___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_protected___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_protected___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_protected___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_protected___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_protected___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_protected___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_protected___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_protected___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_protected___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_protected___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_protected___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_protected___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_protected___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_protected___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_protected___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_protected___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_protected___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -3953,7 +3842,7 @@ lean_object* _init_l_Lean_Parser_Command_protected___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_protected___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_protected___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3977,58 +3866,55 @@ x_1 = l_Lean_Parser_Command_protected___closed__5;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_visibility___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_visibility___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
-lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-lean_inc(x_2);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
 lean_inc(x_1);
-x_7 = l_Lean_Parser_Command_private___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+x_6 = l_Lean_Parser_Command_private___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_7;
-}
-else
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_7, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_10, x_6);
-lean_dec(x_10);
-if (x_11 == 0)
-{
+x_10 = lean_nat_dec_eq(x_9, x_5);
 lean_dec(x_9);
-lean_dec(x_6);
+if (x_10 == 0)
+{
+lean_dec(x_8);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-lean_inc(x_6);
-x_12 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = l_Lean_Parser_Command_protected___elambda__1(x_1, x_11);
+x_13 = l_Lean_Parser_mergeOrElseErrors(x_12, x_8, x_5);
 lean_dec(x_5);
-x_13 = l_Lean_Parser_Command_protected___elambda__1(x_1, x_2, x_12);
-x_14 = l_Lean_Parser_mergeOrElseErrors(x_13, x_9, x_6);
-lean_dec(x_6);
-return x_14;
+return x_13;
 }
 }
 }
@@ -4051,7 +3937,7 @@ lean_object* _init_l_Lean_Parser_Command_visibility___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_visibility___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_visibility___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4106,13 +3992,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_noncomputable___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_noncomputable___elambda__1___closed__5() {
@@ -4164,125 +4049,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_noncomputable___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_noncomputable___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_noncomputable___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_noncomputable___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -4324,7 +4209,7 @@ lean_object* _init_l_Lean_Parser_Command_noncomputable___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_noncomputable___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_noncomputable___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4379,13 +4264,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_unsafe___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_unsafe___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_unsafe___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_unsafe___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_unsafe___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_unsafe___elambda__1___closed__5() {
@@ -4437,125 +4321,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_unsafe___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_unsafe___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_unsafe___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_unsafe___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_unsafe___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_unsafe___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_unsafe___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_unsafe___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_unsafe___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_unsafe___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_unsafe___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_unsafe___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_unsafe___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_unsafe___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_unsafe___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_unsafe___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_unsafe___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_unsafe___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_unsafe___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_unsafe___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -4597,7 +4481,7 @@ lean_object* _init_l_Lean_Parser_Command_unsafe___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_unsafe___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_unsafe___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4652,13 +4536,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_partial___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_partial___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_partial___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_partial___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_partial___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_partial___elambda__1___closed__5() {
@@ -4710,125 +4593,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_partial___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_partial___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_partial___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_partial___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_partial___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_partial___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_partial___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_partial___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_partial___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_partial___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_partial___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_partial___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_partial___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_partial___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_partial___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_partial___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_partial___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_partial___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_partial___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_partial___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -4870,7 +4753,7 @@ lean_object* _init_l_Lean_Parser_Command_partial___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_partial___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_partial___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4925,463 +4808,449 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_declModifiers___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_declModifiers___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_declModifiers___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_declModifiers___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_46; lean_object* x_66; lean_object* x_86; lean_object* x_106; lean_object* x_126; lean_object* x_127; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_45; lean_object* x_65; lean_object* x_85; lean_object* x_105; lean_object* x_125; lean_object* x_126; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_125 = l_Lean_Parser_Command_docComment___elambda__1(x_1, x_13);
+x_126 = lean_ctor_get(x_125, 3);
+lean_inc(x_126);
+if (lean_obj_tag(x_126) == 0)
+{
+lean_object* x_127; lean_object* x_128; 
+x_127 = l_Lean_nullKind;
 lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-lean_inc(x_1);
-x_126 = l_Lean_Parser_Command_docComment___elambda__1(x_1, x_2, x_14);
-x_127 = lean_ctor_get(x_126, 3);
-lean_inc(x_127);
-if (lean_obj_tag(x_127) == 0)
-{
-lean_object* x_128; lean_object* x_129; 
-x_128 = l_Lean_nullKind;
-lean_inc(x_16);
-x_129 = l_Lean_Parser_ParserState_mkNode(x_126, x_128, x_16);
-x_106 = x_129;
-goto block_125;
+x_128 = l_Lean_Parser_ParserState_mkNode(x_125, x_127, x_15);
+x_105 = x_128;
+goto block_124;
 }
 else
 {
-lean_object* x_130; uint8_t x_131; 
-lean_dec(x_127);
-x_130 = lean_ctor_get(x_126, 1);
-lean_inc(x_130);
-x_131 = lean_nat_dec_eq(x_130, x_8);
-lean_dec(x_130);
-if (x_131 == 0)
+lean_object* x_129; uint8_t x_130; 
+lean_dec(x_126);
+x_129 = lean_ctor_get(x_125, 1);
+lean_inc(x_129);
+x_130 = lean_nat_dec_eq(x_129, x_7);
+lean_dec(x_129);
+if (x_130 == 0)
 {
-lean_object* x_132; lean_object* x_133; 
-x_132 = l_Lean_nullKind;
-lean_inc(x_16);
-x_133 = l_Lean_Parser_ParserState_mkNode(x_126, x_132, x_16);
-x_106 = x_133;
-goto block_125;
+lean_object* x_131; lean_object* x_132; 
+x_131 = l_Lean_nullKind;
+lean_inc(x_15);
+x_132 = l_Lean_Parser_ParserState_mkNode(x_125, x_131, x_15);
+x_105 = x_132;
+goto block_124;
 }
 else
 {
-lean_object* x_134; lean_object* x_135; lean_object* x_136; 
-lean_inc(x_8);
-x_134 = l_Lean_Parser_ParserState_restore(x_126, x_16, x_8);
-x_135 = l_Lean_nullKind;
-lean_inc(x_16);
-x_136 = l_Lean_Parser_ParserState_mkNode(x_134, x_135, x_16);
-x_106 = x_136;
-goto block_125;
+lean_object* x_133; lean_object* x_134; lean_object* x_135; 
+lean_inc(x_7);
+x_133 = l_Lean_Parser_ParserState_restore(x_125, x_15, x_7);
+x_134 = l_Lean_nullKind;
+lean_inc(x_15);
+x_135 = l_Lean_Parser_ParserState_mkNode(x_133, x_134, x_15);
+x_105 = x_135;
+goto block_124;
 }
 }
-block_45:
+block_44:
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-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_22 = l_Lean_Parser_Command_partial___elambda__1(x_1, x_2, x_17);
-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_object* x_27; lean_object* x_28; 
-lean_dec(x_21);
-x_24 = l_Lean_nullKind;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_22, x_24, x_20);
-x_26 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; uint8_t x_30; 
-lean_dec(x_23);
-x_29 = lean_ctor_get(x_22, 1);
-lean_inc(x_29);
-x_30 = lean_nat_dec_eq(x_29, x_21);
-lean_dec(x_29);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_21);
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_22, x_31, x_20);
-x_33 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_36 = l_Lean_Parser_ParserState_restore(x_22, x_20, x_21);
-x_37 = l_Lean_nullKind;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_20);
-x_39 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
-}
-}
-}
-else
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_19 = lean_array_get_size(x_18);
 lean_dec(x_18);
-lean_dec(x_2);
-lean_dec(x_1);
-x_42 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_17, x_42, x_16);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_11, x_8);
-lean_dec(x_8);
-return x_44;
-}
-}
-block_65:
+x_20 = lean_ctor_get(x_16, 1);
+lean_inc(x_20);
+x_21 = l_Lean_Parser_Command_partial___elambda__1(x_1, x_16);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_47; 
-x_47 = lean_ctor_get(x_46, 3);
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+lean_dec(x_20);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_19);
+x_25 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; uint8_t x_29; 
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_21, 1);
+lean_inc(x_28);
+x_29 = lean_nat_dec_eq(x_28, x_20);
+lean_dec(x_28);
+if (x_29 == 0)
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_20);
+x_30 = l_Lean_nullKind;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_21, x_30, x_19);
+x_32 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
+}
+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; 
+x_35 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+x_36 = l_Lean_nullKind;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_19);
+x_38 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+}
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_41 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_16, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
+}
+}
+block_64:
+{
+lean_object* x_46; 
+x_46 = lean_ctor_get(x_45, 3);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+x_47 = lean_ctor_get(x_45, 0);
 lean_inc(x_47);
-if (lean_obj_tag(x_47) == 0)
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_48 = lean_ctor_get(x_46, 0);
-lean_inc(x_48);
-x_49 = lean_array_get_size(x_48);
-lean_dec(x_48);
-x_50 = lean_ctor_get(x_46, 1);
-lean_inc(x_50);
-lean_inc(x_2);
-lean_inc(x_1);
-x_51 = l_Lean_Parser_Command_unsafe___elambda__1(x_1, x_2, x_46);
-x_52 = lean_ctor_get(x_51, 3);
-lean_inc(x_52);
-if (lean_obj_tag(x_52) == 0)
-{
-lean_object* x_53; lean_object* x_54; 
-lean_dec(x_50);
-x_53 = l_Lean_nullKind;
-x_54 = l_Lean_Parser_ParserState_mkNode(x_51, x_53, x_49);
-x_17 = x_54;
-goto block_45;
-}
-else
-{
-lean_object* x_55; uint8_t x_56; 
-lean_dec(x_52);
-x_55 = lean_ctor_get(x_51, 1);
-lean_inc(x_55);
-x_56 = lean_nat_dec_eq(x_55, x_50);
-lean_dec(x_55);
-if (x_56 == 0)
-{
-lean_object* x_57; lean_object* x_58; 
-lean_dec(x_50);
-x_57 = l_Lean_nullKind;
-x_58 = l_Lean_Parser_ParserState_mkNode(x_51, x_57, x_49);
-x_17 = x_58;
-goto block_45;
-}
-else
-{
-lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-x_59 = l_Lean_Parser_ParserState_restore(x_51, x_49, x_50);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_49);
-x_17 = x_61;
-goto block_45;
-}
-}
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+x_48 = lean_array_get_size(x_47);
 lean_dec(x_47);
-lean_dec(x_2);
-lean_dec(x_1);
-x_62 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
-x_63 = l_Lean_Parser_ParserState_mkNode(x_46, x_62, x_16);
-x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_11, x_8);
-lean_dec(x_8);
-return x_64;
-}
-}
-block_85:
+x_49 = lean_ctor_get(x_45, 1);
+lean_inc(x_49);
+lean_inc(x_1);
+x_50 = l_Lean_Parser_Command_unsafe___elambda__1(x_1, x_45);
+x_51 = lean_ctor_get(x_50, 3);
+lean_inc(x_51);
+if (lean_obj_tag(x_51) == 0)
 {
-lean_object* x_67; 
-x_67 = lean_ctor_get(x_66, 3);
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_49);
+x_52 = l_Lean_nullKind;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_50, x_52, x_48);
+x_16 = x_53;
+goto block_44;
+}
+else
+{
+lean_object* x_54; uint8_t x_55; 
+lean_dec(x_51);
+x_54 = lean_ctor_get(x_50, 1);
+lean_inc(x_54);
+x_55 = lean_nat_dec_eq(x_54, x_49);
+lean_dec(x_54);
+if (x_55 == 0)
+{
+lean_object* x_56; lean_object* x_57; 
+lean_dec(x_49);
+x_56 = l_Lean_nullKind;
+x_57 = l_Lean_Parser_ParserState_mkNode(x_50, x_56, x_48);
+x_16 = x_57;
+goto block_44;
+}
+else
+{
+lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_58 = l_Lean_Parser_ParserState_restore(x_50, x_48, x_49);
+x_59 = l_Lean_nullKind;
+x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_48);
+x_16 = x_60;
+goto block_44;
+}
+}
+}
+else
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+lean_dec(x_46);
+lean_dec(x_1);
+x_61 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
+x_62 = l_Lean_Parser_ParserState_mkNode(x_45, x_61, x_15);
+x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_10, x_7);
+lean_dec(x_7);
+return x_63;
+}
+}
+block_84:
+{
+lean_object* x_66; 
+x_66 = lean_ctor_get(x_65, 3);
+lean_inc(x_66);
+if (lean_obj_tag(x_66) == 0)
+{
+lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+x_67 = lean_ctor_get(x_65, 0);
 lean_inc(x_67);
-if (lean_obj_tag(x_67) == 0)
-{
-lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
-x_68 = lean_ctor_get(x_66, 0);
-lean_inc(x_68);
-x_69 = lean_array_get_size(x_68);
-lean_dec(x_68);
-x_70 = lean_ctor_get(x_66, 1);
-lean_inc(x_70);
-lean_inc(x_2);
-lean_inc(x_1);
-x_71 = l_Lean_Parser_Command_noncomputable___elambda__1(x_1, x_2, x_66);
-x_72 = lean_ctor_get(x_71, 3);
-lean_inc(x_72);
-if (lean_obj_tag(x_72) == 0)
-{
-lean_object* x_73; lean_object* x_74; 
-lean_dec(x_70);
-x_73 = l_Lean_nullKind;
-x_74 = l_Lean_Parser_ParserState_mkNode(x_71, x_73, x_69);
-x_46 = x_74;
-goto block_65;
-}
-else
-{
-lean_object* x_75; uint8_t x_76; 
-lean_dec(x_72);
-x_75 = lean_ctor_get(x_71, 1);
-lean_inc(x_75);
-x_76 = lean_nat_dec_eq(x_75, x_70);
-lean_dec(x_75);
-if (x_76 == 0)
-{
-lean_object* x_77; lean_object* x_78; 
-lean_dec(x_70);
-x_77 = l_Lean_nullKind;
-x_78 = l_Lean_Parser_ParserState_mkNode(x_71, x_77, x_69);
-x_46 = x_78;
-goto block_65;
-}
-else
-{
-lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-x_79 = l_Lean_Parser_ParserState_restore(x_71, x_69, x_70);
-x_80 = l_Lean_nullKind;
-x_81 = l_Lean_Parser_ParserState_mkNode(x_79, x_80, x_69);
-x_46 = x_81;
-goto block_65;
-}
-}
-}
-else
-{
-lean_object* x_82; lean_object* x_83; lean_object* x_84; 
+x_68 = lean_array_get_size(x_67);
 lean_dec(x_67);
-lean_dec(x_2);
-lean_dec(x_1);
-x_82 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
-x_83 = l_Lean_Parser_ParserState_mkNode(x_66, x_82, x_16);
-x_84 = l_Lean_Parser_mergeOrElseErrors(x_83, x_11, x_8);
-lean_dec(x_8);
-return x_84;
-}
-}
-block_105:
+x_69 = lean_ctor_get(x_65, 1);
+lean_inc(x_69);
+lean_inc(x_1);
+x_70 = l_Lean_Parser_Command_noncomputable___elambda__1(x_1, x_65);
+x_71 = lean_ctor_get(x_70, 3);
+lean_inc(x_71);
+if (lean_obj_tag(x_71) == 0)
 {
-lean_object* x_87; 
-x_87 = lean_ctor_get(x_86, 3);
+lean_object* x_72; lean_object* x_73; 
+lean_dec(x_69);
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_70, x_72, x_68);
+x_45 = x_73;
+goto block_64;
+}
+else
+{
+lean_object* x_74; uint8_t x_75; 
+lean_dec(x_71);
+x_74 = lean_ctor_get(x_70, 1);
+lean_inc(x_74);
+x_75 = lean_nat_dec_eq(x_74, x_69);
+lean_dec(x_74);
+if (x_75 == 0)
+{
+lean_object* x_76; lean_object* x_77; 
+lean_dec(x_69);
+x_76 = l_Lean_nullKind;
+x_77 = l_Lean_Parser_ParserState_mkNode(x_70, x_76, x_68);
+x_45 = x_77;
+goto block_64;
+}
+else
+{
+lean_object* x_78; lean_object* x_79; lean_object* x_80; 
+x_78 = l_Lean_Parser_ParserState_restore(x_70, x_68, x_69);
+x_79 = l_Lean_nullKind;
+x_80 = l_Lean_Parser_ParserState_mkNode(x_78, x_79, x_68);
+x_45 = x_80;
+goto block_64;
+}
+}
+}
+else
+{
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+lean_dec(x_66);
+lean_dec(x_1);
+x_81 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
+x_82 = l_Lean_Parser_ParserState_mkNode(x_65, x_81, x_15);
+x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_10, x_7);
+lean_dec(x_7);
+return x_83;
+}
+}
+block_104:
+{
+lean_object* x_86; 
+x_86 = lean_ctor_get(x_85, 3);
+lean_inc(x_86);
+if (lean_obj_tag(x_86) == 0)
+{
+lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
+x_87 = lean_ctor_get(x_85, 0);
 lean_inc(x_87);
-if (lean_obj_tag(x_87) == 0)
-{
-lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-x_88 = lean_ctor_get(x_86, 0);
-lean_inc(x_88);
-x_89 = lean_array_get_size(x_88);
-lean_dec(x_88);
-x_90 = lean_ctor_get(x_86, 1);
-lean_inc(x_90);
-lean_inc(x_2);
-lean_inc(x_1);
-x_91 = l_Lean_Parser_Command_visibility___elambda__1(x_1, x_2, x_86);
-x_92 = lean_ctor_get(x_91, 3);
-lean_inc(x_92);
-if (lean_obj_tag(x_92) == 0)
-{
-lean_object* x_93; lean_object* x_94; 
-lean_dec(x_90);
-x_93 = l_Lean_nullKind;
-x_94 = l_Lean_Parser_ParserState_mkNode(x_91, x_93, x_89);
-x_66 = x_94;
-goto block_85;
-}
-else
-{
-lean_object* x_95; uint8_t x_96; 
-lean_dec(x_92);
-x_95 = lean_ctor_get(x_91, 1);
-lean_inc(x_95);
-x_96 = lean_nat_dec_eq(x_95, x_90);
-lean_dec(x_95);
-if (x_96 == 0)
-{
-lean_object* x_97; lean_object* x_98; 
-lean_dec(x_90);
-x_97 = l_Lean_nullKind;
-x_98 = l_Lean_Parser_ParserState_mkNode(x_91, x_97, x_89);
-x_66 = x_98;
-goto block_85;
-}
-else
-{
-lean_object* x_99; lean_object* x_100; lean_object* x_101; 
-x_99 = l_Lean_Parser_ParserState_restore(x_91, x_89, x_90);
-x_100 = l_Lean_nullKind;
-x_101 = l_Lean_Parser_ParserState_mkNode(x_99, x_100, x_89);
-x_66 = x_101;
-goto block_85;
-}
-}
-}
-else
-{
-lean_object* x_102; lean_object* x_103; lean_object* x_104; 
+x_88 = lean_array_get_size(x_87);
 lean_dec(x_87);
-lean_dec(x_2);
-lean_dec(x_1);
-x_102 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
-x_103 = l_Lean_Parser_ParserState_mkNode(x_86, x_102, x_16);
-x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_11, x_8);
-lean_dec(x_8);
-return x_104;
-}
-}
-block_125:
-{
-lean_object* x_107; 
-x_107 = lean_ctor_get(x_106, 3);
-lean_inc(x_107);
-if (lean_obj_tag(x_107) == 0)
-{
-lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; 
-x_108 = lean_ctor_get(x_106, 0);
-lean_inc(x_108);
-x_109 = lean_array_get_size(x_108);
-lean_dec(x_108);
-x_110 = lean_ctor_get(x_106, 1);
-lean_inc(x_110);
-lean_inc(x_2);
+x_89 = lean_ctor_get(x_85, 1);
+lean_inc(x_89);
 lean_inc(x_1);
-x_111 = l_Lean_Parser_Command_attributes___elambda__1(x_1, x_2, x_106);
-x_112 = lean_ctor_get(x_111, 3);
-lean_inc(x_112);
-if (lean_obj_tag(x_112) == 0)
+x_90 = l_Lean_Parser_Command_visibility___elambda__1(x_1, x_85);
+x_91 = lean_ctor_get(x_90, 3);
+lean_inc(x_91);
+if (lean_obj_tag(x_91) == 0)
 {
-lean_object* x_113; lean_object* x_114; 
-lean_dec(x_110);
-x_113 = l_Lean_nullKind;
-x_114 = l_Lean_Parser_ParserState_mkNode(x_111, x_113, x_109);
-x_86 = x_114;
-goto block_105;
+lean_object* x_92; lean_object* x_93; 
+lean_dec(x_89);
+x_92 = l_Lean_nullKind;
+x_93 = l_Lean_Parser_ParserState_mkNode(x_90, x_92, x_88);
+x_65 = x_93;
+goto block_84;
 }
 else
 {
-lean_object* x_115; uint8_t x_116; 
-lean_dec(x_112);
-x_115 = lean_ctor_get(x_111, 1);
-lean_inc(x_115);
-x_116 = lean_nat_dec_eq(x_115, x_110);
-lean_dec(x_115);
-if (x_116 == 0)
+lean_object* x_94; uint8_t x_95; 
+lean_dec(x_91);
+x_94 = lean_ctor_get(x_90, 1);
+lean_inc(x_94);
+x_95 = lean_nat_dec_eq(x_94, x_89);
+lean_dec(x_94);
+if (x_95 == 0)
 {
-lean_object* x_117; lean_object* x_118; 
-lean_dec(x_110);
-x_117 = l_Lean_nullKind;
-x_118 = l_Lean_Parser_ParserState_mkNode(x_111, x_117, x_109);
-x_86 = x_118;
-goto block_105;
+lean_object* x_96; lean_object* x_97; 
+lean_dec(x_89);
+x_96 = l_Lean_nullKind;
+x_97 = l_Lean_Parser_ParserState_mkNode(x_90, x_96, x_88);
+x_65 = x_97;
+goto block_84;
 }
 else
 {
-lean_object* x_119; lean_object* x_120; lean_object* x_121; 
-x_119 = l_Lean_Parser_ParserState_restore(x_111, x_109, x_110);
-x_120 = l_Lean_nullKind;
-x_121 = l_Lean_Parser_ParserState_mkNode(x_119, x_120, x_109);
-x_86 = x_121;
-goto block_105;
+lean_object* x_98; lean_object* x_99; lean_object* x_100; 
+x_98 = l_Lean_Parser_ParserState_restore(x_90, x_88, x_89);
+x_99 = l_Lean_nullKind;
+x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_88);
+x_65 = x_100;
+goto block_84;
 }
 }
 }
 else
 {
-lean_object* x_122; lean_object* x_123; lean_object* x_124; 
-lean_dec(x_107);
-lean_dec(x_2);
+lean_object* x_101; lean_object* x_102; lean_object* x_103; 
+lean_dec(x_86);
 lean_dec(x_1);
-x_122 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
-x_123 = l_Lean_Parser_ParserState_mkNode(x_106, x_122, x_16);
-x_124 = l_Lean_Parser_mergeOrElseErrors(x_123, x_11, x_8);
-lean_dec(x_8);
-return x_124;
+x_101 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
+x_102 = l_Lean_Parser_ParserState_mkNode(x_85, x_101, x_15);
+x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_10, x_7);
+lean_dec(x_7);
+return x_103;
+}
+}
+block_124:
+{
+lean_object* x_106; 
+x_106 = lean_ctor_get(x_105, 3);
+lean_inc(x_106);
+if (lean_obj_tag(x_106) == 0)
+{
+lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; 
+x_107 = lean_ctor_get(x_105, 0);
+lean_inc(x_107);
+x_108 = lean_array_get_size(x_107);
+lean_dec(x_107);
+x_109 = lean_ctor_get(x_105, 1);
+lean_inc(x_109);
+lean_inc(x_1);
+x_110 = l_Lean_Parser_Command_attributes___elambda__1(x_1, x_105);
+x_111 = lean_ctor_get(x_110, 3);
+lean_inc(x_111);
+if (lean_obj_tag(x_111) == 0)
+{
+lean_object* x_112; lean_object* x_113; 
+lean_dec(x_109);
+x_112 = l_Lean_nullKind;
+x_113 = l_Lean_Parser_ParserState_mkNode(x_110, x_112, x_108);
+x_85 = x_113;
+goto block_104;
+}
+else
+{
+lean_object* x_114; uint8_t x_115; 
+lean_dec(x_111);
+x_114 = lean_ctor_get(x_110, 1);
+lean_inc(x_114);
+x_115 = lean_nat_dec_eq(x_114, x_109);
+lean_dec(x_114);
+if (x_115 == 0)
+{
+lean_object* x_116; lean_object* x_117; 
+lean_dec(x_109);
+x_116 = l_Lean_nullKind;
+x_117 = l_Lean_Parser_ParserState_mkNode(x_110, x_116, x_108);
+x_85 = x_117;
+goto block_104;
+}
+else
+{
+lean_object* x_118; lean_object* x_119; lean_object* x_120; 
+x_118 = l_Lean_Parser_ParserState_restore(x_110, x_108, x_109);
+x_119 = l_Lean_nullKind;
+x_120 = l_Lean_Parser_ParserState_mkNode(x_118, x_119, x_108);
+x_85 = x_120;
+goto block_104;
+}
+}
+}
+else
+{
+lean_object* x_121; lean_object* x_122; lean_object* x_123; 
+lean_dec(x_106);
+lean_dec(x_1);
+x_121 = l_Lean_Parser_Command_declModifiers___elambda__1___closed__2;
+x_122 = l_Lean_Parser_ParserState_mkNode(x_105, x_121, x_15);
+x_123 = l_Lean_Parser_mergeOrElseErrors(x_122, x_10, x_7);
+lean_dec(x_7);
+return x_123;
 }
 }
 }
@@ -5530,7 +5399,7 @@ lean_object* _init_l_Lean_Parser_Command_declModifiers___closed__14() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declModifiers___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declModifiers___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5554,219 +5423,213 @@ x_1 = l_Lean_Parser_Command_declModifiers___closed__15;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-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; 
-x_9 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_10 = lean_ctor_get(x_9, 1);
-lean_inc(x_10);
-x_11 = lean_ctor_get(x_8, 0);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+lean_inc(x_5);
+x_10 = l_Lean_Parser_ident___elambda__1(x_5, x_6);
+x_11 = lean_ctor_get(x_10, 3);
 lean_inc(x_11);
-x_12 = lean_array_get_size(x_11);
-lean_dec(x_11);
-x_13 = lean_ctor_get(x_8, 1);
-lean_inc(x_13);
-lean_inc(x_7);
-lean_inc(x_6);
-x_14 = lean_apply_3(x_10, x_6, x_7, x_8);
-x_15 = lean_ctor_get(x_14, 3);
-lean_inc(x_15);
-if (lean_obj_tag(x_15) == 0)
+if (lean_obj_tag(x_11) == 0)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_33; lean_object* x_34; 
-lean_dec(x_13);
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_12 = lean_ctor_get(x_10, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
 lean_dec(x_12);
-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_inc(x_18);
-lean_inc(x_7);
-x_33 = l_Lean_Parser_tokenFn(x_7, x_14);
-x_34 = lean_ctor_get(x_33, 3);
-lean_inc(x_34);
-if (lean_obj_tag(x_34) == 0)
+x_14 = lean_ctor_get(x_10, 1);
+lean_inc(x_14);
+lean_inc(x_5);
+x_29 = l_Lean_Parser_tokenFn(x_5, x_10);
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_35; lean_object* x_36; 
-x_35 = lean_ctor_get(x_33, 0);
-lean_inc(x_35);
-x_36 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_35);
-lean_dec(x_35);
-if (lean_obj_tag(x_36) == 2)
+lean_object* x_31; lean_object* x_32; 
+x_31 = lean_ctor_get(x_29, 0);
+lean_inc(x_31);
+x_32 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_31);
+lean_dec(x_31);
+if (lean_obj_tag(x_32) == 2)
 {
-lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_37 = lean_ctor_get(x_36, 1);
-lean_inc(x_37);
-lean_dec(x_36);
-x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_39 = lean_string_dec_eq(x_37, x_38);
-lean_dec(x_37);
-if (x_39 == 0)
+lean_object* x_33; lean_object* x_34; uint8_t x_35; 
+x_33 = lean_ctor_get(x_32, 1);
+lean_inc(x_33);
+lean_dec(x_32);
+x_34 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_35 = lean_string_dec_eq(x_33, x_34);
+lean_dec(x_33);
+if (x_35 == 0)
+{
+lean_object* x_36; lean_object* x_37; 
+x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_14);
+x_15 = x_37;
+goto block_28;
+}
+else
+{
+x_15 = x_29;
+goto block_28;
+}
+}
+else
+{
+lean_object* x_38; lean_object* x_39; 
+lean_dec(x_32);
+x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_14);
+x_15 = x_39;
+goto block_28;
+}
+}
+else
 {
 lean_object* x_40; lean_object* x_41; 
+lean_dec(x_30);
 x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_18);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_18);
-x_19 = x_41;
-goto block_32;
+lean_inc(x_14);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_14);
+x_15 = x_41;
+goto block_28;
 }
-else
+block_28:
 {
-x_19 = x_33;
-goto block_32;
-}
-}
-else
+lean_object* x_16; 
+x_16 = lean_ctor_get(x_15, 3);
+lean_inc(x_16);
+if (lean_obj_tag(x_16) == 0)
 {
-lean_object* x_42; lean_object* x_43; 
-lean_dec(x_36);
-x_42 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_18);
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_42, x_18);
-x_19 = x_43;
-goto block_32;
-}
-}
-else
+lean_dec(x_14);
+lean_dec(x_13);
 {
-lean_object* x_44; lean_object* x_45; 
-lean_dec(x_34);
-x_44 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_18);
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_44, x_18);
-x_19 = x_45;
-goto block_32;
-}
-block_32:
-{
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_dec(x_18);
-lean_dec(x_17);
-{
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_19;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_15;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
-lean_dec(x_20);
-lean_dec(x_7);
-lean_dec(x_6);
-x_22 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
-lean_dec(x_17);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
-lean_dec(x_23);
-x_25 = lean_nat_sub(x_24, x_3);
-lean_dec(x_24);
-x_26 = lean_unsigned_to_nat(1u);
-x_27 = lean_nat_dec_eq(x_25, x_26);
-lean_dec(x_25);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_3);
-return x_29;
-}
-else
-{
-if (x_4 == 0)
-{
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Lean_nullKind;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_3);
-return x_31;
-}
-else
-{
-lean_dec(x_3);
-return x_22;
-}
-}
-}
-}
-}
-else
-{
-lean_dec(x_15);
-lean_dec(x_7);
-lean_dec(x_6);
-if (x_5 == 0)
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+lean_dec(x_16);
+lean_dec(x_5);
+x_18 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
 lean_dec(x_13);
-lean_dec(x_12);
-x_46 = lean_box(0);
-x_47 = l_Lean_Parser_ParserState_pushSyntax(x_14, x_46);
-x_48 = l_Lean_nullKind;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_3);
-return x_49;
+x_19 = lean_ctor_get(x_18, 0);
+lean_inc(x_19);
+x_20 = lean_array_get_size(x_19);
+lean_dec(x_19);
+x_21 = lean_nat_sub(x_20, x_2);
+lean_dec(x_20);
+x_22 = lean_unsigned_to_nat(1u);
+x_23 = lean_nat_dec_eq(x_21, x_22);
+lean_dec(x_21);
+if (x_23 == 0)
+{
+lean_object* x_24; lean_object* x_25; 
+x_24 = l_Lean_nullKind;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_2);
+return x_25;
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_50 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13);
-lean_dec(x_12);
-x_51 = lean_ctor_get(x_50, 0);
-lean_inc(x_51);
-x_52 = lean_array_get_size(x_51);
-lean_dec(x_51);
-x_53 = lean_nat_sub(x_52, x_3);
-lean_dec(x_52);
-x_54 = lean_unsigned_to_nat(2u);
-x_55 = lean_nat_dec_eq(x_53, x_54);
-lean_dec(x_53);
-if (x_55 == 0)
+if (x_3 == 0)
 {
-lean_object* x_56; lean_object* x_57; 
-x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_50, x_56, x_3);
-return x_57;
+lean_object* x_26; lean_object* x_27; 
+x_26 = l_Lean_nullKind;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_2);
+return x_27;
 }
 else
 {
+lean_dec(x_2);
+return x_18;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_11);
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_58; lean_object* x_59; 
-x_58 = l_Lean_nullKind;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_50, x_58, x_3);
-return x_59;
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_42 = lean_box(0);
+x_43 = l_Lean_Parser_ParserState_pushSyntax(x_10, x_42);
+x_44 = l_Lean_nullKind;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_2);
+return x_45;
 }
 else
 {
-lean_object* x_60; 
-lean_dec(x_3);
-x_60 = l_Lean_Parser_ParserState_popSyntax(x_50);
-return x_60;
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; 
+x_46 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_47 = lean_ctor_get(x_46, 0);
+lean_inc(x_47);
+x_48 = lean_array_get_size(x_47);
+lean_dec(x_47);
+x_49 = lean_nat_sub(x_48, x_2);
+lean_dec(x_48);
+x_50 = lean_unsigned_to_nat(2u);
+x_51 = lean_nat_dec_eq(x_49, x_50);
+lean_dec(x_49);
+if (x_51 == 0)
+{
+lean_object* x_52; lean_object* x_53; 
+x_52 = l_Lean_nullKind;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_46, x_52, x_2);
+return x_53;
+}
+else
+{
+if (x_3 == 0)
+{
+lean_object* x_54; lean_object* x_55; 
+x_54 = l_Lean_nullKind;
+x_55 = l_Lean_Parser_ParserState_mkNode(x_46, x_54, x_2);
+return x_55;
+}
+else
+{
+lean_object* x_56; 
+lean_dec(x_2);
+x_56 = l_Lean_Parser_ParserState_popSyntax(x_46);
+return x_56;
 }
 }
 }
 }
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = 0;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2(x_1, x_2, x_8, x_3, x_9, x_4, x_5, x_6);
-return x_10;
+lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = 0;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2(x_1, x_6, x_2, x_7, x_3, x_4);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_declId___elambda__1___closed__1() {
@@ -5800,298 +5663,285 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_declId___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_declId___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_declId___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_declId___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_declId___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_declId___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_declId___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_declId___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_declId___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_16 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_42; lean_object* x_62; lean_object* x_63; 
+x_18 = lean_ctor_get(x_16, 0);
+lean_inc(x_18);
+x_19 = lean_array_get_size(x_18);
+lean_dec(x_18);
+x_20 = lean_ctor_get(x_16, 1);
+lean_inc(x_20);
+lean_inc(x_1);
+x_62 = l_Lean_Parser_tokenFn(x_1, x_16);
+x_63 = lean_ctor_get(x_62, 3);
+lean_inc(x_63);
+if (lean_obj_tag(x_63) == 0)
+{
+lean_object* x_64; lean_object* x_65; 
+x_64 = lean_ctor_get(x_62, 0);
+lean_inc(x_64);
+x_65 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_64);
+lean_dec(x_64);
+if (lean_obj_tag(x_65) == 2)
+{
+lean_object* x_66; lean_object* x_67; uint8_t x_68; 
+x_66 = lean_ctor_get(x_65, 1);
+lean_inc(x_66);
+lean_dec(x_65);
+x_67 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__6;
+x_68 = lean_string_dec_eq(x_66, x_67);
+lean_dec(x_66);
+if (x_68 == 0)
+{
+lean_object* x_69; lean_object* x_70; 
+x_69 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
+lean_inc(x_20);
+x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_69, x_20);
+x_42 = x_70;
+goto block_61;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
+x_42 = x_62;
+goto block_61;
+}
+}
+else
+{
+lean_object* x_71; lean_object* x_72; 
+lean_dec(x_65);
+x_71 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
 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_24; lean_object* x_45; lean_object* x_66; lean_object* x_67; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = lean_ctor_get(x_19, 1);
-lean_inc(x_23);
-lean_inc(x_2);
-x_66 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_67 = lean_ctor_get(x_66, 3);
-lean_inc(x_67);
-if (lean_obj_tag(x_67) == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = lean_ctor_get(x_66, 0);
-lean_inc(x_68);
-x_69 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_68);
-lean_dec(x_68);
-if (lean_obj_tag(x_69) == 2)
-{
-lean_object* x_70; lean_object* x_71; uint8_t x_72; 
-x_70 = lean_ctor_get(x_69, 1);
-lean_inc(x_70);
-lean_dec(x_69);
-x_71 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__6;
-x_72 = lean_string_dec_eq(x_70, x_71);
-lean_dec(x_70);
-if (x_72 == 0)
+x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_71, x_20);
+x_42 = x_72;
+goto block_61;
+}
+}
+else
 {
 lean_object* x_73; lean_object* x_74; 
+lean_dec(x_63);
 x_73 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
-lean_inc(x_23);
-x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_73, x_23);
-x_45 = x_74;
-goto block_65;
+lean_inc(x_20);
+x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_73, x_20);
+x_42 = x_74;
+goto block_61;
+}
+block_41:
+{
+lean_object* x_22; 
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+lean_dec(x_20);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_19);
+x_25 = l_Lean_Parser_Command_declId___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
 }
 else
 {
-x_45 = x_66;
-goto block_65;
-}
+lean_object* x_28; uint8_t x_29; 
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_21, 1);
+lean_inc(x_28);
+x_29 = lean_nat_dec_eq(x_28, x_20);
+lean_dec(x_28);
+if (x_29 == 0)
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_20);
+x_30 = l_Lean_nullKind;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_21, x_30, x_19);
+x_32 = l_Lean_Parser_Command_declId___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
 }
 else
 {
-lean_object* x_75; lean_object* x_76; 
-lean_dec(x_69);
-x_75 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
-lean_inc(x_23);
-x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_75, x_23);
-x_45 = x_76;
-goto block_65;
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_35 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+x_36 = l_Lean_nullKind;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_19);
+x_38 = l_Lean_Parser_Command_declId___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
-else
+}
+block_61:
 {
-lean_object* x_77; lean_object* x_78; 
-lean_dec(x_67);
-x_77 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
-lean_inc(x_23);
-x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_77, x_23);
-x_45 = x_78;
-goto block_65;
-}
-block_44:
+lean_object* x_43; 
+x_43 = lean_ctor_get(x_42, 3);
+lean_inc(x_43);
+if (lean_obj_tag(x_43) == 0)
 {
-lean_object* x_25; 
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_23);
-x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_22);
-x_28 = l_Lean_Parser_Command_declId___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_18);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_13, x_10);
-lean_dec(x_10);
-return x_30;
-}
-else
-{
-lean_object* x_31; uint8_t x_32; 
-lean_dec(x_25);
-x_31 = lean_ctor_get(x_24, 1);
-lean_inc(x_31);
-x_32 = lean_nat_dec_eq(x_31, x_23);
-lean_dec(x_31);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_23);
-x_33 = l_Lean_nullKind;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_24, x_33, x_22);
-x_35 = l_Lean_Parser_Command_declId___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_18);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_13, x_10);
-lean_dec(x_10);
-return x_37;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_38 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
-x_39 = l_Lean_nullKind;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_22);
-x_41 = l_Lean_Parser_Command_declId___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_18);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_13, x_10);
-lean_dec(x_10);
-return x_43;
-}
-}
-}
-block_65:
-{
-lean_object* x_46; 
+uint8_t x_44; lean_object* x_45; lean_object* x_46; 
+x_44 = 0;
+lean_inc(x_1);
+x_45 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1(x_44, x_44, x_1, x_42);
 x_46 = lean_ctor_get(x_45, 3);
 lean_inc(x_46);
 if (lean_obj_tag(x_46) == 0)
 {
-uint8_t x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; 
-x_47 = 0;
-x_48 = 0;
-lean_inc(x_2);
-x_49 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1(x_47, x_48, x_48, x_1, x_2, x_45);
-x_50 = lean_ctor_get(x_49, 3);
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_47 = lean_ctor_get(x_45, 1);
+lean_inc(x_47);
+x_48 = l_Lean_Parser_tokenFn(x_1, x_45);
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_object* x_50; lean_object* x_51; 
+x_50 = lean_ctor_get(x_48, 0);
 lean_inc(x_50);
-if (lean_obj_tag(x_50) == 0)
+x_51 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_50);
+lean_dec(x_50);
+if (lean_obj_tag(x_51) == 2)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-x_51 = lean_ctor_get(x_49, 1);
-lean_inc(x_51);
-x_52 = l_Lean_Parser_tokenFn(x_2, x_49);
-x_53 = lean_ctor_get(x_52, 3);
-lean_inc(x_53);
-if (lean_obj_tag(x_53) == 0)
+lean_object* x_52; lean_object* x_53; uint8_t x_54; 
+x_52 = lean_ctor_get(x_51, 1);
+lean_inc(x_52);
+lean_dec(x_51);
+x_53 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
+x_54 = lean_string_dec_eq(x_52, x_53);
+lean_dec(x_52);
+if (x_54 == 0)
 {
-lean_object* x_54; lean_object* x_55; 
-x_54 = lean_ctor_get(x_52, 0);
-lean_inc(x_54);
-x_55 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_54);
-lean_dec(x_54);
-if (lean_obj_tag(x_55) == 2)
+lean_object* x_55; lean_object* x_56; 
+x_55 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_55, x_47);
+x_21 = x_56;
+goto block_41;
+}
+else
 {
-lean_object* x_56; lean_object* x_57; uint8_t x_58; 
-x_56 = lean_ctor_get(x_55, 1);
-lean_inc(x_56);
-lean_dec(x_55);
-x_57 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
-x_58 = lean_string_dec_eq(x_56, x_57);
-lean_dec(x_56);
-if (x_58 == 0)
+lean_dec(x_47);
+x_21 = x_48;
+goto block_41;
+}
+}
+else
+{
+lean_object* x_57; lean_object* x_58; 
+lean_dec(x_51);
+x_57 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_57, x_47);
+x_21 = x_58;
+goto block_41;
+}
+}
+else
 {
 lean_object* x_59; lean_object* x_60; 
+lean_dec(x_49);
 x_59 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_59, x_51);
-x_24 = x_60;
-goto block_44;
-}
-else
-{
-lean_dec(x_51);
-x_24 = x_52;
-goto block_44;
-}
-}
-else
-{
-lean_object* x_61; lean_object* x_62; 
-lean_dec(x_55);
-x_61 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_61, x_51);
-x_24 = x_62;
-goto block_44;
-}
-}
-else
-{
-lean_object* x_63; lean_object* x_64; 
-lean_dec(x_53);
-x_63 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_63, x_51);
-x_24 = x_64;
-goto block_44;
-}
-}
-else
-{
-lean_dec(x_50);
-lean_dec(x_2);
-x_24 = x_49;
-goto block_44;
+x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_59, x_47);
+x_21 = x_60;
+goto block_41;
 }
 }
 else
 {
 lean_dec(x_46);
-lean_dec(x_2);
 lean_dec(x_1);
-x_24 = x_45;
-goto block_44;
+x_21 = x_45;
+goto block_41;
+}
+}
+else
+{
+lean_dec(x_43);
+lean_dec(x_1);
+x_21 = x_42;
+goto block_41;
 }
 }
 }
 else
 {
-lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_75; lean_object* x_76; lean_object* x_77; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_79 = l_Lean_Parser_Command_declId___elambda__1___closed__2;
-x_80 = l_Lean_Parser_ParserState_mkNode(x_19, x_79, x_18);
-x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_13, x_10);
-lean_dec(x_10);
-return x_81;
+x_75 = l_Lean_Parser_Command_declId___elambda__1___closed__2;
+x_76 = l_Lean_Parser_ParserState_mkNode(x_16, x_75, x_15);
+x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_10, x_7);
+lean_dec(x_7);
+return x_77;
 }
 }
 }
@@ -6101,7 +5951,7 @@ lean_object* _init_l_Lean_Parser_Command_declId___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_explicitUniv___closed__2;
@@ -6142,7 +5992,7 @@ lean_object* _init_l_Lean_Parser_Command_declId___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_declId___closed__4;
@@ -6176,7 +6026,7 @@ lean_object* _init_l_Lean_Parser_Command_declId___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declId___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declId___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6200,36 +6050,32 @@ x_1 = l_Lean_Parser_Command_declId___closed__9;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
-lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-return x_13;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
 x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_8 = lean_unbox(x_2);
-lean_dec(x_2);
-x_9 = lean_unbox(x_3);
+x_8 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1(x_7, x_8, x_9, x_4, x_5, x_6);
+x_9 = lean_unbox(x_4);
+lean_dec(x_4);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_declId___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
 return x_10;
 }
 }
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox(x_1);
+lean_dec(x_1);
+x_6 = lean_unbox(x_2);
+lean_dec(x_2);
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_declId___elambda__1___spec__1(x_5, x_6, x_3, x_4);
+return x_7;
+}
+}
 lean_object* _init_l_Lean_Parser_Command_declSig___elambda__1___closed__1() {
 _start:
 {
@@ -6261,105 +6107,98 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_declSig___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_declSig___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_declSig___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_declSig___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_declSig___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_declSig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_declSig___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_declSig___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Command_declSig___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
+lean_inc(x_1);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
 lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
-lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = 0;
-lean_inc(x_2);
+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_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
 lean_inc(x_1);
-x_20 = l_Lean_Parser_manyAux___main(x_19, x_5, x_1, x_2, x_16);
-x_21 = l_Lean_nullKind;
-lean_inc(x_18);
-x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_18);
-x_23 = lean_ctor_get(x_22, 3);
-lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
+x_18 = l_Lean_Parser_manyAux___main(x_4, x_1, x_15);
+x_19 = l_Lean_nullKind;
+lean_inc(x_17);
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_17);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_24 = l_Lean_Parser_Term_typeSpec___elambda__1(x_1, x_2, x_22);
-x_25 = l_Lean_Parser_Command_declSig___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_22 = l_Lean_Parser_Term_typeSpec___elambda__1(x_1, x_20);
+x_23 = l_Lean_Parser_Command_declSig___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_17);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_12, x_9);
+lean_dec(x_9);
+return x_25;
 }
 else
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_23);
-lean_dec(x_2);
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_28 = l_Lean_Parser_Command_declSig___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_18);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_13, x_10);
-lean_dec(x_10);
-return x_30;
+x_26 = l_Lean_Parser_Command_declSig___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_17);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_12, x_9);
+lean_dec(x_9);
+return x_28;
 }
 }
 }
@@ -6403,7 +6242,7 @@ lean_object* _init_l_Lean_Parser_Command_declSig___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declSig___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declSig___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6458,105 +6297,98 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_optDeclSig___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_optDeclSig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_optDeclSig___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
+lean_inc(x_1);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
 lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
-lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = 0;
-lean_inc(x_2);
+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_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
 lean_inc(x_1);
-x_20 = l_Lean_Parser_manyAux___main(x_19, x_5, x_1, x_2, x_16);
-x_21 = l_Lean_nullKind;
-lean_inc(x_18);
-x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_18);
-x_23 = lean_ctor_get(x_22, 3);
-lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
+x_18 = l_Lean_Parser_manyAux___main(x_4, x_1, x_15);
+x_19 = l_Lean_nullKind;
+lean_inc(x_17);
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_17);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_24 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_2, x_22);
-x_25 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_22 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_20);
+x_23 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_17);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_12, x_9);
+lean_dec(x_9);
+return x_25;
 }
 else
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_23);
-lean_dec(x_2);
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_28 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_18);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_13, x_10);
-lean_dec(x_10);
-return x_30;
+x_26 = l_Lean_Parser_Command_optDeclSig___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_17);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_12, x_9);
+lean_dec(x_9);
+return x_28;
 }
 }
 }
@@ -6588,7 +6420,7 @@ lean_object* _init_l_Lean_Parser_Command_optDeclSig___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_optDeclSig___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_optDeclSig___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6643,150 +6475,149 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_declValSimple___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_declValSimple___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_declValSimple___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_declValSimple___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_declValSimple___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_declValSimple___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_declValSimple___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_declValSimple___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_declValSimple___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Command_declValSimple___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Command_declValSimple___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Command_declValSimple___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Command_declValSimple___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -6819,7 +6650,7 @@ lean_object* _init_l_Lean_Parser_Command_declValSimple___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declValSimple___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declValSimple___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6874,81 +6705,77 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_declValEqns___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_declValEqns___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_declValEqns___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_declValEqns___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_declValEqns___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_declValEqns___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_declValEqns___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_letEqnsDecl___elambda__1___closed__1;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_declValEqns___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_Term_letEqnsDecl___elambda__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Command_declValEqns___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-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_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
+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_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = lean_apply_2(x_4, x_1, x_15);
+x_19 = l_Lean_Parser_Command_declValEqns___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_17);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_12, x_9);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = l_Lean_Parser_Command_declValEqns___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_18);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_13, x_10);
-lean_dec(x_10);
-return x_22;
+return x_21;
 }
 }
 }
@@ -6981,7 +6808,7 @@ lean_object* _init_l_Lean_Parser_Command_declValEqns___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declValEqns___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declValEqns___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7005,58 +6832,55 @@ x_1 = l_Lean_Parser_Command_declValEqns___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_declVal___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_declVal___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
-lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-lean_inc(x_2);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
 lean_inc(x_1);
-x_7 = l_Lean_Parser_Command_declValSimple___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+x_6 = l_Lean_Parser_Command_declValSimple___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_7;
-}
-else
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_7, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_10, x_6);
-lean_dec(x_10);
-if (x_11 == 0)
-{
+x_10 = lean_nat_dec_eq(x_9, x_5);
 lean_dec(x_9);
-lean_dec(x_6);
+if (x_10 == 0)
+{
+lean_dec(x_8);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-lean_inc(x_6);
-x_12 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = l_Lean_Parser_Command_declValEqns___elambda__1(x_1, x_11);
+x_13 = l_Lean_Parser_mergeOrElseErrors(x_12, x_8, x_5);
 lean_dec(x_5);
-x_13 = l_Lean_Parser_Command_declValEqns___elambda__1(x_1, x_2, x_12);
-x_14 = l_Lean_Parser_mergeOrElseErrors(x_13, x_9, x_6);
-lean_dec(x_6);
-return x_14;
+return x_13;
 }
 }
 }
@@ -7079,7 +6903,7 @@ lean_object* _init_l_Lean_Parser_Command_declVal___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declVal___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declVal___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7134,13 +6958,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_abbrev___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_abbrev___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_abbrev___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_abbrev___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_abbrev___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_abbrev___elambda__1___closed__5() {
@@ -7192,185 +7015,177 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_abbrev___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_abbrev___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_abbrev___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_abbrev___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_37; lean_object* x_38; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_37 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_38 = lean_ctor_get(x_37, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_36; lean_object* x_37; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_36 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_37 = lean_ctor_get(x_36, 3);
+lean_inc(x_37);
+if (lean_obj_tag(x_37) == 0)
+{
+lean_object* x_38; lean_object* x_39; 
+x_38 = lean_ctor_get(x_36, 0);
 lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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_Command_abbrev___elambda__1___closed__6;
-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_Command_abbrev___elambda__1___closed__9;
-lean_inc(x_8);
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_8);
-x_17 = x_45;
-goto block_36;
-}
-else
-{
-x_17 = x_37;
-goto block_36;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l_Lean_Parser_Command_abbrev___elambda__1___closed__9;
-lean_inc(x_8);
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_8);
-x_17 = x_47;
-goto block_36;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
+x_39 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_38);
 lean_dec(x_38);
-x_48 = l_Lean_Parser_Command_abbrev___elambda__1___closed__9;
-lean_inc(x_8);
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_8);
-x_17 = x_49;
-goto block_36;
+if (lean_obj_tag(x_39) == 2)
+{
+lean_object* x_40; lean_object* x_41; uint8_t x_42; 
+x_40 = lean_ctor_get(x_39, 1);
+lean_inc(x_40);
+lean_dec(x_39);
+x_41 = l_Lean_Parser_Command_abbrev___elambda__1___closed__6;
+x_42 = lean_string_dec_eq(x_40, x_41);
+lean_dec(x_40);
+if (x_42 == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = l_Lean_Parser_Command_abbrev___elambda__1___closed__9;
+lean_inc(x_7);
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_43, x_7);
+x_16 = x_44;
+goto block_35;
 }
-block_36:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_36;
+goto block_35;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_45; lean_object* x_46; 
+lean_dec(x_39);
+x_45 = l_Lean_Parser_Command_abbrev___elambda__1___closed__9;
+lean_inc(x_7);
+x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_45, x_7);
+x_16 = x_46;
+goto block_35;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; 
+lean_dec(x_37);
+x_47 = l_Lean_Parser_Command_abbrev___elambda__1___closed__9;
+lean_inc(x_7);
+x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_47, x_7);
+x_16 = x_48;
+goto block_35;
+}
+block_35:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_18 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; 
-lean_inc(x_2);
+lean_object* x_20; lean_object* x_21; 
 lean_inc(x_1);
-x_21 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_19);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
+x_20 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_18);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_23 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_2, x_21);
-x_24 = l_Lean_Parser_Command_abbrev___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_22 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_20);
+x_23 = l_Lean_Parser_Command_abbrev___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_22);
-lean_dec(x_2);
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_27 = l_Lean_Parser_Command_abbrev___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_21, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+x_26 = l_Lean_Parser_Command_abbrev___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 else
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_30 = l_Lean_Parser_Command_abbrev___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
+x_29 = l_Lean_Parser_Command_abbrev___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_18, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
 }
 }
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_33 = l_Lean_Parser_Command_abbrev___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_17, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
+x_32 = l_Lean_Parser_Command_abbrev___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_16, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
 }
 }
 }
@@ -7449,7 +7264,7 @@ lean_object* _init_l_Lean_Parser_Command_abbrev___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_abbrev___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_abbrev___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7504,13 +7319,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_def___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_def___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_def___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_def___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_def___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_def___elambda__1___closed__5() {
@@ -7562,185 +7376,177 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_def___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_def___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_def___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_def___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_37; lean_object* x_38; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_37 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_38 = lean_ctor_get(x_37, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_36; lean_object* x_37; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_36 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_37 = lean_ctor_get(x_36, 3);
+lean_inc(x_37);
+if (lean_obj_tag(x_37) == 0)
+{
+lean_object* x_38; lean_object* x_39; 
+x_38 = lean_ctor_get(x_36, 0);
 lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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_Command_def___elambda__1___closed__6;
-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_Command_def___elambda__1___closed__9;
-lean_inc(x_8);
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_8);
-x_17 = x_45;
-goto block_36;
-}
-else
-{
-x_17 = x_37;
-goto block_36;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l_Lean_Parser_Command_def___elambda__1___closed__9;
-lean_inc(x_8);
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_8);
-x_17 = x_47;
-goto block_36;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
+x_39 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_38);
 lean_dec(x_38);
-x_48 = l_Lean_Parser_Command_def___elambda__1___closed__9;
-lean_inc(x_8);
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_8);
-x_17 = x_49;
-goto block_36;
+if (lean_obj_tag(x_39) == 2)
+{
+lean_object* x_40; lean_object* x_41; uint8_t x_42; 
+x_40 = lean_ctor_get(x_39, 1);
+lean_inc(x_40);
+lean_dec(x_39);
+x_41 = l_Lean_Parser_Command_def___elambda__1___closed__6;
+x_42 = lean_string_dec_eq(x_40, x_41);
+lean_dec(x_40);
+if (x_42 == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = l_Lean_Parser_Command_def___elambda__1___closed__9;
+lean_inc(x_7);
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_43, x_7);
+x_16 = x_44;
+goto block_35;
 }
-block_36:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_36;
+goto block_35;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_45; lean_object* x_46; 
+lean_dec(x_39);
+x_45 = l_Lean_Parser_Command_def___elambda__1___closed__9;
+lean_inc(x_7);
+x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_45, x_7);
+x_16 = x_46;
+goto block_35;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; 
+lean_dec(x_37);
+x_47 = l_Lean_Parser_Command_def___elambda__1___closed__9;
+lean_inc(x_7);
+x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_47, x_7);
+x_16 = x_48;
+goto block_35;
+}
+block_35:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_18 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; 
-lean_inc(x_2);
+lean_object* x_20; lean_object* x_21; 
 lean_inc(x_1);
-x_21 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_19);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
+x_20 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_18);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_23 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_2, x_21);
-x_24 = l_Lean_Parser_Command_def___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_22 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_20);
+x_23 = l_Lean_Parser_Command_def___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_22);
-lean_dec(x_2);
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_27 = l_Lean_Parser_Command_def___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_21, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+x_26 = l_Lean_Parser_Command_def___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 else
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_30 = l_Lean_Parser_Command_def___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
+x_29 = l_Lean_Parser_Command_def___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_18, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
 }
 }
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_33 = l_Lean_Parser_Command_def___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_17, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
+x_32 = l_Lean_Parser_Command_def___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_16, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
 }
 }
 }
@@ -7793,7 +7599,7 @@ lean_object* _init_l_Lean_Parser_Command_def___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_def___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_def___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7848,13 +7654,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_theorem___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_theorem___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_theorem___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_theorem___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_theorem___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_theorem___elambda__1___closed__5() {
@@ -7906,185 +7711,177 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_theorem___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_theorem___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_theorem___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_theorem___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_37; lean_object* x_38; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_37 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_38 = lean_ctor_get(x_37, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_36; lean_object* x_37; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_36 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_37 = lean_ctor_get(x_36, 3);
+lean_inc(x_37);
+if (lean_obj_tag(x_37) == 0)
+{
+lean_object* x_38; lean_object* x_39; 
+x_38 = lean_ctor_get(x_36, 0);
 lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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_Command_theorem___elambda__1___closed__6;
-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_Command_theorem___elambda__1___closed__9;
-lean_inc(x_8);
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_8);
-x_17 = x_45;
-goto block_36;
-}
-else
-{
-x_17 = x_37;
-goto block_36;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l_Lean_Parser_Command_theorem___elambda__1___closed__9;
-lean_inc(x_8);
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_8);
-x_17 = x_47;
-goto block_36;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
+x_39 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_38);
 lean_dec(x_38);
-x_48 = l_Lean_Parser_Command_theorem___elambda__1___closed__9;
-lean_inc(x_8);
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_8);
-x_17 = x_49;
-goto block_36;
+if (lean_obj_tag(x_39) == 2)
+{
+lean_object* x_40; lean_object* x_41; uint8_t x_42; 
+x_40 = lean_ctor_get(x_39, 1);
+lean_inc(x_40);
+lean_dec(x_39);
+x_41 = l_Lean_Parser_Command_theorem___elambda__1___closed__6;
+x_42 = lean_string_dec_eq(x_40, x_41);
+lean_dec(x_40);
+if (x_42 == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = l_Lean_Parser_Command_theorem___elambda__1___closed__9;
+lean_inc(x_7);
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_43, x_7);
+x_16 = x_44;
+goto block_35;
 }
-block_36:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_36;
+goto block_35;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_45; lean_object* x_46; 
+lean_dec(x_39);
+x_45 = l_Lean_Parser_Command_theorem___elambda__1___closed__9;
+lean_inc(x_7);
+x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_45, x_7);
+x_16 = x_46;
+goto block_35;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; 
+lean_dec(x_37);
+x_47 = l_Lean_Parser_Command_theorem___elambda__1___closed__9;
+lean_inc(x_7);
+x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_47, x_7);
+x_16 = x_48;
+goto block_35;
+}
+block_35:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_18 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; 
-lean_inc(x_2);
+lean_object* x_20; lean_object* x_21; 
 lean_inc(x_1);
-x_21 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_2, x_19);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
+x_20 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_18);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_23 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_2, x_21);
-x_24 = l_Lean_Parser_Command_theorem___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_22 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_20);
+x_23 = l_Lean_Parser_Command_theorem___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_22);
-lean_dec(x_2);
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_27 = l_Lean_Parser_Command_theorem___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_21, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+x_26 = l_Lean_Parser_Command_theorem___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 else
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_30 = l_Lean_Parser_Command_theorem___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
+x_29 = l_Lean_Parser_Command_theorem___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_18, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
 }
 }
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_33 = l_Lean_Parser_Command_theorem___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_17, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
+x_32 = l_Lean_Parser_Command_theorem___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_16, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
 }
 }
 }
@@ -8163,7 +7960,7 @@ lean_object* _init_l_Lean_Parser_Command_theorem___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_theorem___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_theorem___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -8218,13 +8015,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_constant___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_constant___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_constant___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_constant___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_constant___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_constant___elambda__1___closed__5() {
@@ -8276,233 +8072,225 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_constant___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_constant___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_constant___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_constant___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_56; lean_object* x_57; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_57 = lean_ctor_get(x_56, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_55; lean_object* x_56; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_55 = l_Lean_Parser_tokenFn(x_1, x_13);
+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);
-if (lean_obj_tag(x_57) == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-x_58 = lean_ctor_get(x_56, 0);
-lean_inc(x_58);
-x_59 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_58);
-lean_dec(x_58);
-if (lean_obj_tag(x_59) == 2)
-{
-lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_60 = lean_ctor_get(x_59, 1);
-lean_inc(x_60);
-lean_dec(x_59);
-x_61 = l_Lean_Parser_Command_constant___elambda__1___closed__6;
-x_62 = lean_string_dec_eq(x_60, x_61);
-lean_dec(x_60);
-if (x_62 == 0)
-{
-lean_object* x_63; lean_object* x_64; 
-x_63 = l_Lean_Parser_Command_constant___elambda__1___closed__9;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_8);
-x_17 = x_64;
-goto block_55;
-}
-else
-{
-x_17 = x_56;
-goto block_55;
-}
-}
-else
-{
-lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
-x_65 = l_Lean_Parser_Command_constant___elambda__1___closed__9;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_8);
-x_17 = x_66;
-goto block_55;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; 
+x_58 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_57);
 lean_dec(x_57);
-x_67 = l_Lean_Parser_Command_constant___elambda__1___closed__9;
-lean_inc(x_8);
-x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_8);
-x_17 = x_68;
-goto block_55;
+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);
+lean_inc(x_59);
+lean_dec(x_58);
+x_60 = l_Lean_Parser_Command_constant___elambda__1___closed__6;
+x_61 = lean_string_dec_eq(x_59, x_60);
+lean_dec(x_59);
+if (x_61 == 0)
+{
+lean_object* x_62; lean_object* x_63; 
+x_62 = l_Lean_Parser_Command_constant___elambda__1___closed__9;
+lean_inc(x_7);
+x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_7);
+x_16 = x_63;
+goto block_54;
 }
-block_55:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_55;
+goto block_54;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_64; lean_object* x_65; 
+lean_dec(x_58);
+x_64 = l_Lean_Parser_Command_constant___elambda__1___closed__9;
+lean_inc(x_7);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_7);
+x_16 = x_65;
+goto block_54;
+}
+}
+else
+{
+lean_object* x_66; lean_object* x_67; 
+lean_dec(x_56);
+x_66 = l_Lean_Parser_Command_constant___elambda__1___closed__9;
+lean_inc(x_7);
+x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_7);
+x_16 = x_67;
+goto block_54;
+}
+block_54:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_18 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; 
-lean_inc(x_2);
+lean_object* x_20; lean_object* x_21; 
 lean_inc(x_1);
-x_21 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_2, x_19);
-x_22 = lean_ctor_get(x_21, 3);
+x_20 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_18);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+x_22 = lean_ctor_get(x_20, 0);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_23 = lean_ctor_get(x_21, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
-lean_dec(x_23);
-x_25 = lean_ctor_get(x_21, 1);
-lean_inc(x_25);
-x_26 = l_Lean_Parser_Command_declValSimple___elambda__1(x_1, x_2, x_21);
-x_27 = lean_ctor_get(x_26, 3);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_25);
-x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_26, x_28, x_24);
-x_30 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
-}
-else
-{
-lean_object* x_33; uint8_t x_34; 
-lean_dec(x_27);
-x_33 = lean_ctor_get(x_26, 1);
-lean_inc(x_33);
-x_34 = lean_nat_dec_eq(x_33, x_25);
-lean_dec(x_33);
-if (x_34 == 0)
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_25);
-x_35 = l_Lean_nullKind;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_26, x_35, x_24);
-x_37 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_16);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_8);
-lean_dec(x_8);
-return x_39;
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_40 = l_Lean_Parser_ParserState_restore(x_26, x_24, x_25);
-x_41 = l_Lean_nullKind;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_24);
-x_43 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_16);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_11, x_8);
-lean_dec(x_8);
-return x_45;
-}
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+x_23 = lean_array_get_size(x_22);
 lean_dec(x_22);
-lean_dec(x_2);
-lean_dec(x_1);
-x_46 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_21, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
+x_24 = lean_ctor_get(x_20, 1);
+lean_inc(x_24);
+x_25 = l_Lean_Parser_Command_declValSimple___elambda__1(x_1, x_20);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_24);
+x_27 = l_Lean_nullKind;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_25, x_27, x_23);
+x_29 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
+}
+else
+{
+lean_object* x_32; uint8_t x_33; 
+lean_dec(x_26);
+x_32 = lean_ctor_get(x_25, 1);
+lean_inc(x_32);
+x_33 = lean_nat_dec_eq(x_32, x_24);
+lean_dec(x_32);
+if (x_33 == 0)
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_24);
+x_34 = l_Lean_nullKind;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_25, x_34, x_23);
+x_36 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
+}
+else
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_39 = l_Lean_Parser_ParserState_restore(x_25, x_23, x_24);
+x_40 = l_Lean_nullKind;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_23);
+x_42 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
+x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_15);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_10, x_7);
+lean_dec(x_7);
+return x_44;
+}
 }
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_49 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_19, x_49, x_16);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_11, x_8);
-lean_dec(x_8);
-return x_51;
+x_45 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
+x_46 = l_Lean_Parser_ParserState_mkNode(x_20, x_45, x_15);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_10, x_7);
+lean_dec(x_7);
+return x_47;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_52 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_17, x_52, x_16);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_8);
-lean_dec(x_8);
-return x_54;
+x_48 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
+x_49 = l_Lean_Parser_ParserState_mkNode(x_18, x_48, x_15);
+x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_10, x_7);
+lean_dec(x_7);
+return x_50;
+}
+}
+else
+{
+lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_51 = l_Lean_Parser_Command_constant___elambda__1___closed__2;
+x_52 = l_Lean_Parser_ParserState_mkNode(x_16, x_51, x_15);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_10, x_7);
+lean_dec(x_7);
+return x_53;
 }
 }
 }
@@ -8590,7 +8378,7 @@ lean_object* _init_l_Lean_Parser_Command_constant___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_constant___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_constant___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -8645,13 +8433,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_instance___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_instance___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_instance___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_instance___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_instance___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_instance___elambda__1___closed__5() {
@@ -8703,313 +8490,299 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_instance___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_instance___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_instance___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_instance___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_76; lean_object* x_77; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_76 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_77 = lean_ctor_get(x_76, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_75; lean_object* x_76; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_75 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_76 = lean_ctor_get(x_75, 3);
+lean_inc(x_76);
+if (lean_obj_tag(x_76) == 0)
+{
+lean_object* x_77; lean_object* x_78; 
+x_77 = lean_ctor_get(x_75, 0);
 lean_inc(x_77);
-if (lean_obj_tag(x_77) == 0)
-{
-lean_object* x_78; lean_object* x_79; 
-x_78 = lean_ctor_get(x_76, 0);
-lean_inc(x_78);
-x_79 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_78);
-lean_dec(x_78);
-if (lean_obj_tag(x_79) == 2)
-{
-lean_object* x_80; lean_object* x_81; uint8_t x_82; 
-x_80 = lean_ctor_get(x_79, 1);
-lean_inc(x_80);
-lean_dec(x_79);
-x_81 = l_Lean_Parser_Command_instance___elambda__1___closed__6;
-x_82 = lean_string_dec_eq(x_80, x_81);
-lean_dec(x_80);
-if (x_82 == 0)
-{
-lean_object* x_83; lean_object* x_84; 
-x_83 = l_Lean_Parser_Command_instance___elambda__1___closed__9;
-lean_inc(x_8);
-x_84 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_83, x_8);
-x_17 = x_84;
-goto block_75;
-}
-else
-{
-x_17 = x_76;
-goto block_75;
-}
-}
-else
-{
-lean_object* x_85; lean_object* x_86; 
-lean_dec(x_79);
-x_85 = l_Lean_Parser_Command_instance___elambda__1___closed__9;
-lean_inc(x_8);
-x_86 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_85, x_8);
-x_17 = x_86;
-goto block_75;
-}
-}
-else
-{
-lean_object* x_87; lean_object* x_88; 
+x_78 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_77);
 lean_dec(x_77);
-x_87 = l_Lean_Parser_Command_instance___elambda__1___closed__9;
-lean_inc(x_8);
-x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_87, x_8);
-x_17 = x_88;
-goto block_75;
-}
-block_75:
+if (lean_obj_tag(x_78) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_79; lean_object* x_80; uint8_t x_81; 
+x_79 = lean_ctor_get(x_78, 1);
+lean_inc(x_79);
+lean_dec(x_78);
+x_80 = l_Lean_Parser_Command_instance___elambda__1___closed__6;
+x_81 = lean_string_dec_eq(x_79, x_80);
+lean_dec(x_79);
+if (x_81 == 0)
+{
+lean_object* x_82; lean_object* x_83; 
+x_82 = l_Lean_Parser_Command_instance___elambda__1___closed__9;
+lean_inc(x_7);
+x_83 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_82, x_7);
+x_16 = x_83;
+goto block_74;
+}
+else
+{
+x_16 = x_75;
+goto block_74;
+}
+}
+else
+{
+lean_object* x_84; lean_object* x_85; 
+lean_dec(x_78);
+x_84 = l_Lean_Parser_Command_instance___elambda__1___closed__9;
+lean_inc(x_7);
+x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_84, x_7);
+x_16 = x_85;
+goto block_74;
+}
+}
+else
+{
+lean_object* x_86; lean_object* x_87; 
+lean_dec(x_76);
+x_86 = l_Lean_Parser_Command_instance___elambda__1___closed__9;
+lean_inc(x_7);
+x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_86, x_7);
+x_16 = x_87;
+goto block_74;
+}
+block_74:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-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);
-lean_inc(x_2);
-lean_inc(x_1);
-x_22 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_2, x_17);
-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_nullKind;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_22, x_24, x_20);
-x_26 = lean_ctor_get(x_25, 3);
-lean_inc(x_26);
-if (lean_obj_tag(x_26) == 0)
-{
-lean_object* x_27; lean_object* x_28; 
-lean_inc(x_2);
-lean_inc(x_1);
-x_27 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_2, x_25);
-x_28 = lean_ctor_get(x_27, 3);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_29 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_2, x_27);
-x_30 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_28);
-lean_dec(x_2);
-lean_dec(x_1);
-x_33 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_26);
-lean_dec(x_2);
-lean_dec(x_1);
-x_36 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_25, x_36, x_16);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_8);
-lean_dec(x_8);
-return x_38;
-}
-}
-else
-{
-lean_object* x_39; uint8_t x_40; 
-lean_dec(x_23);
-x_39 = lean_ctor_get(x_22, 1);
-lean_inc(x_39);
-x_40 = lean_nat_dec_eq(x_39, x_21);
-lean_dec(x_39);
-if (x_40 == 0)
-{
-lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_21);
-x_41 = l_Lean_nullKind;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_22, x_41, x_20);
-x_43 = lean_ctor_get(x_42, 3);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; lean_object* x_45; 
-lean_inc(x_2);
-lean_inc(x_1);
-x_44 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_2, x_42);
-x_45 = lean_ctor_get(x_44, 3);
-lean_inc(x_45);
-if (lean_obj_tag(x_45) == 0)
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_46 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_2, x_44);
-x_47 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_16);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_11, x_8);
-lean_dec(x_8);
-return x_49;
-}
-else
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_45);
-lean_dec(x_2);
-lean_dec(x_1);
-x_50 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_44, x_50, x_16);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_11, x_8);
-lean_dec(x_8);
-return x_52;
-}
-}
-else
-{
-lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-lean_dec(x_43);
-lean_dec(x_2);
-lean_dec(x_1);
-x_53 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_54 = l_Lean_Parser_ParserState_mkNode(x_42, x_53, x_16);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_11, x_8);
-lean_dec(x_8);
-return x_55;
-}
-}
-else
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_56 = l_Lean_Parser_ParserState_restore(x_22, x_20, x_21);
-x_57 = l_Lean_nullKind;
-x_58 = l_Lean_Parser_ParserState_mkNode(x_56, x_57, x_20);
-x_59 = lean_ctor_get(x_58, 3);
-lean_inc(x_59);
-if (lean_obj_tag(x_59) == 0)
-{
-lean_object* x_60; lean_object* x_61; 
-lean_inc(x_2);
-lean_inc(x_1);
-x_60 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_2, x_58);
-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; lean_object* x_64; lean_object* x_65; 
-x_62 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_2, x_60);
-x_63 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_16);
-x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_11, x_8);
-lean_dec(x_8);
-return x_65;
-}
-else
-{
-lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-lean_dec(x_61);
-lean_dec(x_2);
-lean_dec(x_1);
-x_66 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_67 = l_Lean_Parser_ParserState_mkNode(x_60, x_66, x_16);
-x_68 = l_Lean_Parser_mergeOrElseErrors(x_67, x_11, x_8);
-lean_dec(x_8);
-return x_68;
-}
-}
-else
-{
-lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-lean_dec(x_59);
-lean_dec(x_2);
-lean_dec(x_1);
-x_69 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_70 = l_Lean_Parser_ParserState_mkNode(x_58, x_69, x_16);
-x_71 = l_Lean_Parser_mergeOrElseErrors(x_70, x_11, x_8);
-lean_dec(x_8);
-return x_71;
-}
-}
-}
-}
-else
-{
-lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+x_19 = lean_array_get_size(x_18);
 lean_dec(x_18);
-lean_dec(x_2);
+x_20 = lean_ctor_get(x_16, 1);
+lean_inc(x_20);
+lean_inc(x_1);
+x_21 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_16);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_20);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_19);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_object* x_26; lean_object* x_27; 
+lean_inc(x_1);
+x_26 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_24);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+x_28 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_26);
+x_29 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
+}
+else
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_27);
 lean_dec(x_1);
-x_72 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
-x_73 = l_Lean_Parser_ParserState_mkNode(x_17, x_72, x_16);
-x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_11, x_8);
-lean_dec(x_8);
-return x_74;
+x_32 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_26, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_25);
+lean_dec(x_1);
+x_35 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_24, x_35, x_15);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_10, x_7);
+lean_dec(x_7);
+return x_37;
+}
+}
+else
+{
+lean_object* x_38; uint8_t x_39; 
+lean_dec(x_22);
+x_38 = lean_ctor_get(x_21, 1);
+lean_inc(x_38);
+x_39 = lean_nat_dec_eq(x_38, x_20);
+lean_dec(x_38);
+if (x_39 == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+lean_dec(x_20);
+x_40 = l_Lean_nullKind;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_21, x_40, x_19);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+lean_inc(x_1);
+x_43 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_41);
+x_44 = lean_ctor_get(x_43, 3);
+lean_inc(x_44);
+if (lean_obj_tag(x_44) == 0)
+{
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+x_45 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_43);
+x_46 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_15);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_7);
+lean_dec(x_7);
+return x_48;
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+lean_dec(x_1);
+x_49 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_43, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
+return x_51;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+lean_dec(x_42);
+lean_dec(x_1);
+x_52 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_41, x_52, x_15);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_10, x_7);
+lean_dec(x_7);
+return x_54;
+}
+}
+else
+{
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_55 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+x_56 = l_Lean_nullKind;
+x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_19);
+x_58 = lean_ctor_get(x_57, 3);
+lean_inc(x_58);
+if (lean_obj_tag(x_58) == 0)
+{
+lean_object* x_59; lean_object* x_60; 
+lean_inc(x_1);
+x_59 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_57);
+x_60 = lean_ctor_get(x_59, 3);
+lean_inc(x_60);
+if (lean_obj_tag(x_60) == 0)
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+x_61 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_59);
+x_62 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_63 = l_Lean_Parser_ParserState_mkNode(x_61, x_62, x_15);
+x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_10, x_7);
+lean_dec(x_7);
+return x_64;
+}
+else
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+lean_dec(x_60);
+lean_dec(x_1);
+x_65 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_66 = l_Lean_Parser_ParserState_mkNode(x_59, x_65, x_15);
+x_67 = l_Lean_Parser_mergeOrElseErrors(x_66, x_10, x_7);
+lean_dec(x_7);
+return x_67;
+}
+}
+else
+{
+lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+lean_dec(x_58);
+lean_dec(x_1);
+x_68 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_69 = l_Lean_Parser_ParserState_mkNode(x_57, x_68, x_15);
+x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_10, x_7);
+lean_dec(x_7);
+return x_70;
+}
+}
+}
+}
+else
+{
+lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_71 = l_Lean_Parser_Command_instance___elambda__1___closed__2;
+x_72 = l_Lean_Parser_ParserState_mkNode(x_16, x_71, x_15);
+x_73 = l_Lean_Parser_mergeOrElseErrors(x_72, x_10, x_7);
+lean_dec(x_7);
+return x_73;
 }
 }
 }
@@ -9083,7 +8856,7 @@ lean_object* _init_l_Lean_Parser_Command_instance___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_instance___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_instance___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -9138,13 +8911,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_axiom___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_axiom___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_axiom___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_axiom___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_axiom___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_axiom___elambda__1___closed__5() {
@@ -9196,164 +8968,158 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_axiom___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_axiom___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_axiom___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_axiom___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_32; lean_object* x_33; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_32 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_33 = lean_ctor_get(x_32, 3);
-lean_inc(x_33);
-if (lean_obj_tag(x_33) == 0)
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = lean_ctor_get(x_32, 0);
-lean_inc(x_34);
-x_35 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_34);
-lean_dec(x_34);
-if (lean_obj_tag(x_35) == 2)
-{
-lean_object* x_36; lean_object* x_37; uint8_t x_38; 
-x_36 = lean_ctor_get(x_35, 1);
-lean_inc(x_36);
-lean_dec(x_35);
-x_37 = l_Lean_Parser_Command_axiom___elambda__1___closed__6;
-x_38 = lean_string_dec_eq(x_36, x_37);
-lean_dec(x_36);
-if (x_38 == 0)
-{
-lean_object* x_39; lean_object* x_40; 
-x_39 = l_Lean_Parser_Command_axiom___elambda__1___closed__9;
-lean_inc(x_8);
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_39, x_8);
-x_17 = x_40;
-goto block_31;
-}
-else
-{
-x_17 = x_32;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_41; lean_object* x_42; 
-lean_dec(x_35);
-x_41 = l_Lean_Parser_Command_axiom___elambda__1___closed__9;
-lean_inc(x_8);
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_41, x_8);
-x_17 = x_42;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; 
-lean_dec(x_33);
-x_43 = l_Lean_Parser_Command_axiom___elambda__1___closed__9;
-lean_inc(x_8);
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_43, x_8);
-x_17 = x_44;
-goto block_31;
-}
-block_31:
-{
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_31; lean_object* x_32; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_31 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_32 = lean_ctor_get(x_31, 3);
+lean_inc(x_32);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_axiom___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_33; lean_object* x_34; 
+x_33 = lean_ctor_get(x_31, 0);
+lean_inc(x_33);
+x_34 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_33);
+lean_dec(x_33);
+if (lean_obj_tag(x_34) == 2)
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = lean_ctor_get(x_34, 1);
+lean_inc(x_35);
+lean_dec(x_34);
+x_36 = l_Lean_Parser_Command_axiom___elambda__1___closed__6;
+x_37 = lean_string_dec_eq(x_35, x_36);
+lean_dec(x_35);
+if (x_37 == 0)
+{
+lean_object* x_38; lean_object* x_39; 
+x_38 = l_Lean_Parser_Command_axiom___elambda__1___closed__9;
+lean_inc(x_7);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_7);
+x_16 = x_39;
+goto block_30;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_axiom___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_31;
+goto block_30;
 }
 }
 else
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_34);
+x_40 = l_Lean_Parser_Command_axiom___elambda__1___closed__9;
+lean_inc(x_7);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_7);
+x_16 = x_41;
+goto block_30;
+}
+}
+else
+{
+lean_object* x_42; lean_object* x_43; 
+lean_dec(x_32);
+x_42 = l_Lean_Parser_Command_axiom___elambda__1___closed__9;
+lean_inc(x_7);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_7);
+x_16 = x_43;
+goto block_30;
+}
+block_30:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_18);
+x_21 = l_Lean_Parser_Command_axiom___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_28 = l_Lean_Parser_Command_axiom___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_17, x_28, x_16);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_11, x_8);
-lean_dec(x_8);
-return x_30;
+x_24 = l_Lean_Parser_Command_axiom___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
+}
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_27 = l_Lean_Parser_Command_axiom___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_16, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
 }
 }
 }
@@ -9420,7 +9186,7 @@ lean_object* _init_l_Lean_Parser_Command_axiom___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_axiom___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_axiom___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -9475,13 +9241,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_example___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_example___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_example___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_example___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_example___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_example___elambda__1___closed__5() {
@@ -9533,164 +9298,158 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_example___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_example___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_example___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_example___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_32; lean_object* x_33; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_32 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_33 = lean_ctor_get(x_32, 3);
-lean_inc(x_33);
-if (lean_obj_tag(x_33) == 0)
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = lean_ctor_get(x_32, 0);
-lean_inc(x_34);
-x_35 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_34);
-lean_dec(x_34);
-if (lean_obj_tag(x_35) == 2)
-{
-lean_object* x_36; lean_object* x_37; uint8_t x_38; 
-x_36 = lean_ctor_get(x_35, 1);
-lean_inc(x_36);
-lean_dec(x_35);
-x_37 = l_Lean_Parser_Command_example___elambda__1___closed__6;
-x_38 = lean_string_dec_eq(x_36, x_37);
-lean_dec(x_36);
-if (x_38 == 0)
-{
-lean_object* x_39; lean_object* x_40; 
-x_39 = l_Lean_Parser_Command_example___elambda__1___closed__9;
-lean_inc(x_8);
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_39, x_8);
-x_17 = x_40;
-goto block_31;
-}
-else
-{
-x_17 = x_32;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_41; lean_object* x_42; 
-lean_dec(x_35);
-x_41 = l_Lean_Parser_Command_example___elambda__1___closed__9;
-lean_inc(x_8);
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_41, x_8);
-x_17 = x_42;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; 
-lean_dec(x_33);
-x_43 = l_Lean_Parser_Command_example___elambda__1___closed__9;
-lean_inc(x_8);
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_43, x_8);
-x_17 = x_44;
-goto block_31;
-}
-block_31:
-{
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_31; lean_object* x_32; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_31 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_32 = lean_ctor_get(x_31, 3);
+lean_inc(x_32);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_example___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_33; lean_object* x_34; 
+x_33 = lean_ctor_get(x_31, 0);
+lean_inc(x_33);
+x_34 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_33);
+lean_dec(x_33);
+if (lean_obj_tag(x_34) == 2)
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = lean_ctor_get(x_34, 1);
+lean_inc(x_35);
+lean_dec(x_34);
+x_36 = l_Lean_Parser_Command_example___elambda__1___closed__6;
+x_37 = lean_string_dec_eq(x_35, x_36);
+lean_dec(x_35);
+if (x_37 == 0)
+{
+lean_object* x_38; lean_object* x_39; 
+x_38 = l_Lean_Parser_Command_example___elambda__1___closed__9;
+lean_inc(x_7);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_7);
+x_16 = x_39;
+goto block_30;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_example___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_31;
+goto block_30;
 }
 }
 else
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_34);
+x_40 = l_Lean_Parser_Command_example___elambda__1___closed__9;
+lean_inc(x_7);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_7);
+x_16 = x_41;
+goto block_30;
+}
+}
+else
+{
+lean_object* x_42; lean_object* x_43; 
+lean_dec(x_32);
+x_42 = l_Lean_Parser_Command_example___elambda__1___closed__9;
+lean_inc(x_7);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_7);
+x_16 = x_43;
+goto block_30;
+}
+block_30:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Command_declSig___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = l_Lean_Parser_Command_declVal___elambda__1(x_1, x_18);
+x_21 = l_Lean_Parser_Command_example___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_28 = l_Lean_Parser_Command_example___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_17, x_28, x_16);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_11, x_8);
-lean_dec(x_8);
-return x_30;
+x_24 = l_Lean_Parser_Command_example___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
+}
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_27 = l_Lean_Parser_Command_example___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_16, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
 }
 }
 }
@@ -9743,7 +9502,7 @@ lean_object* _init_l_Lean_Parser_Command_example___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_example___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_example___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -9798,289 +9557,288 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_relaxedInferMod___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_relaxedInferMod___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; 
-x_4 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
+x_6 = lean_ctor_get(x_2, 1);
 lean_inc(x_6);
-x_7 = lean_ctor_get(x_3, 1);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_6);
+x_7 = lean_array_get_size(x_5);
+lean_dec(x_5);
+lean_inc(x_2);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+if (lean_is_exclusive(x_2)) {
+ lean_ctor_release(x_2, 0);
+ lean_ctor_release(x_2, 1);
+ lean_ctor_release(x_2, 2);
+ lean_ctor_release(x_2, 3);
+ x_9 = x_2;
+} else {
+ lean_dec_ref(x_2);
+ x_9 = lean_box(0);
+}
+x_10 = lean_ctor_get(x_8, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_dec(x_9);
+lean_dec(x_7);
 lean_dec(x_6);
-lean_inc(x_3);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-if (lean_is_exclusive(x_3)) {
- lean_ctor_release(x_3, 0);
- lean_ctor_release(x_3, 1);
- lean_ctor_release(x_3, 2);
- lean_ctor_release(x_3, 3);
- x_10 = x_3;
-} else {
- lean_dec_ref(x_3);
- x_10 = lean_box(0);
+lean_dec(x_1);
+return x_8;
 }
-x_11 = lean_ctor_get(x_9, 3);
+else
+{
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
 lean_dec(x_10);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_12; lean_object* x_13; uint8_t x_14; 
-x_12 = lean_ctor_get(x_11, 0);
+x_12 = lean_ctor_get(x_8, 1);
 lean_inc(x_12);
-lean_dec(x_11);
-x_13 = lean_ctor_get(x_9, 1);
-lean_inc(x_13);
-x_14 = lean_nat_dec_eq(x_13, x_7);
-lean_dec(x_13);
-if (x_14 == 0)
-{
+x_13 = lean_nat_dec_eq(x_12, x_6);
 lean_dec(x_12);
-lean_dec(x_10);
-lean_dec(x_8);
+if (x_13 == 0)
+{
+lean_dec(x_11);
+lean_dec(x_9);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_31; lean_object* x_63; lean_object* x_64; 
-lean_inc(x_7);
-x_15 = l_Lean_Parser_ParserState_restore(x_9, x_8, x_7);
-lean_dec(x_8);
-x_16 = lean_ctor_get(x_15, 0);
-lean_inc(x_16);
-x_17 = lean_array_get_size(x_16);
-lean_dec(x_16);
-lean_inc(x_2);
-x_63 = l_Lean_Parser_tokenFn(x_2, x_15);
-x_64 = lean_ctor_get(x_63, 3);
+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_30; lean_object* x_62; lean_object* x_63; 
+lean_inc(x_6);
+x_14 = l_Lean_Parser_ParserState_restore(x_8, x_7, x_6);
+lean_dec(x_7);
+x_15 = lean_ctor_get(x_14, 0);
+lean_inc(x_15);
+x_16 = lean_array_get_size(x_15);
+lean_dec(x_15);
+lean_inc(x_1);
+x_62 = l_Lean_Parser_tokenFn(x_1, x_14);
+x_63 = lean_ctor_get(x_62, 3);
+lean_inc(x_63);
+if (lean_obj_tag(x_63) == 0)
+{
+lean_object* x_64; lean_object* x_65; 
+x_64 = lean_ctor_get(x_62, 0);
 lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
-{
-lean_object* x_65; lean_object* x_66; 
-x_65 = lean_ctor_get(x_63, 0);
-lean_inc(x_65);
-x_66 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_65);
-lean_dec(x_65);
-if (lean_obj_tag(x_66) == 2)
-{
-lean_object* x_67; lean_object* x_68; uint8_t x_69; 
-x_67 = lean_ctor_get(x_66, 1);
-lean_inc(x_67);
-lean_dec(x_66);
-x_68 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
-x_69 = lean_string_dec_eq(x_67, x_68);
-lean_dec(x_67);
-if (x_69 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_7);
-x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_63, x_70, x_7);
-x_31 = x_71;
-goto block_62;
-}
-else
-{
-x_31 = x_63;
-goto block_62;
-}
-}
-else
-{
-lean_object* x_72; lean_object* x_73; 
-lean_dec(x_66);
-x_72 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_7);
-x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_63, x_72, x_7);
-x_31 = x_73;
-goto block_62;
-}
-}
-else
-{
-lean_object* x_74; lean_object* x_75; 
+x_65 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_64);
 lean_dec(x_64);
-x_74 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_7);
-x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_63, x_74, x_7);
-x_31 = x_75;
-goto block_62;
-}
-block_30:
+if (lean_obj_tag(x_65) == 2)
 {
-if (lean_obj_tag(x_21) == 0)
+lean_object* x_66; lean_object* x_67; uint8_t x_68; 
+x_66 = lean_ctor_get(x_65, 1);
+lean_inc(x_66);
+lean_dec(x_65);
+x_67 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
+x_68 = lean_string_dec_eq(x_66, x_67);
+lean_dec(x_66);
+if (x_68 == 0)
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-lean_dec(x_20);
-lean_dec(x_19);
-lean_dec(x_10);
-x_22 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_18, x_22, x_17);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_12, x_7);
-lean_dec(x_7);
-return x_24;
+lean_object* x_69; lean_object* x_70; 
+x_69 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_6);
+x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_69, x_6);
+x_30 = x_70;
+goto block_61;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_30 = x_62;
+goto block_61;
+}
+}
+else
+{
+lean_object* x_71; lean_object* x_72; 
+lean_dec(x_65);
+x_71 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_6);
+x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_71, x_6);
+x_30 = x_72;
+goto block_61;
+}
+}
+else
+{
+lean_object* x_73; lean_object* x_74; 
+lean_dec(x_63);
+x_73 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_6);
+x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_73, x_6);
+x_30 = x_74;
+goto block_61;
+}
+block_29:
+{
+if (lean_obj_tag(x_20) == 0)
+{
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+lean_dec(x_19);
 lean_dec(x_18);
-x_25 = l_Array_shrink___main___rarg(x_19, x_17);
-lean_inc(x_7);
-if (lean_is_scalar(x_10)) {
- x_26 = lean_alloc_ctor(0, 4, 0);
+lean_dec(x_9);
+x_21 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_17, x_21, x_16);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_11, x_6);
+lean_dec(x_6);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_17);
+x_24 = l_Array_shrink___main___rarg(x_18, x_16);
+lean_inc(x_6);
+if (lean_is_scalar(x_9)) {
+ x_25 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_26 = x_10;
+ x_25 = x_9;
 }
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_7);
-lean_ctor_set(x_26, 2, x_20);
-lean_ctor_set(x_26, 3, x_21);
-x_27 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_17);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_12, x_7);
-lean_dec(x_7);
-return x_29;
+lean_ctor_set(x_25, 0, x_24);
+lean_ctor_set(x_25, 1, x_6);
+lean_ctor_set(x_25, 2, x_19);
+lean_ctor_set(x_25, 3, x_20);
+x_26 = l_Lean_Parser_Command_relaxedInferMod___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_6);
+lean_dec(x_6);
+return x_28;
 }
 }
-block_62:
+block_61:
 {
-lean_object* x_32; 
-x_32 = lean_ctor_get(x_31, 3);
+lean_object* x_31; 
+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; lean_object* x_34; 
+x_32 = lean_ctor_get(x_30, 1);
 lean_inc(x_32);
-if (lean_obj_tag(x_32) == 0)
+x_33 = l_Lean_Parser_tokenFn(x_1, x_30);
+x_34 = lean_ctor_get(x_33, 3);
+lean_inc(x_34);
+if (lean_obj_tag(x_34) == 0)
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_33 = lean_ctor_get(x_31, 1);
-lean_inc(x_33);
-x_34 = l_Lean_Parser_tokenFn(x_2, x_31);
-x_35 = lean_ctor_get(x_34, 3);
+lean_object* x_35; lean_object* x_36; 
+x_35 = lean_ctor_get(x_33, 0);
 lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
+x_36 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_35);
+lean_dec(x_35);
+if (lean_obj_tag(x_36) == 2)
 {
-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_Lean_Parser_checkLeadingFn___spec__1(x_36);
+lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_37 = lean_ctor_get(x_36, 1);
+lean_inc(x_37);
 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_inc(x_38);
+x_38 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
+x_39 = lean_string_dec_eq(x_37, x_38);
 lean_dec(x_37);
-x_39 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
-x_40 = lean_string_dec_eq(x_38, x_39);
-lean_dec(x_38);
-if (x_40 == 0)
+if (x_39 == 0)
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_41 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_41, x_33);
-x_43 = lean_ctor_get(x_42, 0);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_40 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_32);
+x_42 = lean_ctor_get(x_41, 0);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_41, 2);
 lean_inc(x_43);
-x_44 = lean_ctor_get(x_42, 2);
+x_44 = lean_ctor_get(x_41, 3);
 lean_inc(x_44);
-x_45 = lean_ctor_get(x_42, 3);
-lean_inc(x_45);
+x_17 = x_41;
 x_18 = x_42;
 x_19 = x_43;
 x_20 = x_44;
-x_21 = x_45;
-goto block_30;
+goto block_29;
 }
 else
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_33);
-x_46 = lean_ctor_get(x_34, 0);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_32);
+x_45 = lean_ctor_get(x_33, 0);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_33, 2);
 lean_inc(x_46);
-x_47 = lean_ctor_get(x_34, 2);
+x_47 = lean_ctor_get(x_33, 3);
 lean_inc(x_47);
-x_48 = lean_ctor_get(x_34, 3);
-lean_inc(x_48);
-x_18 = x_34;
+x_17 = x_33;
+x_18 = x_45;
 x_19 = x_46;
 x_20 = x_47;
-x_21 = x_48;
-goto block_30;
+goto block_29;
 }
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_dec(x_37);
-x_49 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_49, x_33);
-x_51 = lean_ctor_get(x_50, 0);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_36);
+x_48 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_48, x_32);
+x_50 = lean_ctor_get(x_49, 0);
+lean_inc(x_50);
+x_51 = lean_ctor_get(x_49, 2);
 lean_inc(x_51);
-x_52 = lean_ctor_get(x_50, 2);
+x_52 = lean_ctor_get(x_49, 3);
 lean_inc(x_52);
-x_53 = lean_ctor_get(x_50, 3);
-lean_inc(x_53);
+x_17 = x_49;
 x_18 = x_50;
 x_19 = x_51;
 x_20 = x_52;
-x_21 = x_53;
-goto block_30;
+goto block_29;
 }
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-lean_dec(x_35);
-x_54 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_54, x_33);
-x_56 = lean_ctor_get(x_55, 0);
+lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_dec(x_34);
+x_53 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_53, x_32);
+x_55 = lean_ctor_get(x_54, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_54, 2);
 lean_inc(x_56);
-x_57 = lean_ctor_get(x_55, 2);
+x_57 = lean_ctor_get(x_54, 3);
 lean_inc(x_57);
-x_58 = lean_ctor_get(x_55, 3);
-lean_inc(x_58);
+x_17 = x_54;
 x_18 = x_55;
 x_19 = x_56;
 x_20 = x_57;
-x_21 = x_58;
-goto block_30;
+goto block_29;
 }
 }
 else
 {
-lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_32);
-lean_dec(x_2);
-x_59 = lean_ctor_get(x_31, 0);
+lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+lean_dec(x_31);
+lean_dec(x_1);
+x_58 = lean_ctor_get(x_30, 0);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_30, 2);
 lean_inc(x_59);
-x_60 = lean_ctor_get(x_31, 2);
+x_60 = lean_ctor_get(x_30, 3);
 lean_inc(x_60);
-x_61 = lean_ctor_get(x_31, 3);
-lean_inc(x_61);
-x_18 = x_31;
+x_17 = x_30;
+x_18 = x_58;
 x_19 = x_59;
 x_20 = x_60;
-x_21 = x_61;
-goto block_30;
+goto block_29;
 }
 }
 }
@@ -10123,7 +9881,7 @@ lean_object* _init_l_Lean_Parser_Command_relaxedInferMod___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_relaxedInferMod___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_relaxedInferMod___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -10178,289 +9936,288 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_strictInferMod___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_strictInferMod___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_strictInferMod___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; 
-x_4 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
+x_6 = lean_ctor_get(x_2, 1);
 lean_inc(x_6);
-x_7 = lean_ctor_get(x_3, 1);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_6);
+x_7 = lean_array_get_size(x_5);
+lean_dec(x_5);
+lean_inc(x_2);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+if (lean_is_exclusive(x_2)) {
+ lean_ctor_release(x_2, 0);
+ lean_ctor_release(x_2, 1);
+ lean_ctor_release(x_2, 2);
+ lean_ctor_release(x_2, 3);
+ x_9 = x_2;
+} else {
+ lean_dec_ref(x_2);
+ x_9 = lean_box(0);
+}
+x_10 = lean_ctor_get(x_8, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_dec(x_9);
+lean_dec(x_7);
 lean_dec(x_6);
-lean_inc(x_3);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-if (lean_is_exclusive(x_3)) {
- lean_ctor_release(x_3, 0);
- lean_ctor_release(x_3, 1);
- lean_ctor_release(x_3, 2);
- lean_ctor_release(x_3, 3);
- x_10 = x_3;
-} else {
- lean_dec_ref(x_3);
- x_10 = lean_box(0);
+lean_dec(x_1);
+return x_8;
 }
-x_11 = lean_ctor_get(x_9, 3);
+else
+{
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
 lean_dec(x_10);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_12; lean_object* x_13; uint8_t x_14; 
-x_12 = lean_ctor_get(x_11, 0);
+x_12 = lean_ctor_get(x_8, 1);
 lean_inc(x_12);
-lean_dec(x_11);
-x_13 = lean_ctor_get(x_9, 1);
-lean_inc(x_13);
-x_14 = lean_nat_dec_eq(x_13, x_7);
-lean_dec(x_13);
-if (x_14 == 0)
-{
+x_13 = lean_nat_dec_eq(x_12, x_6);
 lean_dec(x_12);
-lean_dec(x_10);
-lean_dec(x_8);
+if (x_13 == 0)
+{
+lean_dec(x_11);
+lean_dec(x_9);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_31; lean_object* x_63; lean_object* x_64; 
-lean_inc(x_7);
-x_15 = l_Lean_Parser_ParserState_restore(x_9, x_8, x_7);
-lean_dec(x_8);
-x_16 = lean_ctor_get(x_15, 0);
-lean_inc(x_16);
-x_17 = lean_array_get_size(x_16);
-lean_dec(x_16);
-lean_inc(x_2);
-x_63 = l_Lean_Parser_tokenFn(x_2, x_15);
-x_64 = lean_ctor_get(x_63, 3);
+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_30; lean_object* x_62; lean_object* x_63; 
+lean_inc(x_6);
+x_14 = l_Lean_Parser_ParserState_restore(x_8, x_7, x_6);
+lean_dec(x_7);
+x_15 = lean_ctor_get(x_14, 0);
+lean_inc(x_15);
+x_16 = lean_array_get_size(x_15);
+lean_dec(x_15);
+lean_inc(x_1);
+x_62 = l_Lean_Parser_tokenFn(x_1, x_14);
+x_63 = lean_ctor_get(x_62, 3);
+lean_inc(x_63);
+if (lean_obj_tag(x_63) == 0)
+{
+lean_object* x_64; lean_object* x_65; 
+x_64 = lean_ctor_get(x_62, 0);
 lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
-{
-lean_object* x_65; lean_object* x_66; 
-x_65 = lean_ctor_get(x_63, 0);
-lean_inc(x_65);
-x_66 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_65);
-lean_dec(x_65);
-if (lean_obj_tag(x_66) == 2)
-{
-lean_object* x_67; lean_object* x_68; uint8_t x_69; 
-x_67 = lean_ctor_get(x_66, 1);
-lean_inc(x_67);
-lean_dec(x_66);
-x_68 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_69 = lean_string_dec_eq(x_67, x_68);
-lean_dec(x_67);
-if (x_69 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_7);
-x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_63, x_70, x_7);
-x_31 = x_71;
-goto block_62;
-}
-else
-{
-x_31 = x_63;
-goto block_62;
-}
-}
-else
-{
-lean_object* x_72; lean_object* x_73; 
-lean_dec(x_66);
-x_72 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_7);
-x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_63, x_72, x_7);
-x_31 = x_73;
-goto block_62;
-}
-}
-else
-{
-lean_object* x_74; lean_object* x_75; 
+x_65 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_64);
 lean_dec(x_64);
-x_74 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_7);
-x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_63, x_74, x_7);
-x_31 = x_75;
-goto block_62;
-}
-block_30:
+if (lean_obj_tag(x_65) == 2)
 {
-if (lean_obj_tag(x_21) == 0)
+lean_object* x_66; lean_object* x_67; uint8_t x_68; 
+x_66 = lean_ctor_get(x_65, 1);
+lean_inc(x_66);
+lean_dec(x_65);
+x_67 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_68 = lean_string_dec_eq(x_66, x_67);
+lean_dec(x_66);
+if (x_68 == 0)
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-lean_dec(x_20);
-lean_dec(x_19);
-lean_dec(x_10);
-x_22 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_18, x_22, x_17);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_12, x_7);
-lean_dec(x_7);
-return x_24;
+lean_object* x_69; lean_object* x_70; 
+x_69 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_6);
+x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_69, x_6);
+x_30 = x_70;
+goto block_61;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_30 = x_62;
+goto block_61;
+}
+}
+else
+{
+lean_object* x_71; lean_object* x_72; 
+lean_dec(x_65);
+x_71 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_6);
+x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_71, x_6);
+x_30 = x_72;
+goto block_61;
+}
+}
+else
+{
+lean_object* x_73; lean_object* x_74; 
+lean_dec(x_63);
+x_73 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_6);
+x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_73, x_6);
+x_30 = x_74;
+goto block_61;
+}
+block_29:
+{
+if (lean_obj_tag(x_20) == 0)
+{
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+lean_dec(x_19);
 lean_dec(x_18);
-x_25 = l_Array_shrink___main___rarg(x_19, x_17);
-lean_inc(x_7);
-if (lean_is_scalar(x_10)) {
- x_26 = lean_alloc_ctor(0, 4, 0);
+lean_dec(x_9);
+x_21 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_17, x_21, x_16);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_11, x_6);
+lean_dec(x_6);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_17);
+x_24 = l_Array_shrink___main___rarg(x_18, x_16);
+lean_inc(x_6);
+if (lean_is_scalar(x_9)) {
+ x_25 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_26 = x_10;
+ x_25 = x_9;
 }
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_7);
-lean_ctor_set(x_26, 2, x_20);
-lean_ctor_set(x_26, 3, x_21);
-x_27 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_17);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_12, x_7);
-lean_dec(x_7);
-return x_29;
+lean_ctor_set(x_25, 0, x_24);
+lean_ctor_set(x_25, 1, x_6);
+lean_ctor_set(x_25, 2, x_19);
+lean_ctor_set(x_25, 3, x_20);
+x_26 = l_Lean_Parser_Command_strictInferMod___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_6);
+lean_dec(x_6);
+return x_28;
 }
 }
-block_62:
+block_61:
 {
-lean_object* x_32; 
-x_32 = lean_ctor_get(x_31, 3);
+lean_object* x_31; 
+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; lean_object* x_34; 
+x_32 = lean_ctor_get(x_30, 1);
 lean_inc(x_32);
-if (lean_obj_tag(x_32) == 0)
+x_33 = l_Lean_Parser_tokenFn(x_1, x_30);
+x_34 = lean_ctor_get(x_33, 3);
+lean_inc(x_34);
+if (lean_obj_tag(x_34) == 0)
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_33 = lean_ctor_get(x_31, 1);
-lean_inc(x_33);
-x_34 = l_Lean_Parser_tokenFn(x_2, x_31);
-x_35 = lean_ctor_get(x_34, 3);
+lean_object* x_35; lean_object* x_36; 
+x_35 = lean_ctor_get(x_33, 0);
 lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
+x_36 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_35);
+lean_dec(x_35);
+if (lean_obj_tag(x_36) == 2)
 {
-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_Lean_Parser_checkLeadingFn___spec__1(x_36);
+lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_37 = lean_ctor_get(x_36, 1);
+lean_inc(x_37);
 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_inc(x_38);
+x_38 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_39 = lean_string_dec_eq(x_37, x_38);
 lean_dec(x_37);
-x_39 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_40 = lean_string_dec_eq(x_38, x_39);
-lean_dec(x_38);
-if (x_40 == 0)
+if (x_39 == 0)
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_41 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_41, x_33);
-x_43 = lean_ctor_get(x_42, 0);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_40 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_32);
+x_42 = lean_ctor_get(x_41, 0);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_41, 2);
 lean_inc(x_43);
-x_44 = lean_ctor_get(x_42, 2);
+x_44 = lean_ctor_get(x_41, 3);
 lean_inc(x_44);
-x_45 = lean_ctor_get(x_42, 3);
-lean_inc(x_45);
+x_17 = x_41;
 x_18 = x_42;
 x_19 = x_43;
 x_20 = x_44;
-x_21 = x_45;
-goto block_30;
+goto block_29;
 }
 else
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_33);
-x_46 = lean_ctor_get(x_34, 0);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_32);
+x_45 = lean_ctor_get(x_33, 0);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_33, 2);
 lean_inc(x_46);
-x_47 = lean_ctor_get(x_34, 2);
+x_47 = lean_ctor_get(x_33, 3);
 lean_inc(x_47);
-x_48 = lean_ctor_get(x_34, 3);
-lean_inc(x_48);
-x_18 = x_34;
+x_17 = x_33;
+x_18 = x_45;
 x_19 = x_46;
 x_20 = x_47;
-x_21 = x_48;
-goto block_30;
+goto block_29;
 }
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_dec(x_37);
-x_49 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_49, x_33);
-x_51 = lean_ctor_get(x_50, 0);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_36);
+x_48 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_48, x_32);
+x_50 = lean_ctor_get(x_49, 0);
+lean_inc(x_50);
+x_51 = lean_ctor_get(x_49, 2);
 lean_inc(x_51);
-x_52 = lean_ctor_get(x_50, 2);
+x_52 = lean_ctor_get(x_49, 3);
 lean_inc(x_52);
-x_53 = lean_ctor_get(x_50, 3);
-lean_inc(x_53);
+x_17 = x_49;
 x_18 = x_50;
 x_19 = x_51;
 x_20 = x_52;
-x_21 = x_53;
-goto block_30;
+goto block_29;
 }
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-lean_dec(x_35);
-x_54 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_54, x_33);
-x_56 = lean_ctor_get(x_55, 0);
+lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_dec(x_34);
+x_53 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_53, x_32);
+x_55 = lean_ctor_get(x_54, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_54, 2);
 lean_inc(x_56);
-x_57 = lean_ctor_get(x_55, 2);
+x_57 = lean_ctor_get(x_54, 3);
 lean_inc(x_57);
-x_58 = lean_ctor_get(x_55, 3);
-lean_inc(x_58);
+x_17 = x_54;
 x_18 = x_55;
 x_19 = x_56;
 x_20 = x_57;
-x_21 = x_58;
-goto block_30;
+goto block_29;
 }
 }
 else
 {
-lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_32);
-lean_dec(x_2);
-x_59 = lean_ctor_get(x_31, 0);
+lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+lean_dec(x_31);
+lean_dec(x_1);
+x_58 = lean_ctor_get(x_30, 0);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_30, 2);
 lean_inc(x_59);
-x_60 = lean_ctor_get(x_31, 2);
+x_60 = lean_ctor_get(x_30, 3);
 lean_inc(x_60);
-x_61 = lean_ctor_get(x_31, 3);
-lean_inc(x_61);
-x_18 = x_31;
+x_17 = x_30;
+x_18 = x_58;
 x_19 = x_59;
 x_20 = x_60;
-x_21 = x_61;
-goto block_30;
+goto block_29;
 }
 }
 }
@@ -10471,8 +10228,8 @@ lean_object* _init_l_Lean_Parser_Command_strictInferMod___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
@@ -10503,7 +10260,7 @@ lean_object* _init_l_Lean_Parser_Command_strictInferMod___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_strictInferMod___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_strictInferMod___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -10527,58 +10284,55 @@ x_1 = l_Lean_Parser_Command_strictInferMod___closed__5;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_inferMod___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_inferMod___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
-lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-lean_inc(x_2);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
 lean_inc(x_1);
-x_7 = l_Lean_Parser_Command_relaxedInferMod___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+x_6 = l_Lean_Parser_Command_relaxedInferMod___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_7;
-}
-else
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_7, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_10, x_6);
-lean_dec(x_10);
-if (x_11 == 0)
-{
+x_10 = lean_nat_dec_eq(x_9, x_5);
 lean_dec(x_9);
-lean_dec(x_6);
+if (x_10 == 0)
+{
+lean_dec(x_8);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-lean_inc(x_6);
-x_12 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = l_Lean_Parser_Command_strictInferMod___elambda__1(x_1, x_11);
+x_13 = l_Lean_Parser_mergeOrElseErrors(x_12, x_8, x_5);
 lean_dec(x_5);
-x_13 = l_Lean_Parser_Command_strictInferMod___elambda__1(x_1, x_2, x_12);
-x_14 = l_Lean_Parser_mergeOrElseErrors(x_13, x_9, x_6);
-lean_dec(x_6);
-return x_14;
+return x_13;
 }
 }
 }
@@ -10601,7 +10355,7 @@ lean_object* _init_l_Lean_Parser_Command_inferMod___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_inferMod___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_inferMod___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -10656,288 +10410,271 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_introRule___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_introRule___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_introRule___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_introRule___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_introRule___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_introRule___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_introRule___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_introRule___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_introRule___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_65; lean_object* x_66; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_65 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_66 = lean_ctor_get(x_65, 3);
+lean_inc(x_66);
+if (lean_obj_tag(x_66) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_67; lean_object* x_68; 
+x_67 = lean_ctor_get(x_65, 0);
+lean_inc(x_67);
+x_68 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_67);
+lean_dec(x_67);
+if (lean_obj_tag(x_68) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_68; lean_object* x_69; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_68 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_69 = lean_ctor_get(x_68, 3);
+lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_69 = lean_ctor_get(x_68, 1);
 lean_inc(x_69);
-if (lean_obj_tag(x_69) == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = lean_ctor_get(x_68, 0);
-lean_inc(x_70);
-x_71 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_70);
-lean_dec(x_70);
-if (lean_obj_tag(x_71) == 2)
-{
-lean_object* x_72; lean_object* x_73; uint8_t x_74; 
-x_72 = lean_ctor_get(x_71, 1);
-lean_inc(x_72);
-lean_dec(x_71);
-x_73 = l_Lean_Parser_Term_doPat___elambda__1___closed__6;
-x_74 = lean_string_dec_eq(x_72, x_73);
-lean_dec(x_72);
-if (x_74 == 0)
-{
-lean_object* x_75; lean_object* x_76; 
-x_75 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
-lean_inc(x_10);
-x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_75, x_10);
-x_19 = x_76;
-goto block_67;
-}
-else
-{
-x_19 = x_68;
-goto block_67;
-}
-}
-else
-{
-lean_object* x_77; lean_object* x_78; 
-lean_dec(x_71);
-x_77 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
-lean_inc(x_10);
-x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_77, x_10);
-x_19 = x_78;
-goto block_67;
-}
-}
-else
-{
-lean_object* x_79; lean_object* x_80; 
+lean_dec(x_68);
+x_70 = l_Lean_Parser_Term_doPat___elambda__1___closed__6;
+x_71 = lean_string_dec_eq(x_69, x_70);
 lean_dec(x_69);
-x_79 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
-lean_inc(x_10);
-x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_79, x_10);
-x_19 = x_80;
-goto block_67;
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
+lean_inc(x_7);
+x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_72, x_7);
+x_16 = x_73;
+goto block_64;
 }
-block_67:
+else
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
+x_16 = x_65;
+goto block_64;
+}
+}
+else
+{
+lean_object* x_74; lean_object* x_75; 
+lean_dec(x_68);
+x_74 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
+lean_inc(x_7);
+x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_74, x_7);
+x_16 = x_75;
+goto block_64;
+}
+}
+else
+{
+lean_object* x_76; lean_object* x_77; 
+lean_dec(x_66);
+x_76 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
+lean_inc(x_7);
+x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_76, x_7);
+x_16 = x_77;
+goto block_64;
+}
+block_64:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_20 = lean_ctor_get(x_18, 0);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_object* x_21; lean_object* x_22; 
-lean_inc(x_2);
-lean_inc(x_1);
-x_21 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_22 = lean_ctor_get(x_21, 3);
+x_21 = lean_array_get_size(x_20);
+lean_dec(x_20);
+x_22 = lean_ctor_get(x_18, 1);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_23 = lean_ctor_get(x_21, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
-lean_dec(x_23);
-x_25 = lean_ctor_get(x_21, 1);
-lean_inc(x_25);
-lean_inc(x_2);
 lean_inc(x_1);
-x_26 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_2, x_21);
+x_23 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_18);
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+lean_dec(x_22);
+x_25 = l_Lean_nullKind;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_23, x_25, x_21);
 x_27 = lean_ctor_get(x_26, 3);
 lean_inc(x_27);
 if (lean_obj_tag(x_27) == 0)
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_25);
-x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_26, x_28, x_24);
-x_30 = lean_ctor_get(x_29, 3);
-lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+x_28 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_26);
+x_29 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
+}
+else
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_31 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_29);
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_27);
+lean_dec(x_1);
 x_32 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_18);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_13, x_10);
-lean_dec(x_10);
+x_33 = l_Lean_Parser_ParserState_mkNode(x_26, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
 return x_34;
 }
+}
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_30);
-lean_dec(x_2);
+lean_object* x_35; uint8_t x_36; 
+lean_dec(x_24);
+x_35 = lean_ctor_get(x_23, 1);
+lean_inc(x_35);
+x_36 = lean_nat_dec_eq(x_35, x_22);
+lean_dec(x_35);
+if (x_36 == 0)
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+lean_dec(x_22);
+x_37 = l_Lean_nullKind;
+x_38 = l_Lean_Parser_ParserState_mkNode(x_23, x_37, x_21);
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_40 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_38);
+x_41 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_39);
 lean_dec(x_1);
-x_35 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_29, x_35, x_18);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_13, x_10);
-lean_dec(x_10);
-return x_37;
-}
-}
-else
-{
-lean_object* x_38; uint8_t x_39; 
-lean_dec(x_27);
-x_38 = lean_ctor_get(x_26, 1);
-lean_inc(x_38);
-x_39 = lean_nat_dec_eq(x_38, x_25);
-lean_dec(x_38);
-if (x_39 == 0)
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-lean_dec(x_25);
-x_40 = l_Lean_nullKind;
-x_41 = l_Lean_Parser_ParserState_mkNode(x_26, x_40, x_24);
-x_42 = lean_ctor_get(x_41, 3);
-lean_inc(x_42);
-if (lean_obj_tag(x_42) == 0)
-{
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_43 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_41);
 x_44 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_18);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_13, x_10);
-lean_dec(x_10);
+x_45 = l_Lean_Parser_ParserState_mkNode(x_38, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
 return x_46;
 }
+}
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_dec(x_42);
-lean_dec(x_2);
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_47 = l_Lean_Parser_ParserState_restore(x_23, x_21, x_22);
+x_48 = l_Lean_nullKind;
+x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_21);
+x_50 = lean_ctor_get(x_49, 3);
+lean_inc(x_50);
+if (lean_obj_tag(x_50) == 0)
+{
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_51 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_49);
+x_52 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_51, x_52, x_15);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_10, x_7);
+lean_dec(x_7);
+return x_54;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_dec(x_50);
 lean_dec(x_1);
-x_47 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_41, x_47, x_18);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_13, x_10);
-lean_dec(x_10);
-return x_49;
-}
-}
-else
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-x_50 = l_Lean_Parser_ParserState_restore(x_26, x_24, x_25);
-x_51 = l_Lean_nullKind;
-x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_24);
-x_53 = lean_ctor_get(x_52, 3);
-lean_inc(x_53);
-if (lean_obj_tag(x_53) == 0)
-{
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-x_54 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_52);
 x_55 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
-x_56 = l_Lean_Parser_ParserState_mkNode(x_54, x_55, x_18);
-x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_13, x_10);
-lean_dec(x_10);
+x_56 = l_Lean_Parser_ParserState_mkNode(x_49, x_55, x_15);
+x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_10, x_7);
+lean_dec(x_7);
 return x_57;
 }
+}
+}
+}
 else
 {
 lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-lean_dec(x_53);
-lean_dec(x_2);
+lean_dec(x_19);
 lean_dec(x_1);
 x_58 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_52, x_58, x_18);
-x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_13, x_10);
-lean_dec(x_10);
+x_59 = l_Lean_Parser_ParserState_mkNode(x_18, x_58, x_15);
+x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_10, x_7);
+lean_dec(x_7);
 return x_60;
 }
 }
-}
-}
 else
 {
 lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-lean_dec(x_22);
-lean_dec(x_2);
+lean_dec(x_17);
 lean_dec(x_1);
 x_61 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
-x_62 = l_Lean_Parser_ParserState_mkNode(x_21, x_61, x_18);
-x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_13, x_10);
-lean_dec(x_10);
+x_62 = l_Lean_Parser_ParserState_mkNode(x_16, x_61, x_15);
+x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_10, x_7);
+lean_dec(x_7);
 return x_63;
 }
 }
-else
-{
-lean_object* x_64; lean_object* x_65; lean_object* x_66; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_64 = l_Lean_Parser_Command_introRule___elambda__1___closed__2;
-x_65 = l_Lean_Parser_ParserState_mkNode(x_19, x_64, x_18);
-x_66 = l_Lean_Parser_mergeOrElseErrors(x_65, x_13, x_10);
-lean_dec(x_10);
-return x_66;
-}
-}
 }
 }
 }
@@ -10969,7 +10706,7 @@ lean_object* _init_l_Lean_Parser_Command_introRule___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_introRule___closed__2;
@@ -11013,7 +10750,7 @@ lean_object* _init_l_Lean_Parser_Command_introRule___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_introRule___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_introRule___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -11037,67 +10774,64 @@ x_1 = l_Lean_Parser_Command_introRule___closed__8;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-lean_inc(x_2);
-x_8 = l_Lean_Parser_Command_introRule___elambda__1(x_2, x_3, x_4);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Command_introRule___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_10; uint8_t x_11; 
-lean_dec(x_6);
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_7, x_10);
-lean_dec(x_10);
-lean_dec(x_7);
-if (x_11 == 0)
+lean_object* x_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
+lean_dec(x_5);
+if (x_9 == 0)
 {
-x_4 = x_8;
+x_2 = x_6;
 goto _start;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_13 = l_Lean_Parser_manyAux___main___closed__1;
-x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
-return x_14;
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_15; uint8_t x_16; 
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_15 = lean_ctor_get(x_8, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_7, x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+lean_object* x_13; uint8_t x_14; 
 lean_dec(x_7);
-lean_dec(x_6);
-return x_8;
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_17;
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+return x_15;
 }
 }
 }
@@ -11133,13 +10867,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_inductive___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_inductive___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_inductive___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_inductive___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_inductive___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_inductive___elambda__1___closed__5() {
@@ -11191,192 +10924,183 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_inductive___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_inductive___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_inductive___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_inductive___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_42; lean_object* x_43; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_42 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_43 = lean_ctor_get(x_42, 3);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_40; lean_object* x_41; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_40 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_41 = lean_ctor_get(x_40, 3);
+lean_inc(x_41);
+if (lean_obj_tag(x_41) == 0)
 {
-lean_object* x_44; lean_object* x_45; 
-x_44 = lean_ctor_get(x_42, 0);
+lean_object* x_42; lean_object* x_43; 
+x_42 = lean_ctor_get(x_40, 0);
+lean_inc(x_42);
+x_43 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_42);
+lean_dec(x_42);
+if (lean_obj_tag(x_43) == 2)
+{
+lean_object* x_44; lean_object* x_45; uint8_t x_46; 
+x_44 = lean_ctor_get(x_43, 1);
 lean_inc(x_44);
-x_45 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_44);
+lean_dec(x_43);
+x_45 = l_Lean_Parser_Command_inductive___elambda__1___closed__6;
+x_46 = lean_string_dec_eq(x_44, x_45);
 lean_dec(x_44);
-if (lean_obj_tag(x_45) == 2)
+if (x_46 == 0)
 {
-lean_object* x_46; lean_object* x_47; uint8_t x_48; 
-x_46 = lean_ctor_get(x_45, 1);
-lean_inc(x_46);
-lean_dec(x_45);
-x_47 = l_Lean_Parser_Command_inductive___elambda__1___closed__6;
-x_48 = lean_string_dec_eq(x_46, x_47);
-lean_dec(x_46);
-if (x_48 == 0)
+lean_object* x_47; lean_object* x_48; 
+x_47 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
+lean_inc(x_7);
+x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_47, x_7);
+x_16 = x_48;
+goto block_39;
+}
+else
+{
+x_16 = x_40;
+goto block_39;
+}
+}
+else
 {
 lean_object* x_49; lean_object* x_50; 
+lean_dec(x_43);
 x_49 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
-lean_inc(x_8);
-x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_49, x_8);
-x_17 = x_50;
-goto block_41;
-}
-else
-{
-x_17 = x_42;
-goto block_41;
+lean_inc(x_7);
+x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_49, x_7);
+x_16 = x_50;
+goto block_39;
 }
 }
 else
 {
 lean_object* x_51; lean_object* x_52; 
-lean_dec(x_45);
+lean_dec(x_41);
 x_51 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
-lean_inc(x_8);
-x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_51, x_8);
-x_17 = x_52;
-goto block_41;
+lean_inc(x_7);
+x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_51, x_7);
+x_16 = x_52;
+goto block_39;
 }
-}
-else
+block_39:
 {
-lean_object* x_53; lean_object* x_54; 
-lean_dec(x_43);
-x_53 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
-lean_inc(x_8);
-x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_53, x_8);
-x_17 = x_54;
-goto block_41;
-}
-block_41:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_18; lean_object* x_19; 
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_18 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; 
-lean_inc(x_2);
+lean_object* x_20; lean_object* x_21; 
 lean_inc(x_1);
-x_21 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_19);
-x_22 = lean_ctor_get(x_21, 3);
+x_20 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_18);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+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; 
+x_22 = lean_ctor_get(x_20, 0);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; uint8_t 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; 
-x_23 = lean_ctor_get(x_21, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
-lean_dec(x_23);
-x_25 = 0;
-x_26 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1(x_25, x_1, x_2, x_21);
-x_27 = l_Lean_nullKind;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_24);
-x_29 = l_Lean_Parser_Command_inductive___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_23 = lean_array_get_size(x_22);
 lean_dec(x_22);
-lean_dec(x_2);
+x_24 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1(x_1, x_20);
+x_25 = l_Lean_nullKind;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_23);
+x_27 = l_Lean_Parser_Command_inductive___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
+}
+else
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_32 = l_Lean_Parser_Command_inductive___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_21, x_32, x_16);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_8);
-lean_dec(x_8);
-return x_34;
+x_30 = l_Lean_Parser_Command_inductive___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_20, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
 }
 }
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_35 = l_Lean_Parser_Command_inductive___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_19, x_35, x_16);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_11, x_8);
-lean_dec(x_8);
-return x_37;
+x_33 = l_Lean_Parser_Command_inductive___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_18, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
 }
 }
 else
 {
-lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_38 = l_Lean_Parser_Command_inductive___elambda__1___closed__2;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_17, x_38, x_16);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_11, x_8);
-lean_dec(x_8);
-return x_40;
+x_36 = l_Lean_Parser_Command_inductive___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_16, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
 }
 }
 }
@@ -11464,7 +11188,7 @@ lean_object* _init_l_Lean_Parser_Command_inductive___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_inductive___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_inductive___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -11488,16 +11212,6 @@ x_1 = l_Lean_Parser_Command_inductive___closed__9;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-return x_6;
-}
-}
 lean_object* _init_l_Lean_Parser_Command_classInductive___elambda__1___closed__1() {
 _start:
 {
@@ -11529,13 +11243,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_classInductive___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_classInductive___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_classInductive___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_classInductive___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_classInductive___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_classInductive___elambda__1___closed__5() {
@@ -11587,353 +11300,343 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_classInductive___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_classInductive___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; 
-x_4 = l_Lean_Parser_Command_classInductive___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_classInductive___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
+x_6 = lean_ctor_get(x_2, 1);
 lean_inc(x_6);
-x_7 = lean_ctor_get(x_3, 1);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_6);
-lean_dec(x_6);
-lean_inc(x_3);
+x_7 = lean_array_get_size(x_5);
+lean_dec(x_5);
 lean_inc(x_2);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-if (lean_is_exclusive(x_3)) {
- lean_ctor_release(x_3, 0);
- lean_ctor_release(x_3, 1);
- lean_ctor_release(x_3, 2);
- lean_ctor_release(x_3, 3);
- x_10 = x_3;
+x_8 = lean_apply_2(x_4, x_1, x_2);
+if (lean_is_exclusive(x_2)) {
+ lean_ctor_release(x_2, 0);
+ lean_ctor_release(x_2, 1);
+ lean_ctor_release(x_2, 2);
+ lean_ctor_release(x_2, 3);
+ x_9 = x_2;
 } else {
- lean_dec_ref(x_3);
- x_10 = lean_box(0);
+ lean_dec_ref(x_2);
+ x_9 = lean_box(0);
 }
-x_11 = lean_ctor_get(x_9, 3);
+x_10 = lean_ctor_get(x_8, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
 lean_dec(x_10);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_12; lean_object* x_13; uint8_t x_14; 
-x_12 = lean_ctor_get(x_11, 0);
+x_12 = lean_ctor_get(x_8, 1);
 lean_inc(x_12);
-lean_dec(x_11);
-x_13 = lean_ctor_get(x_9, 1);
-lean_inc(x_13);
-x_14 = lean_nat_dec_eq(x_13, x_7);
-lean_dec(x_13);
-if (x_14 == 0)
-{
+x_13 = lean_nat_dec_eq(x_12, x_6);
 lean_dec(x_12);
-lean_dec(x_10);
-lean_dec(x_8);
+if (x_13 == 0)
+{
+lean_dec(x_11);
+lean_dec(x_9);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-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_51; lean_object* x_83; lean_object* x_84; 
-lean_inc(x_7);
-x_15 = l_Lean_Parser_ParserState_restore(x_9, x_8, x_7);
-lean_dec(x_8);
-x_16 = lean_ctor_get(x_15, 0);
-lean_inc(x_16);
-x_17 = lean_array_get_size(x_16);
-lean_dec(x_16);
-lean_inc(x_2);
-x_83 = l_Lean_Parser_tokenFn(x_2, x_15);
-x_84 = lean_ctor_get(x_83, 3);
-lean_inc(x_84);
-if (lean_obj_tag(x_84) == 0)
+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_49; lean_object* x_81; lean_object* x_82; 
+lean_inc(x_6);
+x_14 = l_Lean_Parser_ParserState_restore(x_8, x_7, x_6);
+lean_dec(x_7);
+x_15 = lean_ctor_get(x_14, 0);
+lean_inc(x_15);
+x_16 = lean_array_get_size(x_15);
+lean_dec(x_15);
+lean_inc(x_1);
+x_81 = l_Lean_Parser_tokenFn(x_1, x_14);
+x_82 = lean_ctor_get(x_81, 3);
+lean_inc(x_82);
+if (lean_obj_tag(x_82) == 0)
 {
-lean_object* x_85; lean_object* x_86; 
-x_85 = lean_ctor_get(x_83, 0);
+lean_object* x_83; lean_object* x_84; 
+x_83 = lean_ctor_get(x_81, 0);
+lean_inc(x_83);
+x_84 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_83);
+lean_dec(x_83);
+if (lean_obj_tag(x_84) == 2)
+{
+lean_object* x_85; lean_object* x_86; uint8_t x_87; 
+x_85 = lean_ctor_get(x_84, 1);
 lean_inc(x_85);
-x_86 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_85);
+lean_dec(x_84);
+x_86 = l_Lean_Parser_Command_classInductive___elambda__1___closed__6;
+x_87 = lean_string_dec_eq(x_85, x_86);
 lean_dec(x_85);
-if (lean_obj_tag(x_86) == 2)
+if (x_87 == 0)
 {
-lean_object* x_87; lean_object* x_88; uint8_t x_89; 
-x_87 = lean_ctor_get(x_86, 1);
-lean_inc(x_87);
-lean_dec(x_86);
-x_88 = l_Lean_Parser_Command_classInductive___elambda__1___closed__6;
-x_89 = lean_string_dec_eq(x_87, x_88);
-lean_dec(x_87);
-if (x_89 == 0)
+lean_object* x_88; lean_object* x_89; 
+x_88 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
+lean_inc(x_6);
+x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_81, x_88, x_6);
+x_49 = x_89;
+goto block_80;
+}
+else
+{
+x_49 = x_81;
+goto block_80;
+}
+}
+else
 {
 lean_object* x_90; lean_object* x_91; 
+lean_dec(x_84);
 x_90 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
-lean_inc(x_7);
-x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_90, x_7);
-x_51 = x_91;
-goto block_82;
-}
-else
-{
-x_51 = x_83;
-goto block_82;
+lean_inc(x_6);
+x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_81, x_90, x_6);
+x_49 = x_91;
+goto block_80;
 }
 }
 else
 {
 lean_object* x_92; lean_object* x_93; 
-lean_dec(x_86);
+lean_dec(x_82);
 x_92 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
-lean_inc(x_7);
-x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_92, x_7);
-x_51 = x_93;
-goto block_82;
+lean_inc(x_6);
+x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_81, x_92, x_6);
+x_49 = x_93;
+goto block_80;
 }
-}
-else
+block_48:
 {
-lean_object* x_94; lean_object* x_95; 
-lean_dec(x_84);
-x_94 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
-lean_inc(x_7);
-x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_94, x_7);
-x_51 = x_95;
-goto block_82;
-}
-block_50:
+if (lean_obj_tag(x_20) == 0)
 {
+lean_object* x_21; 
+lean_dec(x_19);
+lean_dec(x_18);
+lean_dec(x_9);
+x_21 = lean_ctor_get(x_17, 3);
+lean_inc(x_21);
 if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_22; 
-lean_dec(x_20);
-lean_dec(x_19);
-lean_dec(x_10);
-x_22 = lean_ctor_get(x_18, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; 
-lean_inc(x_2);
+lean_object* x_22; lean_object* x_23; 
 lean_inc(x_1);
-x_23 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_2, x_18);
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
+x_22 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_17);
+x_23 = lean_ctor_get(x_22, 3);
+lean_inc(x_23);
+if (lean_obj_tag(x_23) == 0)
 {
-lean_object* x_25; lean_object* x_26; 
-lean_inc(x_2);
+lean_object* x_24; lean_object* x_25; 
 lean_inc(x_1);
-x_25 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_23);
-x_26 = lean_ctor_get(x_25, 3);
+x_24 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_22);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+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; 
+x_26 = lean_ctor_get(x_24, 0);
 lean_inc(x_26);
-if (lean_obj_tag(x_26) == 0)
-{
-lean_object* x_27; lean_object* x_28; uint8_t 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; 
-x_27 = lean_ctor_get(x_25, 0);
-lean_inc(x_27);
-x_28 = lean_array_get_size(x_27);
-lean_dec(x_27);
-x_29 = 0;
-x_30 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1(x_29, x_1, x_2, x_25);
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_28);
-x_33 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_17);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_12, x_7);
-lean_dec(x_7);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+x_27 = lean_array_get_size(x_26);
 lean_dec(x_26);
-lean_dec(x_2);
+x_28 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_inductive___elambda__1___spec__1(x_1, x_24);
+x_29 = l_Lean_nullKind;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_27);
+x_31 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_16);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_11, x_6);
+lean_dec(x_6);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_25);
 lean_dec(x_1);
-x_36 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_25, x_36, x_17);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_12, x_7);
-lean_dec(x_7);
-return x_38;
+x_34 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_24, x_34, x_16);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_6);
+lean_dec(x_6);
+return x_36;
 }
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_24);
-lean_dec(x_2);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+lean_dec(x_23);
 lean_dec(x_1);
-x_39 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_23, x_39, x_17);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_12, x_7);
-lean_dec(x_7);
-return x_41;
+x_37 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
+x_38 = l_Lean_Parser_ParserState_mkNode(x_22, x_37, x_16);
+x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_6);
+lean_dec(x_6);
+return x_39;
 }
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-lean_dec(x_22);
-lean_dec(x_2);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_42 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_18, x_42, x_17);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_12, x_7);
-lean_dec(x_7);
-return x_44;
+x_40 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_17, x_40, x_16);
+x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_11, x_6);
+lean_dec(x_6);
+return x_42;
 }
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_45 = l_Array_shrink___main___rarg(x_19, x_17);
-lean_inc(x_7);
-if (lean_is_scalar(x_10)) {
- x_46 = lean_alloc_ctor(0, 4, 0);
+x_43 = l_Array_shrink___main___rarg(x_18, x_16);
+lean_inc(x_6);
+if (lean_is_scalar(x_9)) {
+ x_44 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_46 = x_10;
+ x_44 = x_9;
 }
-lean_ctor_set(x_46, 0, x_45);
-lean_ctor_set(x_46, 1, x_7);
-lean_ctor_set(x_46, 2, x_20);
-lean_ctor_set(x_46, 3, x_21);
-x_47 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_17);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_12, x_7);
-lean_dec(x_7);
-return x_49;
+lean_ctor_set(x_44, 0, x_43);
+lean_ctor_set(x_44, 1, x_6);
+lean_ctor_set(x_44, 2, x_19);
+lean_ctor_set(x_44, 3, x_20);
+x_45 = l_Lean_Parser_Command_classInductive___elambda__1___closed__2;
+x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_16);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_11, x_6);
+lean_dec(x_6);
+return x_47;
 }
 }
-block_82:
+block_80:
 {
-lean_object* x_52; 
-x_52 = lean_ctor_get(x_51, 3);
-lean_inc(x_52);
-if (lean_obj_tag(x_52) == 0)
+lean_object* x_50; 
+x_50 = lean_ctor_get(x_49, 3);
+lean_inc(x_50);
+if (lean_obj_tag(x_50) == 0)
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_53 = lean_ctor_get(x_51, 1);
+lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_51 = lean_ctor_get(x_49, 1);
+lean_inc(x_51);
+lean_inc(x_1);
+x_52 = l_Lean_Parser_tokenFn(x_1, x_49);
+x_53 = lean_ctor_get(x_52, 3);
 lean_inc(x_53);
-lean_inc(x_2);
-x_54 = l_Lean_Parser_tokenFn(x_2, x_51);
-x_55 = lean_ctor_get(x_54, 3);
-lean_inc(x_55);
-if (lean_obj_tag(x_55) == 0)
+if (lean_obj_tag(x_53) == 0)
 {
-lean_object* x_56; lean_object* x_57; 
-x_56 = lean_ctor_get(x_54, 0);
+lean_object* x_54; lean_object* x_55; 
+x_54 = lean_ctor_get(x_52, 0);
+lean_inc(x_54);
+x_55 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_54);
+lean_dec(x_54);
+if (lean_obj_tag(x_55) == 2)
+{
+lean_object* x_56; lean_object* x_57; uint8_t x_58; 
+x_56 = lean_ctor_get(x_55, 1);
 lean_inc(x_56);
-x_57 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_56);
-lean_dec(x_56);
-if (lean_obj_tag(x_57) == 2)
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_58 = lean_ctor_get(x_57, 1);
-lean_inc(x_58);
-lean_dec(x_57);
-x_59 = l_Lean_Parser_Command_inductive___elambda__1___closed__6;
-x_60 = lean_string_dec_eq(x_58, x_59);
-lean_dec(x_58);
-if (x_60 == 0)
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-x_61 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
-x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_53);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_ctor_get(x_62, 2);
-lean_inc(x_64);
-x_65 = lean_ctor_get(x_62, 3);
-lean_inc(x_65);
-x_18 = x_62;
-x_19 = x_63;
-x_20 = x_64;
-x_21 = x_65;
-goto block_50;
-}
-else
-{
-lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-lean_dec(x_53);
-x_66 = lean_ctor_get(x_54, 0);
-lean_inc(x_66);
-x_67 = lean_ctor_get(x_54, 2);
-lean_inc(x_67);
-x_68 = lean_ctor_get(x_54, 3);
-lean_inc(x_68);
-x_18 = x_54;
-x_19 = x_66;
-x_20 = x_67;
-x_21 = x_68;
-goto block_50;
-}
-}
-else
-{
-lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-lean_dec(x_57);
-x_69 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
-x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_69, x_53);
-x_71 = lean_ctor_get(x_70, 0);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_70, 2);
-lean_inc(x_72);
-x_73 = lean_ctor_get(x_70, 3);
-lean_inc(x_73);
-x_18 = x_70;
-x_19 = x_71;
-x_20 = x_72;
-x_21 = x_73;
-goto block_50;
-}
-}
-else
-{
-lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
 lean_dec(x_55);
-x_74 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
-x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_74, x_53);
-x_76 = lean_ctor_get(x_75, 0);
-lean_inc(x_76);
-x_77 = lean_ctor_get(x_75, 2);
-lean_inc(x_77);
-x_78 = lean_ctor_get(x_75, 3);
-lean_inc(x_78);
-x_18 = x_75;
-x_19 = x_76;
-x_20 = x_77;
-x_21 = x_78;
-goto block_50;
+x_57 = l_Lean_Parser_Command_inductive___elambda__1___closed__6;
+x_58 = lean_string_dec_eq(x_56, x_57);
+lean_dec(x_56);
+if (x_58 == 0)
+{
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_59 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
+x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_59, x_51);
+x_61 = lean_ctor_get(x_60, 0);
+lean_inc(x_61);
+x_62 = lean_ctor_get(x_60, 2);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_60, 3);
+lean_inc(x_63);
+x_17 = x_60;
+x_18 = x_61;
+x_19 = x_62;
+x_20 = x_63;
+goto block_48;
+}
+else
+{
+lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+lean_dec(x_51);
+x_64 = lean_ctor_get(x_52, 0);
+lean_inc(x_64);
+x_65 = lean_ctor_get(x_52, 2);
+lean_inc(x_65);
+x_66 = lean_ctor_get(x_52, 3);
+lean_inc(x_66);
+x_17 = x_52;
+x_18 = x_64;
+x_19 = x_65;
+x_20 = x_66;
+goto block_48;
 }
 }
 else
 {
-lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-lean_dec(x_52);
-x_79 = lean_ctor_get(x_51, 0);
+lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+lean_dec(x_55);
+x_67 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
+x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_67, x_51);
+x_69 = lean_ctor_get(x_68, 0);
+lean_inc(x_69);
+x_70 = lean_ctor_get(x_68, 2);
+lean_inc(x_70);
+x_71 = lean_ctor_get(x_68, 3);
+lean_inc(x_71);
+x_17 = x_68;
+x_18 = x_69;
+x_19 = x_70;
+x_20 = x_71;
+goto block_48;
+}
+}
+else
+{
+lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; 
+lean_dec(x_53);
+x_72 = l_Lean_Parser_Command_inductive___elambda__1___closed__9;
+x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_72, x_51);
+x_74 = lean_ctor_get(x_73, 0);
+lean_inc(x_74);
+x_75 = lean_ctor_get(x_73, 2);
+lean_inc(x_75);
+x_76 = lean_ctor_get(x_73, 3);
+lean_inc(x_76);
+x_17 = x_73;
+x_18 = x_74;
+x_19 = x_75;
+x_20 = x_76;
+goto block_48;
+}
+}
+else
+{
+lean_object* x_77; lean_object* x_78; lean_object* x_79; 
+lean_dec(x_50);
+x_77 = lean_ctor_get(x_49, 0);
+lean_inc(x_77);
+x_78 = lean_ctor_get(x_49, 2);
+lean_inc(x_78);
+x_79 = lean_ctor_get(x_49, 3);
 lean_inc(x_79);
-x_80 = lean_ctor_get(x_51, 2);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_51, 3);
-lean_inc(x_81);
-x_18 = x_51;
-x_19 = x_79;
-x_20 = x_80;
-x_21 = x_81;
-goto block_50;
+x_17 = x_49;
+x_18 = x_77;
+x_19 = x_78;
+x_20 = x_79;
+goto block_48;
 }
 }
 }
@@ -11996,7 +11699,7 @@ lean_object* _init_l_Lean_Parser_Command_classInductive___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_classInductive___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_classInductive___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -12020,6 +11723,68 @@ x_1 = l_Lean_Parser_Command_classInductive___closed__7;
 return x_1;
 }
 }
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_ident___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
+lean_dec(x_5);
+if (x_9 == 0)
+{
+x_2 = x_6;
+goto _start;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
+}
+}
+else
+{
+lean_object* x_13; uint8_t x_14; 
+lean_dec(x_7);
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
+}
+else
+{
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+return x_15;
+}
+}
+}
+}
 lean_object* _init_l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__1() {
 _start:
 {
@@ -12051,402 +11816,384 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_structExplicitBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_structExplicitBinder___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_51; lean_object* x_76; lean_object* x_103; lean_object* x_104; 
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_103 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_104 = lean_ctor_get(x_103, 3);
-lean_inc(x_104);
-if (lean_obj_tag(x_104) == 0)
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_105; lean_object* x_106; 
-x_105 = lean_ctor_get(x_103, 0);
-lean_inc(x_105);
-x_106 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_105);
-lean_dec(x_105);
-if (lean_obj_tag(x_106) == 2)
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
 {
-lean_object* x_107; lean_object* x_108; uint8_t x_109; 
-x_107 = lean_ctor_get(x_106, 1);
-lean_inc(x_107);
-lean_dec(x_106);
-x_108 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_109 = lean_string_dec_eq(x_107, x_108);
-lean_dec(x_107);
-if (x_109 == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_48; lean_object* x_73; lean_object* x_99; lean_object* x_100; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_99 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_100 = lean_ctor_get(x_99, 3);
+lean_inc(x_100);
+if (lean_obj_tag(x_100) == 0)
+{
+lean_object* x_101; lean_object* x_102; 
+x_101 = lean_ctor_get(x_99, 0);
+lean_inc(x_101);
+x_102 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_101);
+lean_dec(x_101);
+if (lean_obj_tag(x_102) == 2)
+{
+lean_object* x_103; lean_object* x_104; uint8_t x_105; 
+x_103 = lean_ctor_get(x_102, 1);
+lean_inc(x_103);
+lean_dec(x_102);
+x_104 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_105 = lean_string_dec_eq(x_103, x_104);
+lean_dec(x_103);
+if (x_105 == 0)
+{
+lean_object* x_106; lean_object* x_107; 
+x_106 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_107 = l_Lean_Parser_ParserState_mkErrorsAt(x_99, x_106, x_7);
+x_73 = x_107;
+goto block_98;
+}
+else
+{
+x_73 = x_99;
+goto block_98;
+}
+}
+else
+{
+lean_object* x_108; lean_object* x_109; 
+lean_dec(x_102);
+x_108 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_109 = l_Lean_Parser_ParserState_mkErrorsAt(x_99, x_108, x_7);
+x_73 = x_109;
+goto block_98;
+}
+}
+else
 {
 lean_object* x_110; lean_object* x_111; 
-x_110 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_10);
-x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_110, x_10);
-x_76 = x_111;
-goto block_102;
+lean_dec(x_100);
+x_110 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_99, x_110, x_7);
+x_73 = x_111;
+goto block_98;
 }
-else
+block_47:
 {
-x_76 = x_103;
-goto block_102;
-}
-}
-else
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_112; lean_object* x_113; 
-lean_dec(x_106);
-x_112 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_10);
-x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_112, x_10);
-x_76 = x_113;
-goto block_102;
-}
-}
-else
-{
-lean_object* x_114; lean_object* x_115; 
-lean_dec(x_104);
-x_114 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_10);
-x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_114, x_10);
-x_76 = x_115;
-goto block_102;
-}
-block_50:
-{
-lean_object* x_20; 
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_16, 1);
+lean_inc(x_18);
+x_19 = l_Lean_Parser_tokenFn(x_1, x_16);
 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; 
-x_21 = lean_ctor_get(x_19, 1);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_23 = lean_ctor_get(x_22, 3);
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
+lean_dec(x_21);
+if (lean_obj_tag(x_22) == 2)
+{
+lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 1);
 lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
+lean_dec(x_22);
+x_24 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_25 = lean_string_dec_eq(x_23, x_24);
+lean_dec(x_23);
+if (x_25 == 0)
 {
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_26 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18);
+x_28 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+else
 {
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_29 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_dec(x_18);
 x_31 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_18);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_13, x_10);
-lean_dec(x_10);
+x_32 = l_Lean_Parser_ParserState_mkNode(x_19, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
 return x_33;
 }
+}
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_21);
-x_34 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_18);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
-lean_dec(x_10);
-return x_36;
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_22);
+x_34 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_34, x_18);
+x_36 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
 }
 }
 else
 {
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_25);
-x_37 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
-x_39 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_18);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_13, x_10);
-lean_dec(x_10);
-return x_41;
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_20);
+x_39 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_39, x_18);
+x_41 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
 }
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-lean_dec(x_23);
-x_42 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_17);
+lean_dec(x_1);
 x_44 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_18);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_13, x_10);
-lean_dec(x_10);
+x_45 = l_Lean_Parser_ParserState_mkNode(x_16, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
 return x_46;
 }
 }
-else
+block_72:
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_47 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_18);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_13, x_10);
-lean_dec(x_10);
-return x_49;
-}
-}
-block_75:
+lean_object* x_49; 
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
 {
-lean_object* x_52; 
-x_52 = lean_ctor_get(x_51, 3);
-lean_inc(x_52);
-if (lean_obj_tag(x_52) == 0)
-{
-lean_object* x_53; lean_object* x_54; 
-lean_inc(x_2);
+lean_object* x_50; lean_object* x_51; 
 lean_inc(x_1);
-x_53 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_51);
-x_54 = lean_ctor_get(x_53, 3);
+x_50 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_48);
+x_51 = lean_ctor_get(x_50, 3);
+lean_inc(x_51);
+if (lean_obj_tag(x_51) == 0)
+{
+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_50, 0);
+lean_inc(x_52);
+x_53 = lean_array_get_size(x_52);
+lean_dec(x_52);
+x_54 = lean_ctor_get(x_50, 1);
 lean_inc(x_54);
-if (lean_obj_tag(x_54) == 0)
+lean_inc(x_1);
+x_55 = l_Lean_Parser_Term_binderDefault___elambda__1(x_1, x_50);
+x_56 = lean_ctor_get(x_55, 3);
+lean_inc(x_56);
+if (lean_obj_tag(x_56) == 0)
 {
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_55 = lean_ctor_get(x_53, 0);
-lean_inc(x_55);
-x_56 = lean_array_get_size(x_55);
-lean_dec(x_55);
-x_57 = lean_ctor_get(x_53, 1);
-lean_inc(x_57);
-lean_inc(x_2);
-x_58 = l_Lean_Parser_Term_binderDefault___elambda__1(x_1, x_2, x_53);
-x_59 = lean_ctor_get(x_58, 3);
-lean_inc(x_59);
-if (lean_obj_tag(x_59) == 0)
-{
-lean_object* x_60; lean_object* x_61; 
-lean_dec(x_57);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_58, x_60, x_56);
-x_19 = x_61;
-goto block_50;
+lean_object* x_57; lean_object* x_58; 
+lean_dec(x_54);
+x_57 = l_Lean_nullKind;
+x_58 = l_Lean_Parser_ParserState_mkNode(x_55, x_57, x_53);
+x_16 = x_58;
+goto block_47;
 }
 else
 {
-lean_object* x_62; uint8_t x_63; 
+lean_object* x_59; uint8_t x_60; 
+lean_dec(x_56);
+x_59 = lean_ctor_get(x_55, 1);
+lean_inc(x_59);
+x_60 = lean_nat_dec_eq(x_59, x_54);
 lean_dec(x_59);
-x_62 = lean_ctor_get(x_58, 1);
-lean_inc(x_62);
-x_63 = lean_nat_dec_eq(x_62, x_57);
-lean_dec(x_62);
-if (x_63 == 0)
+if (x_60 == 0)
 {
-lean_object* x_64; lean_object* x_65; 
-lean_dec(x_57);
+lean_object* x_61; lean_object* x_62; 
+lean_dec(x_54);
+x_61 = l_Lean_nullKind;
+x_62 = l_Lean_Parser_ParserState_mkNode(x_55, x_61, x_53);
+x_16 = x_62;
+goto block_47;
+}
+else
+{
+lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_63 = l_Lean_Parser_ParserState_restore(x_55, x_53, x_54);
 x_64 = l_Lean_nullKind;
-x_65 = l_Lean_Parser_ParserState_mkNode(x_58, x_64, x_56);
-x_19 = x_65;
-goto block_50;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_53);
+x_16 = x_65;
+goto block_47;
+}
+}
 }
 else
 {
 lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-x_66 = l_Lean_Parser_ParserState_restore(x_58, x_56, x_57);
-x_67 = l_Lean_nullKind;
-x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_56);
-x_19 = x_68;
-goto block_50;
-}
+lean_dec(x_51);
+lean_dec(x_1);
+x_66 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
+x_67 = l_Lean_Parser_ParserState_mkNode(x_50, x_66, x_15);
+x_68 = l_Lean_Parser_mergeOrElseErrors(x_67, x_10, x_7);
+lean_dec(x_7);
+return x_68;
 }
 }
 else
 {
 lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-lean_dec(x_54);
-lean_dec(x_2);
+lean_dec(x_49);
 lean_dec(x_1);
 x_69 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
-x_70 = l_Lean_Parser_ParserState_mkNode(x_53, x_69, x_18);
-x_71 = l_Lean_Parser_mergeOrElseErrors(x_70, x_13, x_10);
-lean_dec(x_10);
+x_70 = l_Lean_Parser_ParserState_mkNode(x_48, x_69, x_15);
+x_71 = l_Lean_Parser_mergeOrElseErrors(x_70, x_10, x_7);
+lean_dec(x_7);
 return x_71;
 }
 }
-else
+block_98:
 {
-lean_object* x_72; lean_object* x_73; lean_object* x_74; 
-lean_dec(x_52);
-lean_dec(x_2);
-lean_dec(x_1);
-x_72 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
-x_73 = l_Lean_Parser_ParserState_mkNode(x_51, x_72, x_18);
-x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_13, x_10);
-lean_dec(x_10);
-return x_74;
-}
-}
-block_102:
+lean_object* x_74; 
+x_74 = lean_ctor_get(x_73, 3);
+lean_inc(x_74);
+if (lean_obj_tag(x_74) == 0)
 {
-lean_object* x_77; 
-x_77 = lean_ctor_get(x_76, 3);
-lean_inc(x_77);
-if (lean_obj_tag(x_77) == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; 
-x_78 = lean_ctor_get(x_76, 0);
-lean_inc(x_78);
-x_79 = lean_array_get_size(x_78);
-lean_dec(x_78);
-x_80 = 0;
-lean_inc(x_2);
+lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; 
+x_75 = lean_ctor_get(x_73, 0);
+lean_inc(x_75);
+x_76 = lean_array_get_size(x_75);
+lean_dec(x_75);
 lean_inc(x_1);
-x_81 = l_Lean_Parser_manyAux___main(x_80, x_5, x_1, x_2, x_76);
-x_82 = l_Lean_nullKind;
-x_83 = l_Lean_Parser_ParserState_mkNode(x_81, x_82, x_79);
-x_84 = lean_ctor_get(x_83, 3);
-lean_inc(x_84);
-if (lean_obj_tag(x_84) == 0)
+x_77 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(x_1, x_73);
+x_78 = l_Lean_nullKind;
+x_79 = l_Lean_Parser_ParserState_mkNode(x_77, x_78, x_76);
+x_80 = lean_ctor_get(x_79, 3);
+lean_inc(x_80);
+if (lean_obj_tag(x_80) == 0)
 {
-lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; 
-x_85 = lean_ctor_get(x_83, 0);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+x_81 = lean_ctor_get(x_79, 0);
+lean_inc(x_81);
+x_82 = lean_array_get_size(x_81);
+lean_dec(x_81);
+x_83 = lean_ctor_get(x_79, 1);
+lean_inc(x_83);
+lean_inc(x_1);
+x_84 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_79);
+x_85 = lean_ctor_get(x_84, 3);
 lean_inc(x_85);
-x_86 = lean_array_get_size(x_85);
+if (lean_obj_tag(x_85) == 0)
+{
+lean_object* x_86; 
+lean_dec(x_83);
+x_86 = l_Lean_Parser_ParserState_mkNode(x_84, x_78, x_82);
+x_48 = x_86;
+goto block_72;
+}
+else
+{
+lean_object* x_87; uint8_t x_88; 
 lean_dec(x_85);
-x_87 = lean_ctor_get(x_83, 1);
+x_87 = lean_ctor_get(x_84, 1);
 lean_inc(x_87);
-lean_inc(x_2);
-lean_inc(x_1);
-x_88 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_2, x_83);
-x_89 = lean_ctor_get(x_88, 3);
-lean_inc(x_89);
-if (lean_obj_tag(x_89) == 0)
-{
-lean_object* x_90; 
+x_88 = lean_nat_dec_eq(x_87, x_83);
 lean_dec(x_87);
-x_90 = l_Lean_Parser_ParserState_mkNode(x_88, x_82, x_86);
-x_51 = x_90;
-goto block_75;
+if (x_88 == 0)
+{
+lean_object* x_89; 
+lean_dec(x_83);
+x_89 = l_Lean_Parser_ParserState_mkNode(x_84, x_78, x_82);
+x_48 = x_89;
+goto block_72;
 }
 else
 {
-lean_object* x_91; uint8_t x_92; 
-lean_dec(x_89);
-x_91 = lean_ctor_get(x_88, 1);
-lean_inc(x_91);
-x_92 = lean_nat_dec_eq(x_91, x_87);
-lean_dec(x_91);
-if (x_92 == 0)
-{
-lean_object* x_93; 
-lean_dec(x_87);
-x_93 = l_Lean_Parser_ParserState_mkNode(x_88, x_82, x_86);
-x_51 = x_93;
-goto block_75;
-}
-else
-{
-lean_object* x_94; lean_object* x_95; 
-x_94 = l_Lean_Parser_ParserState_restore(x_88, x_86, x_87);
-x_95 = l_Lean_Parser_ParserState_mkNode(x_94, x_82, x_86);
-x_51 = x_95;
-goto block_75;
+lean_object* x_90; lean_object* x_91; 
+x_90 = l_Lean_Parser_ParserState_restore(x_84, x_82, x_83);
+x_91 = l_Lean_Parser_ParserState_mkNode(x_90, x_78, x_82);
+x_48 = x_91;
+goto block_72;
 }
 }
 }
 else
 {
-lean_object* x_96; lean_object* x_97; lean_object* x_98; 
-lean_dec(x_84);
-lean_dec(x_2);
+lean_object* x_92; lean_object* x_93; lean_object* x_94; 
+lean_dec(x_80);
 lean_dec(x_1);
-x_96 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
-x_97 = l_Lean_Parser_ParserState_mkNode(x_83, x_96, x_18);
-x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_13, x_10);
-lean_dec(x_10);
-return x_98;
+x_92 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
+x_93 = l_Lean_Parser_ParserState_mkNode(x_79, x_92, x_15);
+x_94 = l_Lean_Parser_mergeOrElseErrors(x_93, x_10, x_7);
+lean_dec(x_7);
+return x_94;
 }
 }
 else
 {
-lean_object* x_99; lean_object* x_100; lean_object* x_101; 
-lean_dec(x_77);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_95; lean_object* x_96; lean_object* x_97; 
+lean_dec(x_74);
 lean_dec(x_1);
-x_99 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
-x_100 = l_Lean_Parser_ParserState_mkNode(x_76, x_99, x_18);
-x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_13, x_10);
-lean_dec(x_10);
-return x_101;
+x_95 = l_Lean_Parser_Command_structExplicitBinder___elambda__1___closed__2;
+x_96 = l_Lean_Parser_ParserState_mkNode(x_73, x_95, x_15);
+x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_10, x_7);
+lean_dec(x_7);
+return x_97;
 }
 }
 }
@@ -12457,7 +12204,7 @@ lean_object* _init_l_Lean_Parser_Command_structExplicitBinder___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_noFirstTokenInfo(x_2);
@@ -12480,7 +12227,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Command_structExplicitBinder___closed__2;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
@@ -12521,7 +12268,7 @@ lean_object* _init_l_Lean_Parser_Command_structExplicitBinder___closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 x_2 = l_Lean_Parser_Command_structExplicitBinder___closed__6;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
@@ -12553,7 +12300,7 @@ lean_object* _init_l_Lean_Parser_Command_structExplicitBinder___closed__10() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structExplicitBinder___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structExplicitBinder___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -12608,333 +12355,317 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_structImplicitBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_structImplicitBinder___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_56; lean_object* x_83; lean_object* x_84; 
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_83 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_84 = lean_ctor_get(x_83, 3);
-lean_inc(x_84);
-if (lean_obj_tag(x_84) == 0)
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_85; lean_object* x_86; 
-x_85 = lean_ctor_get(x_83, 0);
-lean_inc(x_85);
-x_86 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_85);
-lean_dec(x_85);
-if (lean_obj_tag(x_86) == 2)
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
 {
-lean_object* x_87; lean_object* x_88; uint8_t x_89; 
-x_87 = lean_ctor_get(x_86, 1);
-lean_inc(x_87);
-lean_dec(x_86);
-x_88 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
-x_89 = lean_string_dec_eq(x_87, x_88);
-lean_dec(x_87);
-if (x_89 == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_53; lean_object* x_79; lean_object* x_80; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_79 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_80 = lean_ctor_get(x_79, 3);
+lean_inc(x_80);
+if (lean_obj_tag(x_80) == 0)
+{
+lean_object* x_81; lean_object* x_82; 
+x_81 = lean_ctor_get(x_79, 0);
+lean_inc(x_81);
+x_82 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_81);
+lean_dec(x_81);
+if (lean_obj_tag(x_82) == 2)
+{
+lean_object* x_83; lean_object* x_84; uint8_t x_85; 
+x_83 = lean_ctor_get(x_82, 1);
+lean_inc(x_83);
+lean_dec(x_82);
+x_84 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
+x_85 = lean_string_dec_eq(x_83, x_84);
+lean_dec(x_83);
+if (x_85 == 0)
+{
+lean_object* x_86; lean_object* x_87; 
+x_86 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_7);
+x_53 = x_87;
+goto block_78;
+}
+else
+{
+x_53 = x_79;
+goto block_78;
+}
+}
+else
+{
+lean_object* x_88; lean_object* x_89; 
+lean_dec(x_82);
+x_88 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_88, x_7);
+x_53 = x_89;
+goto block_78;
+}
+}
+else
 {
 lean_object* x_90; lean_object* x_91; 
+lean_dec(x_80);
 x_90 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_10);
-x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_90, x_10);
-x_56 = x_91;
-goto block_82;
+lean_inc(x_7);
+x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_90, x_7);
+x_53 = x_91;
+goto block_78;
 }
-else
+block_52:
 {
-x_56 = x_83;
-goto block_82;
-}
-}
-else
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_92; lean_object* x_93; 
-lean_dec(x_86);
-x_92 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_10);
-x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_92, x_10);
-x_56 = x_93;
-goto block_82;
-}
-}
-else
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_94; lean_object* x_95; 
-lean_dec(x_84);
-x_94 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_10);
-x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_94, x_10);
-x_56 = x_95;
-goto block_82;
-}
-block_55:
-{
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_object* x_21; lean_object* x_22; 
-lean_inc(x_2);
-x_21 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_19);
+x_21 = l_Lean_Parser_tokenFn(x_1, x_18);
 x_22 = lean_ctor_get(x_21, 3);
 lean_inc(x_22);
 if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_21, 0);
 lean_inc(x_23);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
+x_24 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_23);
+lean_dec(x_23);
+if (lean_obj_tag(x_24) == 2)
+{
+lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_25 = lean_ctor_get(x_24, 1);
 lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
+lean_dec(x_24);
+x_26 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
+x_27 = lean_string_dec_eq(x_25, x_26);
+lean_dec(x_25);
+if (x_27 == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
-lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_28 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20);
+x_30 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
+}
+else
 {
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_31 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_20);
 x_33 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_18);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_13, x_10);
-lean_dec(x_10);
+x_34 = l_Lean_Parser_ParserState_mkNode(x_21, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
 return x_35;
 }
+}
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_18);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_13, x_10);
-lean_dec(x_10);
-return x_38;
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_24);
+x_36 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_36, x_20);
+x_38 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_39 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
-x_41 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_18);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_13, x_10);
-lean_dec(x_10);
-return x_43;
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_22);
+x_41 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_41, x_20);
+x_43 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_15);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_10, x_7);
+lean_dec(x_7);
+return x_45;
 }
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_25);
-x_44 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_19);
+lean_dec(x_1);
 x_46 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_18);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_13, x_10);
-lean_dec(x_10);
+x_47 = l_Lean_Parser_ParserState_mkNode(x_18, x_46, x_15);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_7);
+lean_dec(x_7);
 return x_48;
 }
 }
 else
 {
 lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_22);
-lean_dec(x_2);
+lean_dec(x_17);
+lean_dec(x_1);
 x_49 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_18);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_13, x_10);
-lean_dec(x_10);
+x_50 = l_Lean_Parser_ParserState_mkNode(x_16, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
 return x_51;
 }
 }
-else
+block_78:
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_52 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_19, x_52, x_18);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_13, x_10);
-lean_dec(x_10);
-return x_54;
-}
-}
-block_82:
+lean_object* x_54; 
+x_54 = lean_ctor_get(x_53, 3);
+lean_inc(x_54);
+if (lean_obj_tag(x_54) == 0)
 {
-lean_object* x_57; 
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_58 = lean_ctor_get(x_56, 0);
-lean_inc(x_58);
-x_59 = lean_array_get_size(x_58);
-lean_dec(x_58);
-x_60 = 0;
-lean_inc(x_2);
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_55 = lean_ctor_get(x_53, 0);
+lean_inc(x_55);
+x_56 = lean_array_get_size(x_55);
+lean_dec(x_55);
 lean_inc(x_1);
-x_61 = l_Lean_Parser_manyAux___main(x_60, x_5, x_1, x_2, x_56);
-x_62 = l_Lean_nullKind;
-x_63 = l_Lean_Parser_ParserState_mkNode(x_61, x_62, x_59);
-x_64 = lean_ctor_get(x_63, 3);
-lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
+x_57 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(x_1, x_53);
+x_58 = l_Lean_nullKind;
+x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_56);
+x_60 = lean_ctor_get(x_59, 3);
+lean_inc(x_60);
+if (lean_obj_tag(x_60) == 0)
 {
-lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-x_65 = lean_ctor_get(x_63, 0);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_61 = lean_ctor_get(x_59, 0);
+lean_inc(x_61);
+x_62 = lean_array_get_size(x_61);
+lean_dec(x_61);
+x_63 = lean_ctor_get(x_59, 1);
+lean_inc(x_63);
+lean_inc(x_1);
+x_64 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_59);
+x_65 = lean_ctor_get(x_64, 3);
 lean_inc(x_65);
-x_66 = lean_array_get_size(x_65);
+if (lean_obj_tag(x_65) == 0)
+{
+lean_object* x_66; 
+lean_dec(x_63);
+x_66 = l_Lean_Parser_ParserState_mkNode(x_64, x_58, x_62);
+x_16 = x_66;
+goto block_52;
+}
+else
+{
+lean_object* x_67; uint8_t x_68; 
 lean_dec(x_65);
-x_67 = lean_ctor_get(x_63, 1);
+x_67 = lean_ctor_get(x_64, 1);
 lean_inc(x_67);
-lean_inc(x_2);
-lean_inc(x_1);
-x_68 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_2, x_63);
-x_69 = lean_ctor_get(x_68, 3);
-lean_inc(x_69);
-if (lean_obj_tag(x_69) == 0)
-{
-lean_object* x_70; 
+x_68 = lean_nat_dec_eq(x_67, x_63);
 lean_dec(x_67);
-x_70 = l_Lean_Parser_ParserState_mkNode(x_68, x_62, x_66);
-x_19 = x_70;
-goto block_55;
+if (x_68 == 0)
+{
+lean_object* x_69; 
+lean_dec(x_63);
+x_69 = l_Lean_Parser_ParserState_mkNode(x_64, x_58, x_62);
+x_16 = x_69;
+goto block_52;
 }
 else
 {
-lean_object* x_71; uint8_t x_72; 
-lean_dec(x_69);
-x_71 = lean_ctor_get(x_68, 1);
-lean_inc(x_71);
-x_72 = lean_nat_dec_eq(x_71, x_67);
-lean_dec(x_71);
-if (x_72 == 0)
-{
-lean_object* x_73; 
-lean_dec(x_67);
-x_73 = l_Lean_Parser_ParserState_mkNode(x_68, x_62, x_66);
-x_19 = x_73;
-goto block_55;
-}
-else
-{
-lean_object* x_74; lean_object* x_75; 
-x_74 = l_Lean_Parser_ParserState_restore(x_68, x_66, x_67);
-x_75 = l_Lean_Parser_ParserState_mkNode(x_74, x_62, x_66);
-x_19 = x_75;
-goto block_55;
+lean_object* x_70; lean_object* x_71; 
+x_70 = l_Lean_Parser_ParserState_restore(x_64, x_62, x_63);
+x_71 = l_Lean_Parser_ParserState_mkNode(x_70, x_58, x_62);
+x_16 = x_71;
+goto block_52;
 }
 }
 }
 else
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; 
-lean_dec(x_64);
-lean_dec(x_2);
+lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+lean_dec(x_60);
 lean_dec(x_1);
-x_76 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
-x_77 = l_Lean_Parser_ParserState_mkNode(x_63, x_76, x_18);
-x_78 = l_Lean_Parser_mergeOrElseErrors(x_77, x_13, x_10);
-lean_dec(x_10);
-return x_78;
+x_72 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_59, x_72, x_15);
+x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_10, x_7);
+lean_dec(x_7);
+return x_74;
 }
 }
 else
 {
-lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-lean_dec(x_57);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_75; lean_object* x_76; lean_object* x_77; 
+lean_dec(x_54);
 lean_dec(x_1);
-x_79 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
-x_80 = l_Lean_Parser_ParserState_mkNode(x_56, x_79, x_18);
-x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_13, x_10);
-lean_dec(x_10);
-return x_81;
+x_75 = l_Lean_Parser_Command_structImplicitBinder___elambda__1___closed__2;
+x_76 = l_Lean_Parser_ParserState_mkNode(x_53, x_75, x_15);
+x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_10, x_7);
+lean_dec(x_7);
+return x_77;
 }
 }
 }
@@ -13009,7 +12740,7 @@ lean_object* _init_l_Lean_Parser_Command_structImplicitBinder___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structImplicitBinder___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structImplicitBinder___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -13064,333 +12795,317 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_structInstBinder___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_structInstBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_structInstBinder___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_56; lean_object* x_83; lean_object* x_84; 
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_83 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_84 = lean_ctor_get(x_83, 3);
-lean_inc(x_84);
-if (lean_obj_tag(x_84) == 0)
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_85; lean_object* x_86; 
-x_85 = lean_ctor_get(x_83, 0);
-lean_inc(x_85);
-x_86 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_85);
-lean_dec(x_85);
-if (lean_obj_tag(x_86) == 2)
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
 {
-lean_object* x_87; lean_object* x_88; uint8_t x_89; 
-x_87 = lean_ctor_get(x_86, 1);
-lean_inc(x_87);
-lean_dec(x_86);
-x_88 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
-x_89 = lean_string_dec_eq(x_87, x_88);
-lean_dec(x_87);
-if (x_89 == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_53; lean_object* x_79; lean_object* x_80; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_79 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_80 = lean_ctor_get(x_79, 3);
+lean_inc(x_80);
+if (lean_obj_tag(x_80) == 0)
+{
+lean_object* x_81; lean_object* x_82; 
+x_81 = lean_ctor_get(x_79, 0);
+lean_inc(x_81);
+x_82 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_81);
+lean_dec(x_81);
+if (lean_obj_tag(x_82) == 2)
+{
+lean_object* x_83; lean_object* x_84; uint8_t x_85; 
+x_83 = lean_ctor_get(x_82, 1);
+lean_inc(x_83);
+lean_dec(x_82);
+x_84 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
+x_85 = lean_string_dec_eq(x_83, x_84);
+lean_dec(x_83);
+if (x_85 == 0)
+{
+lean_object* x_86; lean_object* x_87; 
+x_86 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+lean_inc(x_7);
+x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_7);
+x_53 = x_87;
+goto block_78;
+}
+else
+{
+x_53 = x_79;
+goto block_78;
+}
+}
+else
+{
+lean_object* x_88; lean_object* x_89; 
+lean_dec(x_82);
+x_88 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+lean_inc(x_7);
+x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_88, x_7);
+x_53 = x_89;
+goto block_78;
+}
+}
+else
 {
 lean_object* x_90; lean_object* x_91; 
+lean_dec(x_80);
 x_90 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_10);
-x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_90, x_10);
-x_56 = x_91;
-goto block_82;
+lean_inc(x_7);
+x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_90, x_7);
+x_53 = x_91;
+goto block_78;
 }
-else
+block_52:
 {
-x_56 = x_83;
-goto block_82;
-}
-}
-else
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_92; lean_object* x_93; 
-lean_dec(x_86);
-x_92 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_10);
-x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_92, x_10);
-x_56 = x_93;
-goto block_82;
-}
-}
-else
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_94; lean_object* x_95; 
-lean_dec(x_84);
-x_94 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_10);
-x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_94, x_10);
-x_56 = x_95;
-goto block_82;
-}
-block_55:
-{
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_object* x_21; lean_object* x_22; 
-lean_inc(x_2);
-x_21 = l_Lean_Parser_Command_optDeclSig___elambda__1(x_1, x_2, x_19);
+x_21 = l_Lean_Parser_tokenFn(x_1, x_18);
 x_22 = lean_ctor_get(x_21, 3);
 lean_inc(x_22);
 if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_21, 0);
 lean_inc(x_23);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
+x_24 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_23);
+lean_dec(x_23);
+if (lean_obj_tag(x_24) == 2)
+{
+lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_25 = lean_ctor_get(x_24, 1);
 lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
+lean_dec(x_24);
+x_26 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
+x_27 = lean_string_dec_eq(x_25, x_26);
+lean_dec(x_25);
+if (x_27 == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
-lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_28 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20);
+x_30 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
+}
+else
 {
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_31 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_20);
 x_33 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_18);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_13, x_10);
-lean_dec(x_10);
+x_34 = l_Lean_Parser_ParserState_mkNode(x_21, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
 return x_35;
 }
+}
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_18);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_13, x_10);
-lean_dec(x_10);
-return x_38;
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_24);
+x_36 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_36, x_20);
+x_38 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_39 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
-x_41 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_18);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_13, x_10);
-lean_dec(x_10);
-return x_43;
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_22);
+x_41 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_41, x_20);
+x_43 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_15);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_10, x_7);
+lean_dec(x_7);
+return x_45;
 }
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_25);
-x_44 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_19);
+lean_dec(x_1);
 x_46 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_18);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_13, x_10);
-lean_dec(x_10);
+x_47 = l_Lean_Parser_ParserState_mkNode(x_18, x_46, x_15);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_7);
+lean_dec(x_7);
 return x_48;
 }
 }
 else
 {
 lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_22);
-lean_dec(x_2);
+lean_dec(x_17);
+lean_dec(x_1);
 x_49 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_18);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_13, x_10);
-lean_dec(x_10);
+x_50 = l_Lean_Parser_ParserState_mkNode(x_16, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
 return x_51;
 }
 }
-else
+block_78:
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_52 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_19, x_52, x_18);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_13, x_10);
-lean_dec(x_10);
-return x_54;
-}
-}
-block_82:
+lean_object* x_54; 
+x_54 = lean_ctor_get(x_53, 3);
+lean_inc(x_54);
+if (lean_obj_tag(x_54) == 0)
 {
-lean_object* x_57; 
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_58 = lean_ctor_get(x_56, 0);
-lean_inc(x_58);
-x_59 = lean_array_get_size(x_58);
-lean_dec(x_58);
-x_60 = 0;
-lean_inc(x_2);
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_55 = lean_ctor_get(x_53, 0);
+lean_inc(x_55);
+x_56 = lean_array_get_size(x_55);
+lean_dec(x_55);
 lean_inc(x_1);
-x_61 = l_Lean_Parser_manyAux___main(x_60, x_5, x_1, x_2, x_56);
-x_62 = l_Lean_nullKind;
-x_63 = l_Lean_Parser_ParserState_mkNode(x_61, x_62, x_59);
-x_64 = lean_ctor_get(x_63, 3);
-lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
+x_57 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(x_1, x_53);
+x_58 = l_Lean_nullKind;
+x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_56);
+x_60 = lean_ctor_get(x_59, 3);
+lean_inc(x_60);
+if (lean_obj_tag(x_60) == 0)
 {
-lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-x_65 = lean_ctor_get(x_63, 0);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_61 = lean_ctor_get(x_59, 0);
+lean_inc(x_61);
+x_62 = lean_array_get_size(x_61);
+lean_dec(x_61);
+x_63 = lean_ctor_get(x_59, 1);
+lean_inc(x_63);
+lean_inc(x_1);
+x_64 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_59);
+x_65 = lean_ctor_get(x_64, 3);
 lean_inc(x_65);
-x_66 = lean_array_get_size(x_65);
+if (lean_obj_tag(x_65) == 0)
+{
+lean_object* x_66; 
+lean_dec(x_63);
+x_66 = l_Lean_Parser_ParserState_mkNode(x_64, x_58, x_62);
+x_16 = x_66;
+goto block_52;
+}
+else
+{
+lean_object* x_67; uint8_t x_68; 
 lean_dec(x_65);
-x_67 = lean_ctor_get(x_63, 1);
+x_67 = lean_ctor_get(x_64, 1);
 lean_inc(x_67);
-lean_inc(x_2);
-lean_inc(x_1);
-x_68 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_2, x_63);
-x_69 = lean_ctor_get(x_68, 3);
-lean_inc(x_69);
-if (lean_obj_tag(x_69) == 0)
-{
-lean_object* x_70; 
+x_68 = lean_nat_dec_eq(x_67, x_63);
 lean_dec(x_67);
-x_70 = l_Lean_Parser_ParserState_mkNode(x_68, x_62, x_66);
-x_19 = x_70;
-goto block_55;
+if (x_68 == 0)
+{
+lean_object* x_69; 
+lean_dec(x_63);
+x_69 = l_Lean_Parser_ParserState_mkNode(x_64, x_58, x_62);
+x_16 = x_69;
+goto block_52;
 }
 else
 {
-lean_object* x_71; uint8_t x_72; 
-lean_dec(x_69);
-x_71 = lean_ctor_get(x_68, 1);
-lean_inc(x_71);
-x_72 = lean_nat_dec_eq(x_71, x_67);
-lean_dec(x_71);
-if (x_72 == 0)
-{
-lean_object* x_73; 
-lean_dec(x_67);
-x_73 = l_Lean_Parser_ParserState_mkNode(x_68, x_62, x_66);
-x_19 = x_73;
-goto block_55;
-}
-else
-{
-lean_object* x_74; lean_object* x_75; 
-x_74 = l_Lean_Parser_ParserState_restore(x_68, x_66, x_67);
-x_75 = l_Lean_Parser_ParserState_mkNode(x_74, x_62, x_66);
-x_19 = x_75;
-goto block_55;
+lean_object* x_70; lean_object* x_71; 
+x_70 = l_Lean_Parser_ParserState_restore(x_64, x_62, x_63);
+x_71 = l_Lean_Parser_ParserState_mkNode(x_70, x_58, x_62);
+x_16 = x_71;
+goto block_52;
 }
 }
 }
 else
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; 
-lean_dec(x_64);
-lean_dec(x_2);
+lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+lean_dec(x_60);
 lean_dec(x_1);
-x_76 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
-x_77 = l_Lean_Parser_ParserState_mkNode(x_63, x_76, x_18);
-x_78 = l_Lean_Parser_mergeOrElseErrors(x_77, x_13, x_10);
-lean_dec(x_10);
-return x_78;
+x_72 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_59, x_72, x_15);
+x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_10, x_7);
+lean_dec(x_7);
+return x_74;
 }
 }
 else
 {
-lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-lean_dec(x_57);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_75; lean_object* x_76; lean_object* x_77; 
+lean_dec(x_54);
 lean_dec(x_1);
-x_79 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
-x_80 = l_Lean_Parser_ParserState_mkNode(x_56, x_79, x_18);
-x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_13, x_10);
-lean_dec(x_10);
-return x_81;
+x_75 = l_Lean_Parser_Command_structInstBinder___elambda__1___closed__2;
+x_76 = l_Lean_Parser_ParserState_mkNode(x_53, x_75, x_15);
+x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_10, x_7);
+lean_dec(x_7);
+return x_77;
 }
 }
 }
@@ -13465,7 +13180,7 @@ lean_object* _init_l_Lean_Parser_Command_structInstBinder___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structInstBinder___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structInstBinder___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -13489,151 +13204,146 @@ x_1 = l_Lean_Parser_Command_structInstBinder___closed__8;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structFields___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structFields___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_19; lean_object* x_20; 
-x_5 = lean_ctor_get(x_4, 0);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_17; lean_object* x_18; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-lean_inc(x_3);
-lean_inc(x_2);
-x_19 = l_Lean_Parser_Command_structExplicitBinder___elambda__1(x_2, x_3, x_4);
-x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_1);
+x_17 = l_Lean_Parser_Command_structExplicitBinder___elambda__1(x_1, x_2);
+x_18 = lean_ctor_get(x_17, 3);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
+{
+x_6 = x_17;
+goto block_16;
+}
+else
+{
+lean_object* x_19; lean_object* x_20; uint8_t x_21; 
+x_19 = lean_ctor_get(x_18, 0);
+lean_inc(x_19);
+lean_dec(x_18);
+x_20 = lean_ctor_get(x_17, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-x_8 = x_19;
-goto block_18;
-}
-else
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 0);
-lean_inc(x_21);
+x_21 = lean_nat_dec_eq(x_20, x_5);
 lean_dec(x_20);
-x_22 = lean_ctor_get(x_19, 1);
-lean_inc(x_22);
-x_23 = lean_nat_dec_eq(x_22, x_7);
-lean_dec(x_22);
-if (x_23 == 0)
+if (x_21 == 0)
 {
-lean_dec(x_21);
-x_8 = x_19;
-goto block_18;
+lean_dec(x_19);
+x_6 = x_17;
+goto block_16;
 }
 else
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-lean_inc(x_7);
-x_24 = l_Lean_Parser_ParserState_restore(x_19, x_6, x_7);
-x_25 = lean_ctor_get(x_24, 0);
-lean_inc(x_25);
-x_26 = lean_array_get_size(x_25);
-lean_dec(x_25);
-lean_inc(x_3);
-lean_inc(x_2);
-x_27 = l_Lean_Parser_Command_structImplicitBinder___elambda__1(x_2, x_3, x_24);
-x_28 = lean_ctor_get(x_27, 3);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_inc(x_5);
+x_22 = l_Lean_Parser_ParserState_restore(x_17, x_4, x_5);
+x_23 = lean_ctor_get(x_22, 0);
+lean_inc(x_23);
+x_24 = lean_array_get_size(x_23);
+lean_dec(x_23);
+lean_inc(x_1);
+x_25 = l_Lean_Parser_Command_structImplicitBinder___elambda__1(x_1, x_22);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
+{
+lean_object* x_27; 
+lean_dec(x_24);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_25, x_19, x_5);
+x_6 = x_27;
+goto block_16;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; uint8_t x_30; 
+x_28 = lean_ctor_get(x_26, 0);
 lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; 
 lean_dec(x_26);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_27, x_21, x_7);
-x_8 = x_29;
-goto block_18;
-}
-else
+x_29 = lean_ctor_get(x_25, 1);
+lean_inc(x_29);
+x_30 = lean_nat_dec_eq(x_29, x_5);
+lean_dec(x_29);
+if (x_30 == 0)
 {
-lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_30 = lean_ctor_get(x_28, 0);
-lean_inc(x_30);
+lean_object* x_31; 
 lean_dec(x_28);
-x_31 = lean_ctor_get(x_27, 1);
-lean_inc(x_31);
-x_32 = lean_nat_dec_eq(x_31, x_7);
-lean_dec(x_31);
-if (x_32 == 0)
-{
-lean_object* x_33; 
-lean_dec(x_30);
-lean_dec(x_26);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_27, x_21, x_7);
-x_8 = x_33;
-goto block_18;
+lean_dec(x_24);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_25, x_19, x_5);
+x_6 = x_31;
+goto block_16;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_inc(x_5);
+x_32 = l_Lean_Parser_ParserState_restore(x_25, x_24, x_5);
+lean_dec(x_24);
+lean_inc(x_1);
+x_33 = l_Lean_Parser_Command_structInstBinder___elambda__1(x_1, x_32);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_28, x_5);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_19, x_5);
+x_6 = x_35;
+goto block_16;
+}
+}
+}
+}
+block_16:
+{
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_6, 3);
 lean_inc(x_7);
-x_34 = l_Lean_Parser_ParserState_restore(x_27, x_26, x_7);
-lean_dec(x_26);
-lean_inc(x_3);
-lean_inc(x_2);
-x_35 = l_Lean_Parser_Command_structInstBinder___elambda__1(x_2, x_3, x_34);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_30, x_7);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_21, x_7);
-x_8 = x_37;
-goto block_18;
-}
-}
-}
-}
-block_18:
+if (lean_obj_tag(x_7) == 0)
 {
-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_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
+lean_dec(x_5);
+if (x_9 == 0)
 {
-lean_object* x_10; uint8_t x_11; 
-lean_dec(x_6);
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_7, x_10);
-lean_dec(x_10);
-lean_dec(x_7);
-if (x_11 == 0)
-{
-x_4 = x_8;
+x_2 = x_6;
 goto _start;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_13 = l_Lean_Parser_manyAux___main___closed__1;
-x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
-return x_14;
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_15; uint8_t x_16; 
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_15 = lean_ctor_get(x_8, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_7, x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+lean_object* x_13; uint8_t x_14; 
 lean_dec(x_7);
-lean_dec(x_6);
-return x_8;
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_17;
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+return x_15;
 }
 }
 }
@@ -13670,80 +13380,75 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_structFields___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_structFields___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_structFields___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_structFields___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_structFields___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_structFields___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_structFields___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_structFields___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_structFields___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t 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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structFields___elambda__1___spec__1(x_1, x_13);
+x_17 = l_Lean_nullKind;
 lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = 0;
-x_18 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structFields___elambda__1___spec__1(x_17, x_1, x_2, x_14);
-x_19 = l_Lean_nullKind;
-lean_inc(x_16);
-x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_16);
-x_21 = l_Lean_Parser_Command_structFields___elambda__1___closed__2;
-x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_16);
-x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_11, x_8);
-lean_dec(x_8);
-return x_23;
+x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_15);
+x_19 = l_Lean_Parser_Command_structFields___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
 }
 }
 }
@@ -13809,7 +13514,7 @@ lean_object* _init_l_Lean_Parser_Command_structFields___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structFields___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structFields___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -13833,16 +13538,6 @@ x_1 = l_Lean_Parser_Command_structFields___closed__7;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structFields___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structFields___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-return x_6;
-}
-}
 lean_object* _init_l_Lean_Parser_Command_structCtor___elambda__1___closed__1() {
 _start:
 {
@@ -13874,13 +13569,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_structCtor___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_structCtor___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_structCtor___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_structCtor___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_structCtor___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_structCtor___elambda__1___closed__5() {
@@ -13924,220 +13618,210 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_structCtor___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_structCtor___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_structCtor___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_structCtor___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_48; lean_object* x_49; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_51; lean_object* x_52; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
 lean_inc(x_1);
-x_51 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_52 = lean_ctor_get(x_51, 3);
+x_48 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_50 = lean_ctor_get(x_48, 0);
+lean_inc(x_50);
+x_51 = lean_array_get_size(x_50);
+lean_dec(x_50);
+x_52 = lean_ctor_get(x_48, 1);
 lean_inc(x_52);
-if (lean_obj_tag(x_52) == 0)
+lean_inc(x_1);
+x_53 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_48);
+x_54 = lean_ctor_get(x_53, 3);
+lean_inc(x_54);
+if (lean_obj_tag(x_54) == 0)
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-x_53 = lean_ctor_get(x_51, 0);
-lean_inc(x_53);
-x_54 = lean_array_get_size(x_53);
-lean_dec(x_53);
-x_55 = lean_ctor_get(x_51, 1);
-lean_inc(x_55);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_Command_inferMod___elambda__1(x_1, x_2, x_51);
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-lean_dec(x_55);
-x_58 = l_Lean_nullKind;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_56, x_58, x_54);
-x_19 = x_59;
-goto block_50;
+lean_object* x_55; lean_object* x_56; 
+lean_dec(x_52);
+x_55 = l_Lean_nullKind;
+x_56 = l_Lean_Parser_ParserState_mkNode(x_53, x_55, x_51);
+x_16 = x_56;
+goto block_47;
 }
 else
 {
-lean_object* x_60; uint8_t x_61; 
+lean_object* x_57; uint8_t x_58; 
+lean_dec(x_54);
+x_57 = lean_ctor_get(x_53, 1);
+lean_inc(x_57);
+x_58 = lean_nat_dec_eq(x_57, x_52);
 lean_dec(x_57);
-x_60 = lean_ctor_get(x_56, 1);
-lean_inc(x_60);
-x_61 = lean_nat_dec_eq(x_60, x_55);
-lean_dec(x_60);
-if (x_61 == 0)
+if (x_58 == 0)
 {
-lean_object* x_62; lean_object* x_63; 
-lean_dec(x_55);
+lean_object* x_59; lean_object* x_60; 
+lean_dec(x_52);
+x_59 = l_Lean_nullKind;
+x_60 = l_Lean_Parser_ParserState_mkNode(x_53, x_59, x_51);
+x_16 = x_60;
+goto block_47;
+}
+else
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_61 = l_Lean_Parser_ParserState_restore(x_53, x_51, x_52);
 x_62 = l_Lean_nullKind;
-x_63 = l_Lean_Parser_ParserState_mkNode(x_56, x_62, x_54);
-x_19 = x_63;
-goto block_50;
+x_63 = l_Lean_Parser_ParserState_mkNode(x_61, x_62, x_51);
+x_16 = x_63;
+goto block_47;
+}
+}
 }
 else
 {
 lean_object* x_64; lean_object* x_65; lean_object* x_66; 
-x_64 = l_Lean_Parser_ParserState_restore(x_56, x_54, x_55);
-x_65 = l_Lean_nullKind;
-x_66 = l_Lean_Parser_ParserState_mkNode(x_64, x_65, x_54);
-x_19 = x_66;
-goto block_50;
-}
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-lean_dec(x_52);
-lean_dec(x_2);
+lean_dec(x_49);
 lean_dec(x_1);
-x_67 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
-x_68 = l_Lean_Parser_ParserState_mkNode(x_51, x_67, x_18);
-x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_13, x_10);
-lean_dec(x_10);
-return x_69;
+x_64 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_48, x_64, x_15);
+x_66 = l_Lean_Parser_mergeOrElseErrors(x_65, x_10, x_7);
+lean_dec(x_7);
+return x_66;
 }
-block_50:
+block_47:
 {
-lean_object* x_20; 
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_16, 1);
+lean_inc(x_18);
+x_19 = l_Lean_Parser_tokenFn(x_1, x_16);
 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; 
-x_21 = lean_ctor_get(x_19, 1);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_23 = lean_ctor_get(x_22, 3);
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
+lean_dec(x_21);
+if (lean_obj_tag(x_22) == 2)
+{
+lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 1);
 lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
+lean_dec(x_22);
+x_24 = l_Lean_Parser_Command_structCtor___elambda__1___closed__5;
+x_25 = lean_string_dec_eq(x_23, x_24);
+lean_dec(x_23);
+if (x_25 == 0)
 {
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_26 = l_Lean_Parser_Command_structCtor___elambda__1___closed__8;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18);
+x_28 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+else
 {
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l_Lean_Parser_Command_structCtor___elambda__1___closed__5;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_29 = l_Lean_Parser_Command_structCtor___elambda__1___closed__8;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_dec(x_18);
 x_31 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_18);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_13, x_10);
-lean_dec(x_10);
+x_32 = l_Lean_Parser_ParserState_mkNode(x_19, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
 return x_33;
 }
+}
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_21);
-x_34 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_18);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
-lean_dec(x_10);
-return x_36;
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_22);
+x_34 = l_Lean_Parser_Command_structCtor___elambda__1___closed__8;
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_34, x_18);
+x_36 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
 }
 }
 else
 {
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_25);
-x_37 = l_Lean_Parser_Command_structCtor___elambda__1___closed__8;
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
-x_39 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_18);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_13, x_10);
-lean_dec(x_10);
-return x_41;
-}
-}
-else
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-lean_dec(x_23);
-x_42 = l_Lean_Parser_Command_structCtor___elambda__1___closed__8;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
-x_44 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_18);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_13, x_10);
-lean_dec(x_10);
-return x_46;
-}
-}
-else
-{
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
 lean_dec(x_20);
-lean_dec(x_2);
-x_47 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_18);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_13, x_10);
-lean_dec(x_10);
-return x_49;
+x_39 = l_Lean_Parser_Command_structCtor___elambda__1___closed__8;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_39, x_18);
+x_41 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_44 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_16, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
 }
 }
 }
@@ -14168,7 +13852,7 @@ lean_object* _init_l_Lean_Parser_Command_structCtor___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_structCtor___closed__2;
@@ -14202,7 +13886,7 @@ lean_object* _init_l_Lean_Parser_Command_structCtor___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structCtor___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structCtor___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -14257,13 +13941,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_structureTk___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_structureTk___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_structureTk___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_structureTk___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_structureTk___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_structureTk___elambda__1___closed__5() {
@@ -14315,125 +13998,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_structureTk___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_structureTk___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_structureTk___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_structureTk___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_structureTk___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_structureTk___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_structureTk___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_structureTk___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_structureTk___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_structureTk___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_structureTk___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_structureTk___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_structureTk___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_structureTk___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_structureTk___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_structureTk___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_structureTk___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_structureTk___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_structureTk___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_structureTk___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -14475,7 +14158,7 @@ lean_object* _init_l_Lean_Parser_Command_structureTk___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structureTk___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structureTk___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -14530,134 +14213,133 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_classTk___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_classTk___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_classTk___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_classTk___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_classTk___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_classTk___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_classTk___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_classTk___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_classTk___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_classInductive___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_classTk___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_classTk___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_classTk___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_classTk___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_classInductive___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_classTk___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_classTk___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_classTk___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_classInductive___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_classTk___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -14689,7 +14371,7 @@ lean_object* _init_l_Lean_Parser_Command_classTk___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_classTk___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_classTk___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -14744,13 +14426,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_extends___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_extends___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_extends___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_extends___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_extends___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_extends___elambda__1___closed__5() {
@@ -14802,146 +14483,140 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_extends___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_extends___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_extends___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_extends___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
-lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_27; lean_object* x_28; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_27 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_28 = lean_ctor_get(x_27, 3);
+lean_inc(x_28);
+if (lean_obj_tag(x_28) == 0)
 {
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
+lean_object* x_29; lean_object* x_30; 
+x_29 = lean_ctor_get(x_27, 0);
+lean_inc(x_29);
+x_30 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_29);
+lean_dec(x_29);
+if (lean_obj_tag(x_30) == 2)
+{
+lean_object* x_31; lean_object* x_32; uint8_t x_33; 
+x_31 = lean_ctor_get(x_30, 1);
 lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
+lean_dec(x_30);
+x_32 = l_Lean_Parser_Command_extends___elambda__1___closed__6;
+x_33 = lean_string_dec_eq(x_31, x_32);
 lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
+if (x_33 == 0)
 {
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Command_extends___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
+lean_object* x_34; lean_object* x_35; 
+x_34 = l_Lean_Parser_Command_extends___elambda__1___closed__9;
+lean_inc(x_7);
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_7);
+x_16 = x_35;
+goto block_26;
+}
+else
+{
+x_16 = x_27;
+goto block_26;
+}
+}
+else
 {
 lean_object* x_36; lean_object* x_37; 
+lean_dec(x_30);
 x_36 = l_Lean_Parser_Command_extends___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_36, x_7);
+x_16 = x_37;
+goto block_26;
 }
 }
 else
 {
 lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
+lean_dec(x_28);
 x_38 = l_Lean_Parser_Command_extends___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
+lean_inc(x_7);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_38, x_7);
+x_16 = x_39;
+goto block_26;
 }
+block_26:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = 0;
+x_19 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_18, x_18, x_1, x_16);
+x_20 = l_Lean_Parser_Command_extends___elambda__1___closed__2;
+x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_15);
+x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_10, x_7);
+lean_dec(x_7);
+return x_22;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; 
-lean_dec(x_30);
-x_40 = l_Lean_Parser_Command_extends___elambda__1___closed__9;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
-{
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-uint8_t x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = 0;
-x_20 = 0;
-x_21 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_19, x_20, x_20, x_1, x_2, x_17);
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_22 = l_Lean_Parser_Command_extends___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
-}
-else
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_extends___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_23 = l_Lean_Parser_Command_extends___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_16, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 }
 }
@@ -14994,7 +14669,7 @@ lean_object* _init_l_Lean_Parser_Command_extends___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_extends___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_extends___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -15049,463 +14724,442 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_structure___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_structure___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_structure___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_structure___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_structure___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_structure___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_structure___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_structure___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Command_structure___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
+lean_inc(x_1);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
 lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
-lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_63; lean_object* x_88; lean_object* x_120; lean_object* x_121; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_62; lean_object* x_87; lean_object* x_118; lean_object* x_119; 
+lean_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
 lean_inc(x_1);
-x_120 = l_Lean_Parser_Command_structureTk___elambda__1(x_1, x_2, x_16);
-x_121 = lean_ctor_get(x_120, 3);
+x_118 = l_Lean_Parser_Command_structureTk___elambda__1(x_1, x_15);
+x_119 = lean_ctor_get(x_118, 3);
+lean_inc(x_119);
+if (lean_obj_tag(x_119) == 0)
+{
+x_87 = x_118;
+goto block_117;
+}
+else
+{
+lean_object* x_120; lean_object* x_121; uint8_t x_122; 
+x_120 = lean_ctor_get(x_119, 0);
+lean_inc(x_120);
+lean_dec(x_119);
+x_121 = lean_ctor_get(x_118, 1);
 lean_inc(x_121);
-if (lean_obj_tag(x_121) == 0)
-{
-x_88 = x_120;
-goto block_119;
-}
-else
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_121, 0);
-lean_inc(x_122);
+x_122 = lean_nat_dec_eq(x_121, x_9);
 lean_dec(x_121);
-x_123 = lean_ctor_get(x_120, 1);
-lean_inc(x_123);
-x_124 = lean_nat_dec_eq(x_123, x_10);
-lean_dec(x_123);
-if (x_124 == 0)
+if (x_122 == 0)
 {
-lean_dec(x_122);
-x_88 = x_120;
-goto block_119;
+lean_dec(x_120);
+x_87 = x_118;
+goto block_117;
 }
 else
 {
-lean_object* x_125; lean_object* x_126; lean_object* x_127; 
-lean_inc(x_10);
-x_125 = l_Lean_Parser_ParserState_restore(x_120, x_18, x_10);
-lean_inc(x_2);
+lean_object* x_123; lean_object* x_124; lean_object* x_125; 
+lean_inc(x_9);
+x_123 = l_Lean_Parser_ParserState_restore(x_118, x_17, x_9);
 lean_inc(x_1);
-x_126 = l_Lean_Parser_Command_classTk___elambda__1(x_1, x_2, x_125);
-x_127 = l_Lean_Parser_mergeOrElseErrors(x_126, x_122, x_10);
-x_88 = x_127;
-goto block_119;
+x_124 = l_Lean_Parser_Command_classTk___elambda__1(x_1, x_123);
+x_125 = l_Lean_Parser_mergeOrElseErrors(x_124, x_120, x_9);
+x_87 = x_125;
+goto block_117;
 }
 }
-block_62:
+block_61:
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_19; 
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_20 = lean_ctor_get(x_18, 0);
 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_24; lean_object* x_25; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = lean_ctor_get(x_19, 1);
-lean_inc(x_23);
-lean_inc(x_2);
-lean_inc(x_1);
-x_24 = l_Lean_Parser_Command_structCtor___elambda__1(x_1, x_2, x_19);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-lean_dec(x_23);
-x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_22);
-x_28 = lean_ctor_get(x_27, 3);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_29 = l_Lean_Parser_Command_structFields___elambda__1(x_1, x_2, x_27);
-x_30 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_18);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_13, x_10);
-lean_dec(x_10);
-return x_32;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_28);
-lean_dec(x_2);
-lean_dec(x_1);
-x_33 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_18);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_13, x_10);
-lean_dec(x_10);
-return x_35;
-}
-}
-else
-{
-lean_object* x_36; uint8_t x_37; 
-lean_dec(x_25);
-x_36 = lean_ctor_get(x_24, 1);
-lean_inc(x_36);
-x_37 = lean_nat_dec_eq(x_36, x_23);
-lean_dec(x_36);
-if (x_37 == 0)
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-lean_dec(x_23);
-x_38 = l_Lean_nullKind;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_24, x_38, x_22);
-x_40 = lean_ctor_get(x_39, 3);
-lean_inc(x_40);
-if (lean_obj_tag(x_40) == 0)
-{
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_41 = l_Lean_Parser_Command_structFields___elambda__1(x_1, x_2, x_39);
-x_42 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_18);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_13, x_10);
-lean_dec(x_10);
-return x_44;
-}
-else
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-lean_dec(x_2);
-lean_dec(x_1);
-x_45 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_39, x_45, x_18);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_13, x_10);
-lean_dec(x_10);
-return x_47;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-x_48 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
-x_49 = l_Lean_nullKind;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_48, x_49, x_22);
-x_51 = lean_ctor_get(x_50, 3);
-lean_inc(x_51);
-if (lean_obj_tag(x_51) == 0)
-{
-lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_52 = l_Lean_Parser_Command_structFields___elambda__1(x_1, x_2, x_50);
-x_53 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_54 = l_Lean_Parser_ParserState_mkNode(x_52, x_53, x_18);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_13, x_10);
-lean_dec(x_10);
-return x_55;
-}
-else
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-lean_dec(x_51);
-lean_dec(x_2);
-lean_dec(x_1);
-x_56 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_50, x_56, x_18);
-x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_13, x_10);
-lean_dec(x_10);
-return x_58;
-}
-}
-}
-}
-else
-{
-lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+x_21 = lean_array_get_size(x_20);
 lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_59 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_60 = l_Lean_Parser_ParserState_mkNode(x_19, x_59, x_18);
-x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_13, x_10);
-lean_dec(x_10);
-return x_61;
-}
-}
-block_87:
-{
-lean_object* x_64; 
-x_64 = lean_ctor_get(x_63, 3);
-lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
-{
-lean_object* x_65; lean_object* x_66; 
-lean_inc(x_2);
+x_22 = lean_ctor_get(x_18, 1);
+lean_inc(x_22);
 lean_inc(x_1);
-x_65 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_2, x_63);
-x_66 = lean_ctor_get(x_65, 3);
+x_23 = l_Lean_Parser_Command_structCtor___elambda__1(x_1, x_18);
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+lean_dec(x_22);
+x_25 = l_Lean_nullKind;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_23, x_25, x_21);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+x_28 = l_Lean_Parser_Command_structFields___elambda__1(x_1, x_26);
+x_29 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_17);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_12, x_9);
+lean_dec(x_9);
+return x_31;
+}
+else
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_27);
+lean_dec(x_1);
+x_32 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_26, x_32, x_17);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_12, x_9);
+lean_dec(x_9);
+return x_34;
+}
+}
+else
+{
+lean_object* x_35; uint8_t x_36; 
+lean_dec(x_24);
+x_35 = lean_ctor_get(x_23, 1);
+lean_inc(x_35);
+x_36 = lean_nat_dec_eq(x_35, x_22);
+lean_dec(x_35);
+if (x_36 == 0)
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+lean_dec(x_22);
+x_37 = l_Lean_nullKind;
+x_38 = l_Lean_Parser_ParserState_mkNode(x_23, x_37, x_21);
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_40 = l_Lean_Parser_Command_structFields___elambda__1(x_1, x_38);
+x_41 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_17);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_12, x_9);
+lean_dec(x_9);
+return x_43;
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_39);
+lean_dec(x_1);
+x_44 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_38, x_44, x_17);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_12, x_9);
+lean_dec(x_9);
+return x_46;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_47 = l_Lean_Parser_ParserState_restore(x_23, x_21, x_22);
+x_48 = l_Lean_nullKind;
+x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_21);
+x_50 = lean_ctor_get(x_49, 3);
+lean_inc(x_50);
+if (lean_obj_tag(x_50) == 0)
+{
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_51 = l_Lean_Parser_Command_structFields___elambda__1(x_1, x_49);
+x_52 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_51, x_52, x_17);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_12, x_9);
+lean_dec(x_9);
+return x_54;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_dec(x_50);
+lean_dec(x_1);
+x_55 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_56 = l_Lean_Parser_ParserState_mkNode(x_49, x_55, x_17);
+x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_12, x_9);
+lean_dec(x_9);
+return x_57;
+}
+}
+}
+}
+else
+{
+lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_58 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_59 = l_Lean_Parser_ParserState_mkNode(x_18, x_58, x_17);
+x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_12, x_9);
+lean_dec(x_9);
+return x_60;
+}
+}
+block_86:
+{
+lean_object* x_63; 
+x_63 = lean_ctor_get(x_62, 3);
+lean_inc(x_63);
+if (lean_obj_tag(x_63) == 0)
+{
+lean_object* x_64; lean_object* x_65; 
+lean_inc(x_1);
+x_64 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_62);
+x_65 = lean_ctor_get(x_64, 3);
+lean_inc(x_65);
+if (lean_obj_tag(x_65) == 0)
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+x_66 = lean_ctor_get(x_64, 1);
 lean_inc(x_66);
-if (lean_obj_tag(x_66) == 0)
+lean_inc(x_1);
+x_67 = l_Lean_Parser_tokenFn(x_1, x_64);
+x_68 = lean_ctor_get(x_67, 3);
+lean_inc(x_68);
+if (lean_obj_tag(x_68) == 0)
 {
-lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-x_67 = lean_ctor_get(x_65, 1);
-lean_inc(x_67);
-lean_inc(x_2);
-x_68 = l_Lean_Parser_tokenFn(x_2, x_65);
-x_69 = lean_ctor_get(x_68, 3);
+lean_object* x_69; lean_object* x_70; 
+x_69 = lean_ctor_get(x_67, 0);
 lean_inc(x_69);
-if (lean_obj_tag(x_69) == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = lean_ctor_get(x_68, 0);
-lean_inc(x_70);
-x_71 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_70);
-lean_dec(x_70);
-if (lean_obj_tag(x_71) == 2)
-{
-lean_object* x_72; lean_object* x_73; uint8_t x_74; 
-x_72 = lean_ctor_get(x_71, 1);
-lean_inc(x_72);
-lean_dec(x_71);
-x_73 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_74 = lean_string_dec_eq(x_72, x_73);
-lean_dec(x_72);
-if (x_74 == 0)
-{
-lean_object* x_75; lean_object* x_76; 
-x_75 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_75, x_67);
-x_19 = x_76;
-goto block_62;
-}
-else
-{
-lean_dec(x_67);
-x_19 = x_68;
-goto block_62;
-}
-}
-else
-{
-lean_object* x_77; lean_object* x_78; 
-lean_dec(x_71);
-x_77 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_77, x_67);
-x_19 = x_78;
-goto block_62;
-}
-}
-else
-{
-lean_object* x_79; lean_object* x_80; 
+x_70 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_69);
 lean_dec(x_69);
-x_79 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_79, x_67);
-x_19 = x_80;
-goto block_62;
-}
+if (lean_obj_tag(x_70) == 2)
+{
+lean_object* x_71; lean_object* x_72; uint8_t x_73; 
+x_71 = lean_ctor_get(x_70, 1);
+lean_inc(x_71);
+lean_dec(x_70);
+x_72 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
+x_73 = lean_string_dec_eq(x_71, x_72);
+lean_dec(x_71);
+if (x_73 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_74, x_66);
+x_18 = x_75;
+goto block_61;
 }
 else
 {
-lean_object* x_81; lean_object* x_82; lean_object* x_83; 
 lean_dec(x_66);
-lean_dec(x_2);
-lean_dec(x_1);
-x_81 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_82 = l_Lean_Parser_ParserState_mkNode(x_65, x_81, x_18);
-x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_13, x_10);
-lean_dec(x_10);
-return x_83;
+x_18 = x_67;
+goto block_61;
 }
 }
 else
 {
-lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-lean_dec(x_64);
-lean_dec(x_2);
+lean_object* x_76; lean_object* x_77; 
+lean_dec(x_70);
+x_76 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_76, x_66);
+x_18 = x_77;
+goto block_61;
+}
+}
+else
+{
+lean_object* x_78; lean_object* x_79; 
+lean_dec(x_68);
+x_78 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_78, x_66);
+x_18 = x_79;
+goto block_61;
+}
+}
+else
+{
+lean_object* x_80; lean_object* x_81; lean_object* x_82; 
+lean_dec(x_65);
 lean_dec(x_1);
-x_84 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_85 = l_Lean_Parser_ParserState_mkNode(x_63, x_84, x_18);
-x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_13, x_10);
-lean_dec(x_10);
-return x_86;
+x_80 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_81 = l_Lean_Parser_ParserState_mkNode(x_64, x_80, x_17);
+x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_12, x_9);
+lean_dec(x_9);
+return x_82;
 }
 }
-block_119:
+else
 {
-lean_object* x_89; 
-x_89 = lean_ctor_get(x_88, 3);
-lean_inc(x_89);
-if (lean_obj_tag(x_89) == 0)
+lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+lean_dec(x_63);
+lean_dec(x_1);
+x_83 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_84 = l_Lean_Parser_ParserState_mkNode(x_62, x_83, x_17);
+x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_12, x_9);
+lean_dec(x_9);
+return x_85;
+}
+}
+block_117:
 {
-lean_object* x_90; lean_object* x_91; 
-lean_inc(x_2);
+lean_object* x_88; 
+x_88 = lean_ctor_get(x_87, 3);
+lean_inc(x_88);
+if (lean_obj_tag(x_88) == 0)
+{
+lean_object* x_89; lean_object* x_90; 
 lean_inc(x_1);
-x_90 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_2, x_88);
-x_91 = lean_ctor_get(x_90, 3);
+x_89 = l_Lean_Parser_Command_declId___elambda__1(x_1, x_87);
+x_90 = lean_ctor_get(x_89, 3);
+lean_inc(x_90);
+if (lean_obj_tag(x_90) == 0)
+{
+lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; 
+x_91 = lean_ctor_get(x_89, 0);
 lean_inc(x_91);
-if (lean_obj_tag(x_91) == 0)
-{
-lean_object* x_92; lean_object* x_93; uint8_t x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; 
-x_92 = lean_ctor_get(x_90, 0);
-lean_inc(x_92);
-x_93 = lean_array_get_size(x_92);
-lean_dec(x_92);
-x_94 = 0;
-lean_inc(x_2);
-lean_inc(x_1);
-x_95 = l_Lean_Parser_manyAux___main(x_94, x_5, x_1, x_2, x_90);
-x_96 = l_Lean_nullKind;
-x_97 = l_Lean_Parser_ParserState_mkNode(x_95, x_96, x_93);
-x_98 = lean_ctor_get(x_97, 3);
-lean_inc(x_98);
-if (lean_obj_tag(x_98) == 0)
-{
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; 
-x_99 = lean_ctor_get(x_97, 0);
-lean_inc(x_99);
-x_100 = lean_array_get_size(x_99);
-lean_dec(x_99);
-x_101 = lean_ctor_get(x_97, 1);
-lean_inc(x_101);
-lean_inc(x_2);
-lean_inc(x_1);
-x_102 = l_Lean_Parser_Command_extends___elambda__1(x_1, x_2, x_97);
-x_103 = lean_ctor_get(x_102, 3);
-lean_inc(x_103);
-if (lean_obj_tag(x_103) == 0)
-{
-lean_object* x_104; 
-lean_dec(x_101);
-x_104 = l_Lean_Parser_ParserState_mkNode(x_102, x_96, x_100);
-x_63 = x_104;
-goto block_87;
-}
-else
-{
-lean_object* x_105; uint8_t x_106; 
-lean_dec(x_103);
-x_105 = lean_ctor_get(x_102, 1);
-lean_inc(x_105);
-x_106 = lean_nat_dec_eq(x_105, x_101);
-lean_dec(x_105);
-if (x_106 == 0)
-{
-lean_object* x_107; 
-lean_dec(x_101);
-x_107 = l_Lean_Parser_ParserState_mkNode(x_102, x_96, x_100);
-x_63 = x_107;
-goto block_87;
-}
-else
-{
-lean_object* x_108; lean_object* x_109; 
-x_108 = l_Lean_Parser_ParserState_restore(x_102, x_100, x_101);
-x_109 = l_Lean_Parser_ParserState_mkNode(x_108, x_96, x_100);
-x_63 = x_109;
-goto block_87;
-}
-}
-}
-else
-{
-lean_object* x_110; lean_object* x_111; lean_object* x_112; 
-lean_dec(x_98);
-lean_dec(x_2);
-lean_dec(x_1);
-x_110 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_111 = l_Lean_Parser_ParserState_mkNode(x_97, x_110, x_18);
-x_112 = l_Lean_Parser_mergeOrElseErrors(x_111, x_13, x_10);
-lean_dec(x_10);
-return x_112;
-}
-}
-else
-{
-lean_object* x_113; lean_object* x_114; lean_object* x_115; 
+x_92 = lean_array_get_size(x_91);
 lean_dec(x_91);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_113 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_114 = l_Lean_Parser_ParserState_mkNode(x_90, x_113, x_18);
-x_115 = l_Lean_Parser_mergeOrElseErrors(x_114, x_13, x_10);
-lean_dec(x_10);
-return x_115;
+lean_inc(x_1);
+x_93 = l_Lean_Parser_manyAux___main(x_4, x_1, x_89);
+x_94 = l_Lean_nullKind;
+x_95 = l_Lean_Parser_ParserState_mkNode(x_93, x_94, x_92);
+x_96 = lean_ctor_get(x_95, 3);
+lean_inc(x_96);
+if (lean_obj_tag(x_96) == 0)
+{
+lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; 
+x_97 = lean_ctor_get(x_95, 0);
+lean_inc(x_97);
+x_98 = lean_array_get_size(x_97);
+lean_dec(x_97);
+x_99 = lean_ctor_get(x_95, 1);
+lean_inc(x_99);
+lean_inc(x_1);
+x_100 = l_Lean_Parser_Command_extends___elambda__1(x_1, x_95);
+x_101 = lean_ctor_get(x_100, 3);
+lean_inc(x_101);
+if (lean_obj_tag(x_101) == 0)
+{
+lean_object* x_102; 
+lean_dec(x_99);
+x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_94, x_98);
+x_62 = x_102;
+goto block_86;
+}
+else
+{
+lean_object* x_103; uint8_t x_104; 
+lean_dec(x_101);
+x_103 = lean_ctor_get(x_100, 1);
+lean_inc(x_103);
+x_104 = lean_nat_dec_eq(x_103, x_99);
+lean_dec(x_103);
+if (x_104 == 0)
+{
+lean_object* x_105; 
+lean_dec(x_99);
+x_105 = l_Lean_Parser_ParserState_mkNode(x_100, x_94, x_98);
+x_62 = x_105;
+goto block_86;
+}
+else
+{
+lean_object* x_106; lean_object* x_107; 
+x_106 = l_Lean_Parser_ParserState_restore(x_100, x_98, x_99);
+x_107 = l_Lean_Parser_ParserState_mkNode(x_106, x_94, x_98);
+x_62 = x_107;
+goto block_86;
+}
 }
 }
 else
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; 
-lean_dec(x_89);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_108; lean_object* x_109; lean_object* x_110; 
+lean_dec(x_96);
 lean_dec(x_1);
-x_116 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
-x_117 = l_Lean_Parser_ParserState_mkNode(x_88, x_116, x_18);
-x_118 = l_Lean_Parser_mergeOrElseErrors(x_117, x_13, x_10);
-lean_dec(x_10);
-return x_118;
+x_108 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_109 = l_Lean_Parser_ParserState_mkNode(x_95, x_108, x_17);
+x_110 = l_Lean_Parser_mergeOrElseErrors(x_109, x_12, x_9);
+lean_dec(x_9);
+return x_110;
+}
+}
+else
+{
+lean_object* x_111; lean_object* x_112; lean_object* x_113; 
+lean_dec(x_90);
+lean_dec(x_4);
+lean_dec(x_1);
+x_111 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_112 = l_Lean_Parser_ParserState_mkNode(x_89, x_111, x_17);
+x_113 = l_Lean_Parser_mergeOrElseErrors(x_112, x_12, x_9);
+lean_dec(x_9);
+return x_113;
+}
+}
+else
+{
+lean_object* x_114; lean_object* x_115; lean_object* x_116; 
+lean_dec(x_88);
+lean_dec(x_4);
+lean_dec(x_1);
+x_114 = l_Lean_Parser_Command_structure___elambda__1___closed__2;
+x_115 = l_Lean_Parser_ParserState_mkNode(x_87, x_114, x_17);
+x_116 = l_Lean_Parser_mergeOrElseErrors(x_115, x_12, x_9);
+lean_dec(x_9);
+return x_116;
 }
 }
 }
@@ -15650,7 +15304,7 @@ lean_object* _init_l_Lean_Parser_Command_structure___closed__13() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structure___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structure___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -15705,666 +15359,633 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_declaration___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_declaration___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_declaration___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_declaration___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_declaration___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_declaration___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_declaration___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_declaration___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_declaration___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
 lean_inc(x_1);
-x_17 = l_Lean_Parser_Command_declModifiers___elambda__1(x_1, x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+x_16 = l_Lean_Parser_Command_declModifiers___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-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);
-lean_inc(x_2);
-lean_inc(x_1);
-x_22 = l_Lean_Parser_Command_abbrev___elambda__1(x_1, x_2, x_17);
-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);
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_24 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_22, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
-}
-else
-{
-lean_object* x_27; lean_object* x_28; uint8_t x_29; 
-x_27 = lean_ctor_get(x_23, 0);
-lean_inc(x_27);
-lean_dec(x_23);
-x_28 = lean_ctor_get(x_22, 1);
-lean_inc(x_28);
-x_29 = lean_nat_dec_eq(x_28, x_21);
-lean_dec(x_28);
-if (x_29 == 0)
-{
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_27);
-lean_dec(x_21);
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_30 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_inc(x_21);
-x_33 = l_Lean_Parser_ParserState_restore(x_22, x_20, x_21);
-lean_dec(x_20);
-x_34 = lean_ctor_get(x_33, 0);
-lean_inc(x_34);
-x_35 = lean_array_get_size(x_34);
-lean_dec(x_34);
-lean_inc(x_2);
-lean_inc(x_1);
-x_36 = l_Lean_Parser_Command_def___elambda__1(x_1, x_2, x_33);
-x_37 = lean_ctor_get(x_36, 3);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_35);
-lean_dec(x_2);
-lean_dec(x_1);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_36, x_27, x_21);
-lean_dec(x_21);
-x_39 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
-}
-else
-{
-lean_object* x_42; lean_object* x_43; uint8_t x_44; 
-x_42 = lean_ctor_get(x_37, 0);
-lean_inc(x_42);
-lean_dec(x_37);
-x_43 = lean_ctor_get(x_36, 1);
-lean_inc(x_43);
-x_44 = lean_nat_dec_eq(x_43, x_21);
-lean_dec(x_43);
-if (x_44 == 0)
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_42);
-lean_dec(x_35);
-lean_dec(x_2);
-lean_dec(x_1);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_36, x_27, x_21);
-lean_dec(x_21);
-x_46 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
-}
-else
-{
-lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_inc(x_21);
-x_49 = l_Lean_Parser_ParserState_restore(x_36, x_35, x_21);
-lean_dec(x_35);
-x_50 = lean_ctor_get(x_49, 0);
-lean_inc(x_50);
-x_51 = lean_array_get_size(x_50);
-lean_dec(x_50);
-lean_inc(x_2);
-lean_inc(x_1);
-x_52 = l_Lean_Parser_Command_theorem___elambda__1(x_1, x_2, x_49);
-x_53 = lean_ctor_get(x_52, 3);
-lean_inc(x_53);
-if (lean_obj_tag(x_53) == 0)
-{
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-lean_dec(x_51);
-lean_dec(x_2);
-lean_dec(x_1);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_52, x_42, x_21);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_27, x_21);
-lean_dec(x_21);
-x_56 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_16);
-x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_11, x_8);
-lean_dec(x_8);
-return x_58;
-}
-else
-{
-lean_object* x_59; lean_object* x_60; uint8_t x_61; 
-x_59 = lean_ctor_get(x_53, 0);
-lean_inc(x_59);
-lean_dec(x_53);
-x_60 = lean_ctor_get(x_52, 1);
-lean_inc(x_60);
-x_61 = lean_nat_dec_eq(x_60, x_21);
-lean_dec(x_60);
-if (x_61 == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
-lean_dec(x_51);
-lean_dec(x_2);
-lean_dec(x_1);
-x_62 = l_Lean_Parser_mergeOrElseErrors(x_52, x_42, x_21);
-x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_27, x_21);
-lean_dec(x_21);
-x_64 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_16);
-x_66 = l_Lean_Parser_mergeOrElseErrors(x_65, x_11, x_8);
-lean_dec(x_8);
-return x_66;
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-lean_inc(x_21);
-x_67 = l_Lean_Parser_ParserState_restore(x_52, x_51, x_21);
-lean_dec(x_51);
-x_68 = lean_ctor_get(x_67, 0);
-lean_inc(x_68);
-x_69 = lean_array_get_size(x_68);
-lean_dec(x_68);
-lean_inc(x_2);
-lean_inc(x_1);
-x_70 = l_Lean_Parser_Command_constant___elambda__1(x_1, x_2, x_67);
-x_71 = lean_ctor_get(x_70, 3);
-lean_inc(x_71);
-if (lean_obj_tag(x_71) == 0)
-{
-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_dec(x_69);
-lean_dec(x_2);
-lean_dec(x_1);
-x_72 = l_Lean_Parser_mergeOrElseErrors(x_70, x_59, x_21);
-x_73 = l_Lean_Parser_mergeOrElseErrors(x_72, x_42, x_21);
-x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_27, x_21);
-lean_dec(x_21);
-x_75 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_76 = l_Lean_Parser_ParserState_mkNode(x_74, x_75, x_16);
-x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_11, x_8);
-lean_dec(x_8);
-return x_77;
-}
-else
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_71, 0);
-lean_inc(x_78);
-lean_dec(x_71);
-x_79 = lean_ctor_get(x_70, 1);
-lean_inc(x_79);
-x_80 = lean_nat_dec_eq(x_79, x_21);
-lean_dec(x_79);
-if (x_80 == 0)
-{
-lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-lean_dec(x_78);
-lean_dec(x_69);
-lean_dec(x_2);
-lean_dec(x_1);
-x_81 = l_Lean_Parser_mergeOrElseErrors(x_70, x_59, x_21);
-x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_42, x_21);
-x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_27, x_21);
-lean_dec(x_21);
-x_84 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_85 = l_Lean_Parser_ParserState_mkNode(x_83, x_84, x_16);
-x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_11, x_8);
-lean_dec(x_8);
-return x_86;
-}
-else
-{
-lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
-lean_inc(x_21);
-x_87 = l_Lean_Parser_ParserState_restore(x_70, x_69, x_21);
-lean_dec(x_69);
-x_88 = lean_ctor_get(x_87, 0);
-lean_inc(x_88);
-x_89 = lean_array_get_size(x_88);
-lean_dec(x_88);
-lean_inc(x_2);
-lean_inc(x_1);
-x_90 = l_Lean_Parser_Command_instance___elambda__1(x_1, x_2, x_87);
-x_91 = lean_ctor_get(x_90, 3);
-lean_inc(x_91);
-if (lean_obj_tag(x_91) == 0)
-{
-lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; 
-lean_dec(x_89);
-lean_dec(x_2);
-lean_dec(x_1);
-x_92 = l_Lean_Parser_mergeOrElseErrors(x_90, x_78, x_21);
-x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_59, x_21);
-x_94 = l_Lean_Parser_mergeOrElseErrors(x_93, x_42, x_21);
-x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_27, x_21);
-lean_dec(x_21);
-x_96 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_97 = l_Lean_Parser_ParserState_mkNode(x_95, x_96, x_16);
-x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_11, x_8);
-lean_dec(x_8);
-return x_98;
-}
-else
-{
-lean_object* x_99; lean_object* x_100; uint8_t x_101; 
-x_99 = lean_ctor_get(x_91, 0);
-lean_inc(x_99);
-lean_dec(x_91);
-x_100 = lean_ctor_get(x_90, 1);
-lean_inc(x_100);
-x_101 = lean_nat_dec_eq(x_100, x_21);
-lean_dec(x_100);
-if (x_101 == 0)
-{
-lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; 
-lean_dec(x_99);
-lean_dec(x_89);
-lean_dec(x_2);
-lean_dec(x_1);
-x_102 = l_Lean_Parser_mergeOrElseErrors(x_90, x_78, x_21);
-x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_59, x_21);
-x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_42, x_21);
-x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_27, x_21);
-lean_dec(x_21);
-x_106 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_107 = l_Lean_Parser_ParserState_mkNode(x_105, x_106, x_16);
-x_108 = l_Lean_Parser_mergeOrElseErrors(x_107, x_11, x_8);
-lean_dec(x_8);
-return x_108;
-}
-else
-{
-lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; 
-lean_inc(x_21);
-x_109 = l_Lean_Parser_ParserState_restore(x_90, x_89, x_21);
-lean_dec(x_89);
-x_110 = lean_ctor_get(x_109, 0);
-lean_inc(x_110);
-x_111 = lean_array_get_size(x_110);
-lean_dec(x_110);
-lean_inc(x_2);
-lean_inc(x_1);
-x_112 = l_Lean_Parser_Command_axiom___elambda__1(x_1, x_2, x_109);
-x_113 = lean_ctor_get(x_112, 3);
-lean_inc(x_113);
-if (lean_obj_tag(x_113) == 0)
-{
-lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
-lean_dec(x_111);
-lean_dec(x_2);
-lean_dec(x_1);
-x_114 = l_Lean_Parser_mergeOrElseErrors(x_112, x_99, x_21);
-x_115 = l_Lean_Parser_mergeOrElseErrors(x_114, x_78, x_21);
-x_116 = l_Lean_Parser_mergeOrElseErrors(x_115, x_59, x_21);
-x_117 = l_Lean_Parser_mergeOrElseErrors(x_116, x_42, x_21);
-x_118 = l_Lean_Parser_mergeOrElseErrors(x_117, x_27, x_21);
-lean_dec(x_21);
-x_119 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_120 = l_Lean_Parser_ParserState_mkNode(x_118, x_119, x_16);
-x_121 = l_Lean_Parser_mergeOrElseErrors(x_120, x_11, x_8);
-lean_dec(x_8);
-return x_121;
-}
-else
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_113, 0);
-lean_inc(x_122);
-lean_dec(x_113);
-x_123 = lean_ctor_get(x_112, 1);
-lean_inc(x_123);
-x_124 = lean_nat_dec_eq(x_123, x_21);
-lean_dec(x_123);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; 
-lean_dec(x_122);
-lean_dec(x_111);
-lean_dec(x_2);
-lean_dec(x_1);
-x_125 = l_Lean_Parser_mergeOrElseErrors(x_112, x_99, x_21);
-x_126 = l_Lean_Parser_mergeOrElseErrors(x_125, x_78, x_21);
-x_127 = l_Lean_Parser_mergeOrElseErrors(x_126, x_59, x_21);
-x_128 = l_Lean_Parser_mergeOrElseErrors(x_127, x_42, x_21);
-x_129 = l_Lean_Parser_mergeOrElseErrors(x_128, x_27, x_21);
-lean_dec(x_21);
-x_130 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_131 = l_Lean_Parser_ParserState_mkNode(x_129, x_130, x_16);
-x_132 = l_Lean_Parser_mergeOrElseErrors(x_131, x_11, x_8);
-lean_dec(x_8);
-return x_132;
-}
-else
-{
-lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; 
-lean_inc(x_21);
-x_133 = l_Lean_Parser_ParserState_restore(x_112, x_111, x_21);
-lean_dec(x_111);
-x_134 = lean_ctor_get(x_133, 0);
-lean_inc(x_134);
-x_135 = lean_array_get_size(x_134);
-lean_dec(x_134);
-lean_inc(x_2);
-lean_inc(x_1);
-x_136 = l_Lean_Parser_Command_example___elambda__1(x_1, x_2, x_133);
-x_137 = lean_ctor_get(x_136, 3);
-lean_inc(x_137);
-if (lean_obj_tag(x_137) == 0)
-{
-lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; 
-lean_dec(x_135);
-lean_dec(x_2);
-lean_dec(x_1);
-x_138 = l_Lean_Parser_mergeOrElseErrors(x_136, x_122, x_21);
-x_139 = l_Lean_Parser_mergeOrElseErrors(x_138, x_99, x_21);
-x_140 = l_Lean_Parser_mergeOrElseErrors(x_139, x_78, x_21);
-x_141 = l_Lean_Parser_mergeOrElseErrors(x_140, x_59, x_21);
-x_142 = l_Lean_Parser_mergeOrElseErrors(x_141, x_42, x_21);
-x_143 = l_Lean_Parser_mergeOrElseErrors(x_142, x_27, x_21);
-lean_dec(x_21);
-x_144 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_145 = l_Lean_Parser_ParserState_mkNode(x_143, x_144, x_16);
-x_146 = l_Lean_Parser_mergeOrElseErrors(x_145, x_11, x_8);
-lean_dec(x_8);
-return x_146;
-}
-else
-{
-lean_object* x_147; lean_object* x_148; uint8_t x_149; 
-x_147 = lean_ctor_get(x_137, 0);
-lean_inc(x_147);
-lean_dec(x_137);
-x_148 = lean_ctor_get(x_136, 1);
-lean_inc(x_148);
-x_149 = lean_nat_dec_eq(x_148, x_21);
-lean_dec(x_148);
-if (x_149 == 0)
-{
-lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; 
-lean_dec(x_147);
-lean_dec(x_135);
-lean_dec(x_2);
-lean_dec(x_1);
-x_150 = l_Lean_Parser_mergeOrElseErrors(x_136, x_122, x_21);
-x_151 = l_Lean_Parser_mergeOrElseErrors(x_150, x_99, x_21);
-x_152 = l_Lean_Parser_mergeOrElseErrors(x_151, x_78, x_21);
-x_153 = l_Lean_Parser_mergeOrElseErrors(x_152, x_59, x_21);
-x_154 = l_Lean_Parser_mergeOrElseErrors(x_153, x_42, x_21);
-x_155 = l_Lean_Parser_mergeOrElseErrors(x_154, x_27, x_21);
-lean_dec(x_21);
-x_156 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_157 = l_Lean_Parser_ParserState_mkNode(x_155, x_156, x_16);
-x_158 = l_Lean_Parser_mergeOrElseErrors(x_157, x_11, x_8);
-lean_dec(x_8);
-return x_158;
-}
-else
-{
-lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; 
-lean_inc(x_21);
-x_159 = l_Lean_Parser_ParserState_restore(x_136, x_135, x_21);
-lean_dec(x_135);
-x_160 = lean_ctor_get(x_159, 0);
-lean_inc(x_160);
-x_161 = lean_array_get_size(x_160);
-lean_dec(x_160);
-lean_inc(x_2);
-lean_inc(x_1);
-x_162 = l_Lean_Parser_Command_inductive___elambda__1(x_1, x_2, x_159);
-x_163 = lean_ctor_get(x_162, 3);
-lean_inc(x_163);
-if (lean_obj_tag(x_163) == 0)
-{
-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; lean_object* x_171; lean_object* x_172; lean_object* x_173; 
-lean_dec(x_161);
-lean_dec(x_2);
-lean_dec(x_1);
-x_164 = l_Lean_Parser_mergeOrElseErrors(x_162, x_147, x_21);
-x_165 = l_Lean_Parser_mergeOrElseErrors(x_164, x_122, x_21);
-x_166 = l_Lean_Parser_mergeOrElseErrors(x_165, x_99, x_21);
-x_167 = l_Lean_Parser_mergeOrElseErrors(x_166, x_78, x_21);
-x_168 = l_Lean_Parser_mergeOrElseErrors(x_167, x_59, x_21);
-x_169 = l_Lean_Parser_mergeOrElseErrors(x_168, x_42, x_21);
-x_170 = l_Lean_Parser_mergeOrElseErrors(x_169, x_27, x_21);
-lean_dec(x_21);
-x_171 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_172 = l_Lean_Parser_ParserState_mkNode(x_170, x_171, x_16);
-x_173 = l_Lean_Parser_mergeOrElseErrors(x_172, x_11, x_8);
-lean_dec(x_8);
-return x_173;
-}
-else
-{
-lean_object* x_174; lean_object* x_175; uint8_t x_176; 
-x_174 = lean_ctor_get(x_163, 0);
-lean_inc(x_174);
-lean_dec(x_163);
-x_175 = lean_ctor_get(x_162, 1);
-lean_inc(x_175);
-x_176 = lean_nat_dec_eq(x_175, x_21);
-lean_dec(x_175);
-if (x_176 == 0)
-{
-lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; 
-lean_dec(x_174);
-lean_dec(x_161);
-lean_dec(x_2);
-lean_dec(x_1);
-x_177 = l_Lean_Parser_mergeOrElseErrors(x_162, x_147, x_21);
-x_178 = l_Lean_Parser_mergeOrElseErrors(x_177, x_122, x_21);
-x_179 = l_Lean_Parser_mergeOrElseErrors(x_178, x_99, x_21);
-x_180 = l_Lean_Parser_mergeOrElseErrors(x_179, x_78, x_21);
-x_181 = l_Lean_Parser_mergeOrElseErrors(x_180, x_59, x_21);
-x_182 = l_Lean_Parser_mergeOrElseErrors(x_181, x_42, x_21);
-x_183 = l_Lean_Parser_mergeOrElseErrors(x_182, x_27, x_21);
-lean_dec(x_21);
-x_184 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_185 = l_Lean_Parser_ParserState_mkNode(x_183, x_184, x_16);
-x_186 = l_Lean_Parser_mergeOrElseErrors(x_185, x_11, x_8);
-lean_dec(x_8);
-return x_186;
-}
-else
-{
-lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; 
-lean_inc(x_21);
-x_187 = l_Lean_Parser_ParserState_restore(x_162, x_161, x_21);
-lean_dec(x_161);
-x_188 = lean_ctor_get(x_187, 0);
-lean_inc(x_188);
-x_189 = lean_array_get_size(x_188);
-lean_dec(x_188);
-lean_inc(x_2);
-lean_inc(x_1);
-x_190 = l_Lean_Parser_Command_classInductive___elambda__1(x_1, x_2, x_187);
-x_191 = lean_ctor_get(x_190, 3);
-lean_inc(x_191);
-if (lean_obj_tag(x_191) == 0)
-{
-lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; 
-lean_dec(x_189);
-lean_dec(x_2);
-lean_dec(x_1);
-x_192 = l_Lean_Parser_mergeOrElseErrors(x_190, x_174, x_21);
-x_193 = l_Lean_Parser_mergeOrElseErrors(x_192, x_147, x_21);
-x_194 = l_Lean_Parser_mergeOrElseErrors(x_193, x_122, x_21);
-x_195 = l_Lean_Parser_mergeOrElseErrors(x_194, x_99, x_21);
-x_196 = l_Lean_Parser_mergeOrElseErrors(x_195, x_78, x_21);
-x_197 = l_Lean_Parser_mergeOrElseErrors(x_196, x_59, x_21);
-x_198 = l_Lean_Parser_mergeOrElseErrors(x_197, x_42, x_21);
-x_199 = l_Lean_Parser_mergeOrElseErrors(x_198, x_27, x_21);
-lean_dec(x_21);
-x_200 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_201 = l_Lean_Parser_ParserState_mkNode(x_199, x_200, x_16);
-x_202 = l_Lean_Parser_mergeOrElseErrors(x_201, x_11, x_8);
-lean_dec(x_8);
-return x_202;
-}
-else
-{
-lean_object* x_203; lean_object* x_204; uint8_t x_205; 
-x_203 = lean_ctor_get(x_191, 0);
-lean_inc(x_203);
-lean_dec(x_191);
-x_204 = lean_ctor_get(x_190, 1);
-lean_inc(x_204);
-x_205 = lean_nat_dec_eq(x_204, x_21);
-lean_dec(x_204);
-if (x_205 == 0)
-{
-lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; 
-lean_dec(x_203);
-lean_dec(x_189);
-lean_dec(x_2);
-lean_dec(x_1);
-x_206 = l_Lean_Parser_mergeOrElseErrors(x_190, x_174, x_21);
-x_207 = l_Lean_Parser_mergeOrElseErrors(x_206, x_147, x_21);
-x_208 = l_Lean_Parser_mergeOrElseErrors(x_207, x_122, x_21);
-x_209 = l_Lean_Parser_mergeOrElseErrors(x_208, x_99, x_21);
-x_210 = l_Lean_Parser_mergeOrElseErrors(x_209, x_78, x_21);
-x_211 = l_Lean_Parser_mergeOrElseErrors(x_210, x_59, x_21);
-x_212 = l_Lean_Parser_mergeOrElseErrors(x_211, x_42, x_21);
-x_213 = l_Lean_Parser_mergeOrElseErrors(x_212, x_27, x_21);
-lean_dec(x_21);
-x_214 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_215 = l_Lean_Parser_ParserState_mkNode(x_213, x_214, x_16);
-x_216 = l_Lean_Parser_mergeOrElseErrors(x_215, x_11, x_8);
-lean_dec(x_8);
-return x_216;
-}
-else
-{
-lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; 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_inc(x_21);
-x_217 = l_Lean_Parser_ParserState_restore(x_190, x_189, x_21);
-lean_dec(x_189);
-x_218 = l_Lean_Parser_Command_structure___elambda__1(x_1, x_2, x_217);
-x_219 = l_Lean_Parser_mergeOrElseErrors(x_218, x_203, x_21);
-x_220 = l_Lean_Parser_mergeOrElseErrors(x_219, x_174, x_21);
-x_221 = l_Lean_Parser_mergeOrElseErrors(x_220, x_147, x_21);
-x_222 = l_Lean_Parser_mergeOrElseErrors(x_221, x_122, x_21);
-x_223 = l_Lean_Parser_mergeOrElseErrors(x_222, x_99, x_21);
-x_224 = l_Lean_Parser_mergeOrElseErrors(x_223, x_78, x_21);
-x_225 = l_Lean_Parser_mergeOrElseErrors(x_224, x_59, x_21);
-x_226 = l_Lean_Parser_mergeOrElseErrors(x_225, x_42, x_21);
-x_227 = l_Lean_Parser_mergeOrElseErrors(x_226, x_27, x_21);
-lean_dec(x_21);
-x_228 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_229 = l_Lean_Parser_ParserState_mkNode(x_227, x_228, x_16);
-x_230 = l_Lean_Parser_mergeOrElseErrors(x_229, x_11, x_8);
-lean_dec(x_8);
-return x_230;
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_231; lean_object* x_232; lean_object* x_233; 
+x_19 = lean_array_get_size(x_18);
 lean_dec(x_18);
-lean_dec(x_2);
+x_20 = lean_ctor_get(x_16, 1);
+lean_inc(x_20);
+lean_inc(x_1);
+x_21 = l_Lean_Parser_Command_abbrev___elambda__1(x_1, x_16);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_20);
+lean_dec(x_19);
 lean_dec(x_1);
-x_231 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
-x_232 = l_Lean_Parser_ParserState_mkNode(x_17, x_231, x_16);
-x_233 = l_Lean_Parser_mergeOrElseErrors(x_232, x_11, x_8);
-lean_dec(x_8);
-return x_233;
+x_23 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
+}
+else
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_22, 0);
+lean_inc(x_26);
+lean_dec(x_22);
+x_27 = lean_ctor_get(x_21, 1);
+lean_inc(x_27);
+x_28 = lean_nat_dec_eq(x_27, x_20);
+lean_dec(x_27);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_26);
+lean_dec(x_20);
+lean_dec(x_19);
+lean_dec(x_1);
+x_29 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_21, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
+}
+else
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_inc(x_20);
+x_32 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+lean_dec(x_19);
+x_33 = lean_ctor_get(x_32, 0);
+lean_inc(x_33);
+x_34 = lean_array_get_size(x_33);
+lean_dec(x_33);
+lean_inc(x_1);
+x_35 = l_Lean_Parser_Command_def___elambda__1(x_1, x_32);
+x_36 = lean_ctor_get(x_35, 3);
+lean_inc(x_36);
+if (lean_obj_tag(x_36) == 0)
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_34);
+lean_dec(x_1);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_35, x_26, x_20);
+lean_dec(x_20);
+x_38 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+else
+{
+lean_object* x_41; lean_object* x_42; uint8_t x_43; 
+x_41 = lean_ctor_get(x_36, 0);
+lean_inc(x_41);
+lean_dec(x_36);
+x_42 = lean_ctor_get(x_35, 1);
+lean_inc(x_42);
+x_43 = lean_nat_dec_eq(x_42, x_20);
+lean_dec(x_42);
+if (x_43 == 0)
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_41);
+lean_dec(x_34);
+lean_dec(x_1);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_35, x_26, x_20);
+lean_dec(x_20);
+x_45 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_10, x_7);
+lean_dec(x_7);
+return x_47;
+}
+else
+{
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_inc(x_20);
+x_48 = l_Lean_Parser_ParserState_restore(x_35, x_34, x_20);
+lean_dec(x_34);
+x_49 = lean_ctor_get(x_48, 0);
+lean_inc(x_49);
+x_50 = lean_array_get_size(x_49);
+lean_dec(x_49);
+lean_inc(x_1);
+x_51 = l_Lean_Parser_Command_theorem___elambda__1(x_1, x_48);
+x_52 = lean_ctor_get(x_51, 3);
+lean_inc(x_52);
+if (lean_obj_tag(x_52) == 0)
+{
+lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_dec(x_50);
+lean_dec(x_1);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_51, x_41, x_20);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_26, x_20);
+lean_dec(x_20);
+x_55 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_56 = l_Lean_Parser_ParserState_mkNode(x_54, x_55, x_15);
+x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_10, x_7);
+lean_dec(x_7);
+return x_57;
+}
+else
+{
+lean_object* x_58; lean_object* x_59; uint8_t x_60; 
+x_58 = lean_ctor_get(x_52, 0);
+lean_inc(x_58);
+lean_dec(x_52);
+x_59 = lean_ctor_get(x_51, 1);
+lean_inc(x_59);
+x_60 = lean_nat_dec_eq(x_59, x_20);
+lean_dec(x_59);
+if (x_60 == 0)
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_58);
+lean_dec(x_50);
+lean_dec(x_1);
+x_61 = l_Lean_Parser_mergeOrElseErrors(x_51, x_41, x_20);
+x_62 = l_Lean_Parser_mergeOrElseErrors(x_61, x_26, x_20);
+lean_dec(x_20);
+x_63 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_15);
+x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_10, x_7);
+lean_dec(x_7);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+lean_inc(x_20);
+x_66 = l_Lean_Parser_ParserState_restore(x_51, x_50, x_20);
+lean_dec(x_50);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+lean_inc(x_1);
+x_69 = l_Lean_Parser_Command_constant___elambda__1(x_1, x_66);
+x_70 = lean_ctor_get(x_69, 3);
+lean_inc(x_70);
+if (lean_obj_tag(x_70) == 0)
+{
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; 
+lean_dec(x_68);
+lean_dec(x_1);
+x_71 = l_Lean_Parser_mergeOrElseErrors(x_69, x_58, x_20);
+x_72 = l_Lean_Parser_mergeOrElseErrors(x_71, x_41, x_20);
+x_73 = l_Lean_Parser_mergeOrElseErrors(x_72, x_26, x_20);
+lean_dec(x_20);
+x_74 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_73, x_74, x_15);
+x_76 = l_Lean_Parser_mergeOrElseErrors(x_75, x_10, x_7);
+lean_dec(x_7);
+return x_76;
+}
+else
+{
+lean_object* x_77; lean_object* x_78; uint8_t x_79; 
+x_77 = lean_ctor_get(x_70, 0);
+lean_inc(x_77);
+lean_dec(x_70);
+x_78 = lean_ctor_get(x_69, 1);
+lean_inc(x_78);
+x_79 = lean_nat_dec_eq(x_78, x_20);
+lean_dec(x_78);
+if (x_79 == 0)
+{
+lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+lean_dec(x_77);
+lean_dec(x_68);
+lean_dec(x_1);
+x_80 = l_Lean_Parser_mergeOrElseErrors(x_69, x_58, x_20);
+x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_41, x_20);
+x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_26, x_20);
+lean_dec(x_20);
+x_83 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_84 = l_Lean_Parser_ParserState_mkNode(x_82, x_83, x_15);
+x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_10, x_7);
+lean_dec(x_7);
+return x_85;
+}
+else
+{
+lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
+lean_inc(x_20);
+x_86 = l_Lean_Parser_ParserState_restore(x_69, x_68, x_20);
+lean_dec(x_68);
+x_87 = lean_ctor_get(x_86, 0);
+lean_inc(x_87);
+x_88 = lean_array_get_size(x_87);
+lean_dec(x_87);
+lean_inc(x_1);
+x_89 = l_Lean_Parser_Command_instance___elambda__1(x_1, x_86);
+x_90 = lean_ctor_get(x_89, 3);
+lean_inc(x_90);
+if (lean_obj_tag(x_90) == 0)
+{
+lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; 
+lean_dec(x_88);
+lean_dec(x_1);
+x_91 = l_Lean_Parser_mergeOrElseErrors(x_89, x_77, x_20);
+x_92 = l_Lean_Parser_mergeOrElseErrors(x_91, x_58, x_20);
+x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_41, x_20);
+x_94 = l_Lean_Parser_mergeOrElseErrors(x_93, x_26, x_20);
+lean_dec(x_20);
+x_95 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_15);
+x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_10, x_7);
+lean_dec(x_7);
+return x_97;
+}
+else
+{
+lean_object* x_98; lean_object* x_99; uint8_t x_100; 
+x_98 = lean_ctor_get(x_90, 0);
+lean_inc(x_98);
+lean_dec(x_90);
+x_99 = lean_ctor_get(x_89, 1);
+lean_inc(x_99);
+x_100 = lean_nat_dec_eq(x_99, x_20);
+lean_dec(x_99);
+if (x_100 == 0)
+{
+lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; 
+lean_dec(x_98);
+lean_dec(x_88);
+lean_dec(x_1);
+x_101 = l_Lean_Parser_mergeOrElseErrors(x_89, x_77, x_20);
+x_102 = l_Lean_Parser_mergeOrElseErrors(x_101, x_58, x_20);
+x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_41, x_20);
+x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_26, x_20);
+lean_dec(x_20);
+x_105 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_106 = l_Lean_Parser_ParserState_mkNode(x_104, x_105, x_15);
+x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_10, x_7);
+lean_dec(x_7);
+return x_107;
+}
+else
+{
+lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; 
+lean_inc(x_20);
+x_108 = l_Lean_Parser_ParserState_restore(x_89, x_88, x_20);
+lean_dec(x_88);
+x_109 = lean_ctor_get(x_108, 0);
+lean_inc(x_109);
+x_110 = lean_array_get_size(x_109);
+lean_dec(x_109);
+lean_inc(x_1);
+x_111 = l_Lean_Parser_Command_axiom___elambda__1(x_1, x_108);
+x_112 = lean_ctor_get(x_111, 3);
+lean_inc(x_112);
+if (lean_obj_tag(x_112) == 0)
+{
+lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; 
+lean_dec(x_110);
+lean_dec(x_1);
+x_113 = l_Lean_Parser_mergeOrElseErrors(x_111, x_98, x_20);
+x_114 = l_Lean_Parser_mergeOrElseErrors(x_113, x_77, x_20);
+x_115 = l_Lean_Parser_mergeOrElseErrors(x_114, x_58, x_20);
+x_116 = l_Lean_Parser_mergeOrElseErrors(x_115, x_41, x_20);
+x_117 = l_Lean_Parser_mergeOrElseErrors(x_116, x_26, x_20);
+lean_dec(x_20);
+x_118 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_119 = l_Lean_Parser_ParserState_mkNode(x_117, x_118, x_15);
+x_120 = l_Lean_Parser_mergeOrElseErrors(x_119, x_10, x_7);
+lean_dec(x_7);
+return x_120;
+}
+else
+{
+lean_object* x_121; lean_object* x_122; uint8_t x_123; 
+x_121 = lean_ctor_get(x_112, 0);
+lean_inc(x_121);
+lean_dec(x_112);
+x_122 = lean_ctor_get(x_111, 1);
+lean_inc(x_122);
+x_123 = lean_nat_dec_eq(x_122, x_20);
+lean_dec(x_122);
+if (x_123 == 0)
+{
+lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; 
+lean_dec(x_121);
+lean_dec(x_110);
+lean_dec(x_1);
+x_124 = l_Lean_Parser_mergeOrElseErrors(x_111, x_98, x_20);
+x_125 = l_Lean_Parser_mergeOrElseErrors(x_124, x_77, x_20);
+x_126 = l_Lean_Parser_mergeOrElseErrors(x_125, x_58, x_20);
+x_127 = l_Lean_Parser_mergeOrElseErrors(x_126, x_41, x_20);
+x_128 = l_Lean_Parser_mergeOrElseErrors(x_127, x_26, x_20);
+lean_dec(x_20);
+x_129 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_130 = l_Lean_Parser_ParserState_mkNode(x_128, x_129, x_15);
+x_131 = l_Lean_Parser_mergeOrElseErrors(x_130, x_10, x_7);
+lean_dec(x_7);
+return x_131;
+}
+else
+{
+lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; 
+lean_inc(x_20);
+x_132 = l_Lean_Parser_ParserState_restore(x_111, x_110, x_20);
+lean_dec(x_110);
+x_133 = lean_ctor_get(x_132, 0);
+lean_inc(x_133);
+x_134 = lean_array_get_size(x_133);
+lean_dec(x_133);
+lean_inc(x_1);
+x_135 = l_Lean_Parser_Command_example___elambda__1(x_1, x_132);
+x_136 = lean_ctor_get(x_135, 3);
+lean_inc(x_136);
+if (lean_obj_tag(x_136) == 0)
+{
+lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; 
+lean_dec(x_134);
+lean_dec(x_1);
+x_137 = l_Lean_Parser_mergeOrElseErrors(x_135, x_121, x_20);
+x_138 = l_Lean_Parser_mergeOrElseErrors(x_137, x_98, x_20);
+x_139 = l_Lean_Parser_mergeOrElseErrors(x_138, x_77, x_20);
+x_140 = l_Lean_Parser_mergeOrElseErrors(x_139, x_58, x_20);
+x_141 = l_Lean_Parser_mergeOrElseErrors(x_140, x_41, x_20);
+x_142 = l_Lean_Parser_mergeOrElseErrors(x_141, x_26, x_20);
+lean_dec(x_20);
+x_143 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_144 = l_Lean_Parser_ParserState_mkNode(x_142, x_143, x_15);
+x_145 = l_Lean_Parser_mergeOrElseErrors(x_144, x_10, x_7);
+lean_dec(x_7);
+return x_145;
+}
+else
+{
+lean_object* x_146; lean_object* x_147; uint8_t x_148; 
+x_146 = lean_ctor_get(x_136, 0);
+lean_inc(x_146);
+lean_dec(x_136);
+x_147 = lean_ctor_get(x_135, 1);
+lean_inc(x_147);
+x_148 = lean_nat_dec_eq(x_147, x_20);
+lean_dec(x_147);
+if (x_148 == 0)
+{
+lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; 
+lean_dec(x_146);
+lean_dec(x_134);
+lean_dec(x_1);
+x_149 = l_Lean_Parser_mergeOrElseErrors(x_135, x_121, x_20);
+x_150 = l_Lean_Parser_mergeOrElseErrors(x_149, x_98, x_20);
+x_151 = l_Lean_Parser_mergeOrElseErrors(x_150, x_77, x_20);
+x_152 = l_Lean_Parser_mergeOrElseErrors(x_151, x_58, x_20);
+x_153 = l_Lean_Parser_mergeOrElseErrors(x_152, x_41, x_20);
+x_154 = l_Lean_Parser_mergeOrElseErrors(x_153, x_26, x_20);
+lean_dec(x_20);
+x_155 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_156 = l_Lean_Parser_ParserState_mkNode(x_154, x_155, x_15);
+x_157 = l_Lean_Parser_mergeOrElseErrors(x_156, x_10, x_7);
+lean_dec(x_7);
+return x_157;
+}
+else
+{
+lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; 
+lean_inc(x_20);
+x_158 = l_Lean_Parser_ParserState_restore(x_135, x_134, x_20);
+lean_dec(x_134);
+x_159 = lean_ctor_get(x_158, 0);
+lean_inc(x_159);
+x_160 = lean_array_get_size(x_159);
+lean_dec(x_159);
+lean_inc(x_1);
+x_161 = l_Lean_Parser_Command_inductive___elambda__1(x_1, x_158);
+x_162 = lean_ctor_get(x_161, 3);
+lean_inc(x_162);
+if (lean_obj_tag(x_162) == 0)
+{
+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; lean_object* x_171; lean_object* x_172; 
+lean_dec(x_160);
+lean_dec(x_1);
+x_163 = l_Lean_Parser_mergeOrElseErrors(x_161, x_146, x_20);
+x_164 = l_Lean_Parser_mergeOrElseErrors(x_163, x_121, x_20);
+x_165 = l_Lean_Parser_mergeOrElseErrors(x_164, x_98, x_20);
+x_166 = l_Lean_Parser_mergeOrElseErrors(x_165, x_77, x_20);
+x_167 = l_Lean_Parser_mergeOrElseErrors(x_166, x_58, x_20);
+x_168 = l_Lean_Parser_mergeOrElseErrors(x_167, x_41, x_20);
+x_169 = l_Lean_Parser_mergeOrElseErrors(x_168, x_26, x_20);
+lean_dec(x_20);
+x_170 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_171 = l_Lean_Parser_ParserState_mkNode(x_169, x_170, x_15);
+x_172 = l_Lean_Parser_mergeOrElseErrors(x_171, x_10, x_7);
+lean_dec(x_7);
+return x_172;
+}
+else
+{
+lean_object* x_173; lean_object* x_174; uint8_t x_175; 
+x_173 = lean_ctor_get(x_162, 0);
+lean_inc(x_173);
+lean_dec(x_162);
+x_174 = lean_ctor_get(x_161, 1);
+lean_inc(x_174);
+x_175 = lean_nat_dec_eq(x_174, x_20);
+lean_dec(x_174);
+if (x_175 == 0)
+{
+lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; 
+lean_dec(x_173);
+lean_dec(x_160);
+lean_dec(x_1);
+x_176 = l_Lean_Parser_mergeOrElseErrors(x_161, x_146, x_20);
+x_177 = l_Lean_Parser_mergeOrElseErrors(x_176, x_121, x_20);
+x_178 = l_Lean_Parser_mergeOrElseErrors(x_177, x_98, x_20);
+x_179 = l_Lean_Parser_mergeOrElseErrors(x_178, x_77, x_20);
+x_180 = l_Lean_Parser_mergeOrElseErrors(x_179, x_58, x_20);
+x_181 = l_Lean_Parser_mergeOrElseErrors(x_180, x_41, x_20);
+x_182 = l_Lean_Parser_mergeOrElseErrors(x_181, x_26, x_20);
+lean_dec(x_20);
+x_183 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_184 = l_Lean_Parser_ParserState_mkNode(x_182, x_183, x_15);
+x_185 = l_Lean_Parser_mergeOrElseErrors(x_184, x_10, x_7);
+lean_dec(x_7);
+return x_185;
+}
+else
+{
+lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; 
+lean_inc(x_20);
+x_186 = l_Lean_Parser_ParserState_restore(x_161, x_160, x_20);
+lean_dec(x_160);
+x_187 = lean_ctor_get(x_186, 0);
+lean_inc(x_187);
+x_188 = lean_array_get_size(x_187);
+lean_dec(x_187);
+lean_inc(x_1);
+x_189 = l_Lean_Parser_Command_classInductive___elambda__1(x_1, x_186);
+x_190 = lean_ctor_get(x_189, 3);
+lean_inc(x_190);
+if (lean_obj_tag(x_190) == 0)
+{
+lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; 
+lean_dec(x_188);
+lean_dec(x_1);
+x_191 = l_Lean_Parser_mergeOrElseErrors(x_189, x_173, x_20);
+x_192 = l_Lean_Parser_mergeOrElseErrors(x_191, x_146, x_20);
+x_193 = l_Lean_Parser_mergeOrElseErrors(x_192, x_121, x_20);
+x_194 = l_Lean_Parser_mergeOrElseErrors(x_193, x_98, x_20);
+x_195 = l_Lean_Parser_mergeOrElseErrors(x_194, x_77, x_20);
+x_196 = l_Lean_Parser_mergeOrElseErrors(x_195, x_58, x_20);
+x_197 = l_Lean_Parser_mergeOrElseErrors(x_196, x_41, x_20);
+x_198 = l_Lean_Parser_mergeOrElseErrors(x_197, x_26, x_20);
+lean_dec(x_20);
+x_199 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_200 = l_Lean_Parser_ParserState_mkNode(x_198, x_199, x_15);
+x_201 = l_Lean_Parser_mergeOrElseErrors(x_200, x_10, x_7);
+lean_dec(x_7);
+return x_201;
+}
+else
+{
+lean_object* x_202; lean_object* x_203; uint8_t x_204; 
+x_202 = lean_ctor_get(x_190, 0);
+lean_inc(x_202);
+lean_dec(x_190);
+x_203 = lean_ctor_get(x_189, 1);
+lean_inc(x_203);
+x_204 = lean_nat_dec_eq(x_203, x_20);
+lean_dec(x_203);
+if (x_204 == 0)
+{
+lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; 
+lean_dec(x_202);
+lean_dec(x_188);
+lean_dec(x_1);
+x_205 = l_Lean_Parser_mergeOrElseErrors(x_189, x_173, x_20);
+x_206 = l_Lean_Parser_mergeOrElseErrors(x_205, x_146, x_20);
+x_207 = l_Lean_Parser_mergeOrElseErrors(x_206, x_121, x_20);
+x_208 = l_Lean_Parser_mergeOrElseErrors(x_207, x_98, x_20);
+x_209 = l_Lean_Parser_mergeOrElseErrors(x_208, x_77, x_20);
+x_210 = l_Lean_Parser_mergeOrElseErrors(x_209, x_58, x_20);
+x_211 = l_Lean_Parser_mergeOrElseErrors(x_210, x_41, x_20);
+x_212 = l_Lean_Parser_mergeOrElseErrors(x_211, x_26, x_20);
+lean_dec(x_20);
+x_213 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_214 = l_Lean_Parser_ParserState_mkNode(x_212, x_213, x_15);
+x_215 = l_Lean_Parser_mergeOrElseErrors(x_214, x_10, x_7);
+lean_dec(x_7);
+return x_215;
+}
+else
+{
+lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; 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_inc(x_20);
+x_216 = l_Lean_Parser_ParserState_restore(x_189, x_188, x_20);
+lean_dec(x_188);
+x_217 = l_Lean_Parser_Command_structure___elambda__1(x_1, x_216);
+x_218 = l_Lean_Parser_mergeOrElseErrors(x_217, x_202, x_20);
+x_219 = l_Lean_Parser_mergeOrElseErrors(x_218, x_173, x_20);
+x_220 = l_Lean_Parser_mergeOrElseErrors(x_219, x_146, x_20);
+x_221 = l_Lean_Parser_mergeOrElseErrors(x_220, x_121, x_20);
+x_222 = l_Lean_Parser_mergeOrElseErrors(x_221, x_98, x_20);
+x_223 = l_Lean_Parser_mergeOrElseErrors(x_222, x_77, x_20);
+x_224 = l_Lean_Parser_mergeOrElseErrors(x_223, x_58, x_20);
+x_225 = l_Lean_Parser_mergeOrElseErrors(x_224, x_41, x_20);
+x_226 = l_Lean_Parser_mergeOrElseErrors(x_225, x_26, x_20);
+lean_dec(x_20);
+x_227 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_228 = l_Lean_Parser_ParserState_mkNode(x_226, x_227, x_15);
+x_229 = l_Lean_Parser_mergeOrElseErrors(x_228, x_10, x_7);
+lean_dec(x_7);
+return x_229;
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_230; lean_object* x_231; lean_object* x_232; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_230 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_231 = l_Lean_Parser_ParserState_mkNode(x_16, x_230, x_15);
+x_232 = l_Lean_Parser_mergeOrElseErrors(x_231, x_10, x_7);
+lean_dec(x_7);
+return x_232;
 }
 }
 }
@@ -16518,7 +16139,7 @@ lean_object* _init_l_Lean_Parser_Command_declaration___closed__13() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declaration___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_declaration___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -16545,10 +16166,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_declaration(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_declaration___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_declaration;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -16585,13 +16206,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_section___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_section___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_section___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_section___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_section___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_section___elambda__1___closed__5() {
@@ -16643,197 +16263,187 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_section___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_section___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_section___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_section___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_45; lean_object* x_46; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_45 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_46 = lean_ctor_get(x_45, 3);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_47; lean_object* x_48; 
+x_47 = lean_ctor_get(x_45, 0);
+lean_inc(x_47);
+x_48 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_47);
+lean_dec(x_47);
+if (lean_obj_tag(x_48) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_48; lean_object* x_49; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_48 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_49 = lean_ctor_get(x_48, 3);
+lean_object* x_49; lean_object* x_50; uint8_t x_51; 
+x_49 = lean_ctor_get(x_48, 1);
 lean_inc(x_49);
-if (lean_obj_tag(x_49) == 0)
-{
-lean_object* x_50; lean_object* x_51; 
-x_50 = lean_ctor_get(x_48, 0);
-lean_inc(x_50);
-x_51 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_50);
-lean_dec(x_50);
-if (lean_obj_tag(x_51) == 2)
-{
-lean_object* x_52; lean_object* x_53; uint8_t x_54; 
-x_52 = lean_ctor_get(x_51, 1);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_Parser_Command_section___elambda__1___closed__6;
-x_54 = lean_string_dec_eq(x_52, x_53);
-lean_dec(x_52);
-if (x_54 == 0)
-{
-lean_object* x_55; lean_object* x_56; 
-x_55 = l_Lean_Parser_Command_section___elambda__1___closed__9;
-lean_inc(x_10);
-x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_55, x_10);
-x_19 = x_56;
-goto block_47;
-}
-else
-{
-x_19 = x_48;
-goto block_47;
-}
-}
-else
-{
-lean_object* x_57; lean_object* x_58; 
-lean_dec(x_51);
-x_57 = l_Lean_Parser_Command_section___elambda__1___closed__9;
-lean_inc(x_10);
-x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_57, x_10);
-x_19 = x_58;
-goto block_47;
-}
-}
-else
-{
-lean_object* x_59; lean_object* x_60; 
+lean_dec(x_48);
+x_50 = l_Lean_Parser_Command_section___elambda__1___closed__6;
+x_51 = lean_string_dec_eq(x_49, x_50);
 lean_dec(x_49);
-x_59 = l_Lean_Parser_Command_section___elambda__1___closed__9;
-lean_inc(x_10);
-x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_59, x_10);
-x_19 = x_60;
-goto block_47;
-}
-block_47:
+if (x_51 == 0)
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_52; lean_object* x_53; 
+x_52 = l_Lean_Parser_Command_section___elambda__1___closed__9;
+lean_inc(x_7);
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_7);
+x_16 = x_53;
+goto block_44;
+}
+else
+{
+x_16 = x_45;
+goto block_44;
+}
+}
+else
+{
+lean_object* x_54; lean_object* x_55; 
+lean_dec(x_48);
+x_54 = l_Lean_Parser_Command_section___elambda__1___closed__9;
+lean_inc(x_7);
+x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_7);
+x_16 = x_55;
+goto block_44;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; 
+lean_dec(x_46);
+x_56 = l_Lean_Parser_Command_section___elambda__1___closed__9;
+lean_inc(x_7);
+x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_7);
+x_16 = x_57;
+goto block_44;
+}
+block_44:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_16, 0);
+lean_inc(x_18);
+x_19 = lean_array_get_size(x_18);
+lean_dec(x_18);
+x_20 = lean_ctor_get(x_16, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_21 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = lean_ctor_get(x_19, 1);
-lean_inc(x_23);
-x_24 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_23);
-x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_22);
-x_28 = l_Lean_Parser_Command_section___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_18);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_13, x_10);
-lean_dec(x_10);
-return x_30;
-}
-else
-{
-lean_object* x_31; uint8_t x_32; 
-lean_dec(x_25);
-x_31 = lean_ctor_get(x_24, 1);
-lean_inc(x_31);
-x_32 = lean_nat_dec_eq(x_31, x_23);
-lean_dec(x_31);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_23);
-x_33 = l_Lean_nullKind;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_24, x_33, x_22);
-x_35 = l_Lean_Parser_Command_section___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_18);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_13, x_10);
-lean_dec(x_10);
-return x_37;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_38 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
-x_39 = l_Lean_nullKind;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_22);
-x_41 = l_Lean_Parser_Command_section___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_18);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_13, x_10);
-lean_dec(x_10);
-return x_43;
-}
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
 lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_19);
+x_25 = l_Lean_Parser_Command_section___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; uint8_t x_29; 
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_21, 1);
+lean_inc(x_28);
+x_29 = lean_nat_dec_eq(x_28, x_20);
+lean_dec(x_28);
+if (x_29 == 0)
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_20);
+x_30 = l_Lean_nullKind;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_21, x_30, x_19);
+x_32 = l_Lean_Parser_Command_section___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
+}
+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; 
+x_35 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+x_36 = l_Lean_nullKind;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_19);
+x_38 = l_Lean_Parser_Command_section___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+}
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_44 = l_Lean_Parser_Command_section___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_19, x_44, x_18);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_13, x_10);
-lean_dec(x_10);
-return x_46;
+x_41 = l_Lean_Parser_Command_section___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_16, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
 }
 }
 }
@@ -16854,7 +16464,7 @@ lean_object* _init_l_Lean_Parser_Command_section___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_optionaInfo(x_2);
@@ -16897,7 +16507,7 @@ lean_object* _init_l_Lean_Parser_Command_section___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_section___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_section___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -16924,10 +16534,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_section(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_section___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_section___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_section;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -16964,13 +16574,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_namespace___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_namespace___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_namespace___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_namespace___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_namespace___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_namespace___elambda__1___closed__5() {
@@ -17022,149 +16631,139 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_namespace___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_namespace___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_namespace___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_namespace___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_26; lean_object* x_27; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
+lean_inc(x_28);
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
+lean_dec(x_28);
+if (lean_obj_tag(x_29) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Command_namespace___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Command_namespace___elambda__1___closed__9;
-lean_inc(x_10);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_10);
-x_19 = x_37;
-goto block_28;
-}
-else
-{
-x_19 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Command_namespace___elambda__1___closed__9;
-lean_inc(x_10);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_10);
-x_19 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+lean_dec(x_29);
+x_31 = l_Lean_Parser_Command_namespace___elambda__1___closed__6;
+x_32 = lean_string_dec_eq(x_30, x_31);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Command_namespace___elambda__1___closed__9;
-lean_inc(x_10);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_10);
-x_19 = x_41;
-goto block_28;
-}
-block_28:
+if (x_32 == 0)
 {
-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_24; 
-x_21 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_namespace___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_Parser_Command_namespace___elambda__1___closed__9;
+lean_inc(x_7);
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_7);
+x_16 = x_34;
+goto block_25;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+x_16 = x_26;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_29);
+x_35 = l_Lean_Parser_Command_namespace___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_7);
+x_16 = x_36;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_27);
+x_37 = l_Lean_Parser_Command_namespace___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_7);
+x_16 = x_38;
+goto block_25;
+}
+block_25:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Command_namespace___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_namespace___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_22 = l_Lean_Parser_Command_namespace___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -17185,7 +16784,7 @@ lean_object* _init_l_Lean_Parser_Command_namespace___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_namespace___closed__1;
@@ -17219,7 +16818,7 @@ lean_object* _init_l_Lean_Parser_Command_namespace___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_namespace___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_namespace___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -17246,10 +16845,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_namespace(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_namespace___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_namespace___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_namespace;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -17286,13 +16885,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_end___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_end___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_end___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_end___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_end___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_end___elambda__1___closed__5() {
@@ -17344,197 +16942,187 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_end___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_end___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_end___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_end___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_45; lean_object* x_46; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_45 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_46 = lean_ctor_get(x_45, 3);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_47; lean_object* x_48; 
+x_47 = lean_ctor_get(x_45, 0);
+lean_inc(x_47);
+x_48 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_47);
+lean_dec(x_47);
+if (lean_obj_tag(x_48) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_48; lean_object* x_49; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_48 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_49 = lean_ctor_get(x_48, 3);
+lean_object* x_49; lean_object* x_50; uint8_t x_51; 
+x_49 = lean_ctor_get(x_48, 1);
 lean_inc(x_49);
-if (lean_obj_tag(x_49) == 0)
-{
-lean_object* x_50; lean_object* x_51; 
-x_50 = lean_ctor_get(x_48, 0);
-lean_inc(x_50);
-x_51 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_50);
-lean_dec(x_50);
-if (lean_obj_tag(x_51) == 2)
-{
-lean_object* x_52; lean_object* x_53; uint8_t x_54; 
-x_52 = lean_ctor_get(x_51, 1);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_Parser_Command_end___elambda__1___closed__6;
-x_54 = lean_string_dec_eq(x_52, x_53);
-lean_dec(x_52);
-if (x_54 == 0)
-{
-lean_object* x_55; lean_object* x_56; 
-x_55 = l_Lean_Parser_Command_end___elambda__1___closed__9;
-lean_inc(x_10);
-x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_55, x_10);
-x_19 = x_56;
-goto block_47;
-}
-else
-{
-x_19 = x_48;
-goto block_47;
-}
-}
-else
-{
-lean_object* x_57; lean_object* x_58; 
-lean_dec(x_51);
-x_57 = l_Lean_Parser_Command_end___elambda__1___closed__9;
-lean_inc(x_10);
-x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_57, x_10);
-x_19 = x_58;
-goto block_47;
-}
-}
-else
-{
-lean_object* x_59; lean_object* x_60; 
+lean_dec(x_48);
+x_50 = l_Lean_Parser_Command_end___elambda__1___closed__6;
+x_51 = lean_string_dec_eq(x_49, x_50);
 lean_dec(x_49);
-x_59 = l_Lean_Parser_Command_end___elambda__1___closed__9;
-lean_inc(x_10);
-x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_59, x_10);
-x_19 = x_60;
-goto block_47;
-}
-block_47:
+if (x_51 == 0)
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_52; lean_object* x_53; 
+x_52 = l_Lean_Parser_Command_end___elambda__1___closed__9;
+lean_inc(x_7);
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_7);
+x_16 = x_53;
+goto block_44;
+}
+else
+{
+x_16 = x_45;
+goto block_44;
+}
+}
+else
+{
+lean_object* x_54; lean_object* x_55; 
+lean_dec(x_48);
+x_54 = l_Lean_Parser_Command_end___elambda__1___closed__9;
+lean_inc(x_7);
+x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_7);
+x_16 = x_55;
+goto block_44;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; 
+lean_dec(x_46);
+x_56 = l_Lean_Parser_Command_end___elambda__1___closed__9;
+lean_inc(x_7);
+x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_7);
+x_16 = x_57;
+goto block_44;
+}
+block_44:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_16, 0);
+lean_inc(x_18);
+x_19 = lean_array_get_size(x_18);
+lean_dec(x_18);
+x_20 = lean_ctor_get(x_16, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_21 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = lean_ctor_get(x_19, 1);
-lean_inc(x_23);
-x_24 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_23);
-x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_22);
-x_28 = l_Lean_Parser_Command_end___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_18);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_13, x_10);
-lean_dec(x_10);
-return x_30;
-}
-else
-{
-lean_object* x_31; uint8_t x_32; 
-lean_dec(x_25);
-x_31 = lean_ctor_get(x_24, 1);
-lean_inc(x_31);
-x_32 = lean_nat_dec_eq(x_31, x_23);
-lean_dec(x_31);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_23);
-x_33 = l_Lean_nullKind;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_24, x_33, x_22);
-x_35 = l_Lean_Parser_Command_end___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_18);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_13, x_10);
-lean_dec(x_10);
-return x_37;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_38 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
-x_39 = l_Lean_nullKind;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_22);
-x_41 = l_Lean_Parser_Command_end___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_18);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_13, x_10);
-lean_dec(x_10);
-return x_43;
-}
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
 lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_19);
+x_25 = l_Lean_Parser_Command_end___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; uint8_t x_29; 
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_21, 1);
+lean_inc(x_28);
+x_29 = lean_nat_dec_eq(x_28, x_20);
+lean_dec(x_28);
+if (x_29 == 0)
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_20);
+x_30 = l_Lean_nullKind;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_21, x_30, x_19);
+x_32 = l_Lean_Parser_Command_end___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
+}
+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; 
+x_35 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+x_36 = l_Lean_nullKind;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_19);
+x_38 = l_Lean_Parser_Command_end___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+}
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_44 = l_Lean_Parser_Command_end___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_19, x_44, x_18);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_13, x_10);
-lean_dec(x_10);
-return x_46;
+x_41 = l_Lean_Parser_Command_end___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_16, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
 }
 }
 }
@@ -17587,7 +17175,7 @@ lean_object* _init_l_Lean_Parser_Command_end___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_end___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_end___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -17614,10 +17202,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_end(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_end___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_end___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_end;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -17654,13 +17242,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_variable___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_variable___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_variable___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_variable___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_variable___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_variable___elambda__1___closed__5() {
@@ -17712,149 +17299,145 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_variable___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_variable___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_variable___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Command_variable___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_15);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Command_variable___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Command_variable___elambda__1___closed__9;
-lean_inc(x_10);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_10);
-x_19 = x_37;
-goto block_28;
-}
-else
-{
-x_19 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Command_variable___elambda__1___closed__9;
-lean_inc(x_10);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_10);
-x_19 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Command_variable___elambda__1___closed__9;
-lean_inc(x_10);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_10);
-x_19 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-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_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Command_variable___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_variable___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Command_variable___elambda__1___closed__9;
+lean_inc(x_9);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_9);
+x_18 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+x_18 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Command_variable___elambda__1___closed__9;
+lean_inc(x_9);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_9);
+x_18 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Command_variable___elambda__1___closed__9;
+lean_inc(x_9);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_9);
+x_18 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_19; 
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = lean_apply_2(x_4, x_1, x_18);
+x_21 = l_Lean_Parser_Command_variable___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_17);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_12, x_9);
+lean_dec(x_9);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_19);
+lean_dec(x_4);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_variable___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_24 = l_Lean_Parser_Command_variable___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_17);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_12, x_9);
+lean_dec(x_9);
+return x_26;
 }
 }
 }
@@ -17909,7 +17492,7 @@ lean_object* _init_l_Lean_Parser_Command_variable___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_variable___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_variable___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -17936,10 +17519,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_variable(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_variable___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_variable___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_variable;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -17976,13 +17559,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_variables___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_variables___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_variables___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_variables___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_variables___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_variables___elambda__1___closed__5() {
@@ -18034,181 +17616,174 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_variables___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_variables___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_variables___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Command_variables___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_41; lean_object* x_42; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_41 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_42 = lean_ctor_get(x_41, 3);
-lean_inc(x_42);
-if (lean_obj_tag(x_42) == 0)
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_39; lean_object* x_40; 
+lean_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+lean_inc(x_1);
+x_39 = l_Lean_Parser_tokenFn(x_1, x_15);
+x_40 = lean_ctor_get(x_39, 3);
+lean_inc(x_40);
+if (lean_obj_tag(x_40) == 0)
 {
-lean_object* x_43; lean_object* x_44; 
-x_43 = lean_ctor_get(x_41, 0);
+lean_object* x_41; lean_object* x_42; 
+x_41 = lean_ctor_get(x_39, 0);
+lean_inc(x_41);
+x_42 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_41);
+lean_dec(x_41);
+if (lean_obj_tag(x_42) == 2)
+{
+lean_object* x_43; lean_object* x_44; uint8_t x_45; 
+x_43 = lean_ctor_get(x_42, 1);
 lean_inc(x_43);
-x_44 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_43);
+lean_dec(x_42);
+x_44 = l_Lean_Parser_Command_variables___elambda__1___closed__6;
+x_45 = lean_string_dec_eq(x_43, x_44);
 lean_dec(x_43);
-if (lean_obj_tag(x_44) == 2)
+if (x_45 == 0)
 {
-lean_object* x_45; lean_object* x_46; uint8_t x_47; 
-x_45 = lean_ctor_get(x_44, 1);
-lean_inc(x_45);
-lean_dec(x_44);
-x_46 = l_Lean_Parser_Command_variables___elambda__1___closed__6;
-x_47 = lean_string_dec_eq(x_45, x_46);
-lean_dec(x_45);
-if (x_47 == 0)
+lean_object* x_46; lean_object* x_47; 
+x_46 = l_Lean_Parser_Command_variables___elambda__1___closed__9;
+lean_inc(x_9);
+x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_46, x_9);
+x_18 = x_47;
+goto block_38;
+}
+else
+{
+x_18 = x_39;
+goto block_38;
+}
+}
+else
 {
 lean_object* x_48; lean_object* x_49; 
+lean_dec(x_42);
 x_48 = l_Lean_Parser_Command_variables___elambda__1___closed__9;
-lean_inc(x_10);
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_10);
-x_19 = x_49;
-goto block_40;
-}
-else
-{
-x_19 = x_41;
-goto block_40;
+lean_inc(x_9);
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_48, x_9);
+x_18 = x_49;
+goto block_38;
 }
 }
 else
 {
 lean_object* x_50; lean_object* x_51; 
-lean_dec(x_44);
+lean_dec(x_40);
 x_50 = l_Lean_Parser_Command_variables___elambda__1___closed__9;
-lean_inc(x_10);
-x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_10);
-x_19 = x_51;
-goto block_40;
+lean_inc(x_9);
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_50, x_9);
+x_18 = x_51;
+goto block_38;
 }
-}
-else
+block_38:
 {
-lean_object* x_52; lean_object* x_53; 
-lean_dec(x_42);
-x_52 = l_Lean_Parser_Command_variables___elambda__1___closed__9;
-lean_inc(x_10);
-x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_10);
-x_19 = x_53;
-goto block_40;
-}
-block_40:
+lean_object* x_19; 
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = lean_ctor_get(x_18, 0);
 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_24; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-lean_inc(x_5);
-lean_inc(x_2);
-lean_inc(x_1);
-x_23 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-uint8_t 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; 
-x_25 = 0;
-x_26 = l_Lean_Parser_manyAux___main(x_25, x_5, x_1, x_2, x_23);
-x_27 = l_Lean_nullKind;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_22);
-x_29 = l_Lean_Parser_Command_variables___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_18);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_13, x_10);
-lean_dec(x_10);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_24);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_32 = l_Lean_nullKind;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_23, x_32, x_22);
-x_34 = l_Lean_Parser_Command_variables___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_18);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
-lean_dec(x_10);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_21 = lean_array_get_size(x_20);
 lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_inc(x_4);
+lean_inc(x_1);
+x_22 = lean_apply_2(x_4, x_1, x_18);
+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_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_24 = l_Lean_Parser_manyAux___main(x_4, x_1, x_22);
+x_25 = l_Lean_nullKind;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_21);
+x_27 = l_Lean_Parser_Command_variables___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_17);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_12, x_9);
+lean_dec(x_9);
+return x_29;
+}
+else
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_23);
+lean_dec(x_4);
 lean_dec(x_1);
-x_37 = l_Lean_Parser_Command_variables___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_19, x_37, x_18);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_13, x_10);
-lean_dec(x_10);
-return x_39;
+x_30 = l_Lean_nullKind;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_21);
+x_32 = l_Lean_Parser_Command_variables___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_17);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_12, x_9);
+lean_dec(x_9);
+return x_34;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_19);
+lean_dec(x_4);
+lean_dec(x_1);
+x_35 = l_Lean_Parser_Command_variables___elambda__1___closed__2;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_18, x_35, x_17);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_12, x_9);
+lean_dec(x_9);
+return x_37;
 }
 }
 }
@@ -18263,7 +17838,7 @@ lean_object* _init_l_Lean_Parser_Command_variables___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_variables___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_variables___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -18290,10 +17865,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_variables(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_variables___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_variables___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_variables;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -18330,13 +17905,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_universe___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_universe___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_universe___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_universe___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_universe___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_universe___elambda__1___closed__5() {
@@ -18388,149 +17962,139 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_universe___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_universe___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_universe___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_universe___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_26; lean_object* x_27; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
+lean_inc(x_28);
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
+lean_dec(x_28);
+if (lean_obj_tag(x_29) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Command_universe___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Command_universe___elambda__1___closed__9;
-lean_inc(x_10);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_10);
-x_19 = x_37;
-goto block_28;
-}
-else
-{
-x_19 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Command_universe___elambda__1___closed__9;
-lean_inc(x_10);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_10);
-x_19 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+lean_dec(x_29);
+x_31 = l_Lean_Parser_Command_universe___elambda__1___closed__6;
+x_32 = lean_string_dec_eq(x_30, x_31);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Command_universe___elambda__1___closed__9;
-lean_inc(x_10);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_10);
-x_19 = x_41;
-goto block_28;
-}
-block_28:
+if (x_32 == 0)
 {
-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_24; 
-x_21 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_universe___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_Parser_Command_universe___elambda__1___closed__9;
+lean_inc(x_7);
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_7);
+x_16 = x_34;
+goto block_25;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+x_16 = x_26;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_29);
+x_35 = l_Lean_Parser_Command_universe___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_7);
+x_16 = x_36;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_27);
+x_37 = l_Lean_Parser_Command_universe___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_7);
+x_16 = x_38;
+goto block_25;
+}
+block_25:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Command_universe___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_universe___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_22 = l_Lean_Parser_Command_universe___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -18551,7 +18115,7 @@ lean_object* _init_l_Lean_Parser_Command_universe___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_universe___closed__1;
@@ -18585,7 +18149,7 @@ lean_object* _init_l_Lean_Parser_Command_universe___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_universe___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_universe___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -18612,10 +18176,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_universe(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_universe___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_universe___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_universe;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -18652,13 +18216,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_universes___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_universes___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_universes___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_universes___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_universes___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_universes___elambda__1___closed__5() {
@@ -18710,181 +18273,166 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_universes___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_universes___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_universes___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_universes___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_41; lean_object* x_42; 
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_41 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_42 = lean_ctor_get(x_41, 3);
-lean_inc(x_42);
-if (lean_obj_tag(x_42) == 0)
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_43; lean_object* x_44; 
-x_43 = lean_ctor_get(x_41, 0);
-lean_inc(x_43);
-x_44 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_43);
-lean_dec(x_43);
-if (lean_obj_tag(x_44) == 2)
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
 {
-lean_object* x_45; lean_object* x_46; uint8_t x_47; 
-x_45 = lean_ctor_get(x_44, 1);
-lean_inc(x_45);
-lean_dec(x_44);
-x_46 = l_Lean_Parser_Command_universes___elambda__1___closed__6;
-x_47 = lean_string_dec_eq(x_45, x_46);
-lean_dec(x_45);
-if (x_47 == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_37; lean_object* x_38; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_37 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_38 = lean_ctor_get(x_37, 3);
+lean_inc(x_38);
+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_Lean_Parser_checkStackTopFn___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_Command_universes___elambda__1___closed__6;
+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_Command_universes___elambda__1___closed__9;
+lean_inc(x_7);
+x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_7);
+x_16 = x_45;
+goto block_36;
+}
+else
+{
+x_16 = x_37;
+goto block_36;
+}
+}
+else
+{
+lean_object* x_46; lean_object* x_47; 
+lean_dec(x_40);
+x_46 = l_Lean_Parser_Command_universes___elambda__1___closed__9;
+lean_inc(x_7);
+x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_7);
+x_16 = x_47;
+goto block_36;
+}
+}
+else
 {
 lean_object* x_48; lean_object* x_49; 
+lean_dec(x_38);
 x_48 = l_Lean_Parser_Command_universes___elambda__1___closed__9;
-lean_inc(x_10);
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_10);
-x_19 = x_49;
-goto block_40;
+lean_inc(x_7);
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_7);
+x_16 = x_49;
+goto block_36;
 }
-else
+block_36:
 {
-x_19 = x_41;
-goto block_40;
-}
-}
-else
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_50; lean_object* x_51; 
-lean_dec(x_44);
-x_50 = l_Lean_Parser_Command_universes___elambda__1___closed__9;
-lean_inc(x_10);
-x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_10);
-x_19 = x_51;
-goto block_40;
-}
-}
-else
-{
-lean_object* x_52; lean_object* x_53; 
-lean_dec(x_42);
-x_52 = l_Lean_Parser_Command_universes___elambda__1___closed__9;
-lean_inc(x_10);
-x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_10);
-x_19 = x_53;
-goto block_40;
-}
-block_40:
-{
-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_24; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-lean_inc(x_5);
-lean_inc(x_2);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = lean_ctor_get(x_16, 0);
+lean_inc(x_18);
+x_19 = lean_array_get_size(x_18);
+lean_dec(x_18);
 lean_inc(x_1);
-x_23 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
+x_20 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
 {
-uint8_t 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; 
-x_25 = 0;
-x_26 = l_Lean_Parser_manyAux___main(x_25, x_5, x_1, x_2, x_23);
-x_27 = l_Lean_nullKind;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_22);
-x_29 = l_Lean_Parser_Command_universes___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_18);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_13, x_10);
-lean_dec(x_10);
-return x_31;
+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 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(x_1, x_20);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_19);
+x_25 = l_Lean_Parser_Command_universes___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_24);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_32 = l_Lean_nullKind;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_23, x_32, x_22);
-x_34 = l_Lean_Parser_Command_universes___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_18);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
-lean_dec(x_10);
-return x_36;
+x_28 = l_Lean_nullKind;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_19);
+x_30 = l_Lean_Parser_Command_universes___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
 }
 }
 else
 {
-lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_37 = l_Lean_Parser_Command_universes___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_19, x_37, x_18);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_13, x_10);
-lean_dec(x_10);
-return x_39;
+x_33 = l_Lean_Parser_Command_universes___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_16, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
 }
 }
 }
@@ -18905,7 +18453,7 @@ lean_object* _init_l_Lean_Parser_Command_universes___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_universes___closed__1;
@@ -18939,7 +18487,7 @@ lean_object* _init_l_Lean_Parser_Command_universes___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_universes___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_universes___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -18966,10 +18514,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_universes(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_universes___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_universes___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_universes;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -19006,13 +18554,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_check___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_check___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_check___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_check___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_check___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_check___elambda__1___closed__5() {
@@ -19064,141 +18611,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_check___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_check___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_check___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_check___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Command_check___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Command_check___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Command_check___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Command_check___elambda__1___closed__9;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Command_check___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Command_check___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Command_check___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Command_check___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Command_check___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Command_check___elambda__1___closed__9;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Command_check___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Command_check___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -19219,7 +18766,7 @@ lean_object* _init_l_Lean_Parser_Command_check___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_check___closed__1;
@@ -19253,7 +18800,7 @@ lean_object* _init_l_Lean_Parser_Command_check___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_check___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_check___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -19280,10 +18827,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_check(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_check___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_check___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_check;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -19320,13 +18867,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_synth___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_synth___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_synth___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_synth___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_synth___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_synth___elambda__1___closed__5() {
@@ -19378,141 +18924,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_synth___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_synth___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_synth___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_synth___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Command_synth___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Command_synth___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Command_synth___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Command_synth___elambda__1___closed__9;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Command_synth___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Command_synth___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Command_synth___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Command_synth___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Command_synth___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Command_synth___elambda__1___closed__9;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Command_synth___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Command_synth___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -19533,7 +19079,7 @@ lean_object* _init_l_Lean_Parser_Command_synth___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_synth___closed__1;
@@ -19567,7 +19113,7 @@ lean_object* _init_l_Lean_Parser_Command_synth___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_synth___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_synth___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -19594,10 +19140,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_synth(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_synth___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_synth___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_synth;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -19634,13 +19180,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_exit___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_exit___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_exit___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_exit___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_exit___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_exit___elambda__1___closed__5() {
@@ -19692,125 +19237,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_exit___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_exit___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_exit___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_exit___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_exit___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_exit___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_exit___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_exit___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_exit___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_exit___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_exit___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_exit___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -19852,7 +19397,7 @@ lean_object* _init_l_Lean_Parser_Command_exit___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_exit___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_exit___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -19879,10 +19424,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_exit(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_exit___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_exit;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -19919,13 +19464,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_resolve__name___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_resolve__name___elambda__1___closed__5() {
@@ -19977,149 +19521,139 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_resolve__name___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_resolve__name___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_26; lean_object* x_27; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
+lean_inc(x_28);
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
+lean_dec(x_28);
+if (lean_obj_tag(x_29) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__9;
-lean_inc(x_10);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_10);
-x_19 = x_37;
-goto block_28;
-}
-else
-{
-x_19 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__9;
-lean_inc(x_10);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_10);
-x_19 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+lean_dec(x_29);
+x_31 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__6;
+x_32 = lean_string_dec_eq(x_30, x_31);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__9;
-lean_inc(x_10);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_10);
-x_19 = x_41;
-goto block_28;
-}
-block_28:
+if (x_32 == 0)
 {
-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_24; 
-x_21 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__9;
+lean_inc(x_7);
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_7);
+x_16 = x_34;
+goto block_25;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+x_16 = x_26;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_29);
+x_35 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_7);
+x_16 = x_36;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_27);
+x_37 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_7);
+x_16 = x_38;
+goto block_25;
+}
+block_25:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_22 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -20140,7 +19674,7 @@ lean_object* _init_l_Lean_Parser_Command_resolve__name___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_resolve__name___closed__1;
@@ -20174,7 +19708,7 @@ lean_object* _init_l_Lean_Parser_Command_resolve__name___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_resolve__name___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_resolve__name___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -20201,10 +19735,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_resolve__name(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_resolve__name___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_resolve__name;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -20241,13 +19775,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_init__quot___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_init__quot___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_init__quot___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_init__quot___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_init__quot___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_init__quot___elambda__1___closed__5() {
@@ -20291,125 +19824,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_init__quot___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_init__quot___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_init__quot___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_init__quot___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_init__quot___elambda__1___closed__5;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_init__quot___elambda__1___closed__8;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_init__quot___elambda__1___closed__8;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_init__quot___elambda__1___closed__8;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_init__quot___elambda__1___closed__5;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_init__quot___elambda__1___closed__8;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_init__quot___elambda__1___closed__8;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_init__quot___elambda__1___closed__8;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -20451,7 +19984,7 @@ lean_object* _init_l_Lean_Parser_Command_init__quot___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_init__quot___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_init__quot___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -20478,10 +20011,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_init__quot(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_init__quot___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_init__quot;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -20518,13 +20051,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_set__option___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_set__option___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_set__option___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_set__option___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_set__option___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_set__option___elambda__1___closed__5() {
@@ -20634,334 +20166,298 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_set__option___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_set__option___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_4 = l_Lean_Parser_Term_str___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_set__option___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Level_num___elambda__1___closed__5;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_9 = lean_ctor_get(x_8, 1);
-lean_inc(x_9);
-x_10 = l_Lean_Parser_Command_set__option___elambda__1___closed__4;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_3, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_3, 1);
-lean_inc(x_14);
-lean_inc(x_2);
 lean_inc(x_1);
-x_15 = lean_apply_3(x_11, x_1, x_2, x_3);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_14);
-lean_dec(x_13);
-lean_dec(x_9);
 lean_dec(x_7);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_15;
+return x_8;
 }
 else
 {
-lean_object* x_17; lean_object* x_18; uint8_t x_19; 
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-lean_dec(x_16);
-x_18 = lean_ctor_get(x_15, 1);
-lean_inc(x_18);
-x_19 = lean_nat_dec_eq(x_18, x_14);
-lean_dec(x_18);
-if (x_19 == 0)
-{
-lean_dec(x_17);
-lean_dec(x_14);
-lean_dec(x_13);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
 lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_15;
+return x_8;
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_94; lean_object* x_95; 
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_87; lean_object* x_88; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_20 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_21 = lean_ctor_get(x_20, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-lean_inc(x_2);
-x_94 = l_Lean_Parser_tokenFn(x_2, x_20);
-x_95 = lean_ctor_get(x_94, 3);
-lean_inc(x_95);
-if (lean_obj_tag(x_95) == 0)
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_87 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_88 = lean_ctor_get(x_87, 3);
+lean_inc(x_88);
+if (lean_obj_tag(x_88) == 0)
+{
+lean_object* x_89; lean_object* x_90; 
+x_89 = lean_ctor_get(x_87, 0);
+lean_inc(x_89);
+x_90 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_89);
+lean_dec(x_89);
+if (lean_obj_tag(x_90) == 2)
+{
+lean_object* x_91; lean_object* x_92; uint8_t x_93; 
+x_91 = lean_ctor_get(x_90, 1);
+lean_inc(x_91);
+lean_dec(x_90);
+x_92 = l_Lean_Parser_Command_set__option___elambda__1___closed__6;
+x_93 = lean_string_dec_eq(x_91, x_92);
+lean_dec(x_91);
+if (x_93 == 0)
+{
+lean_object* x_94; lean_object* x_95; 
+x_94 = l_Lean_Parser_Command_set__option___elambda__1___closed__15;
+lean_inc(x_7);
+x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_87, x_94, x_7);
+x_16 = x_95;
+goto block_86;
+}
+else
+{
+x_16 = x_87;
+goto block_86;
+}
+}
+else
 {
 lean_object* x_96; lean_object* x_97; 
-x_96 = lean_ctor_get(x_94, 0);
-lean_inc(x_96);
-x_97 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_96);
-lean_dec(x_96);
-if (lean_obj_tag(x_97) == 2)
-{
-lean_object* x_98; lean_object* x_99; uint8_t x_100; 
-x_98 = lean_ctor_get(x_97, 1);
-lean_inc(x_98);
-lean_dec(x_97);
-x_99 = l_Lean_Parser_Command_set__option___elambda__1___closed__6;
-x_100 = lean_string_dec_eq(x_98, x_99);
-lean_dec(x_98);
-if (x_100 == 0)
-{
-lean_object* x_101; lean_object* x_102; 
-x_101 = l_Lean_Parser_Command_set__option___elambda__1___closed__15;
-lean_inc(x_14);
-x_102 = l_Lean_Parser_ParserState_mkErrorsAt(x_94, x_101, x_14);
-x_23 = x_102;
-goto block_93;
-}
-else
-{
-x_23 = x_94;
-goto block_93;
+lean_dec(x_90);
+x_96 = l_Lean_Parser_Command_set__option___elambda__1___closed__15;
+lean_inc(x_7);
+x_97 = l_Lean_Parser_ParserState_mkErrorsAt(x_87, x_96, x_7);
+x_16 = x_97;
+goto block_86;
 }
 }
 else
 {
-lean_object* x_103; lean_object* x_104; 
-lean_dec(x_97);
-x_103 = l_Lean_Parser_Command_set__option___elambda__1___closed__15;
-lean_inc(x_14);
-x_104 = l_Lean_Parser_ParserState_mkErrorsAt(x_94, x_103, x_14);
-x_23 = x_104;
-goto block_93;
+lean_object* x_98; lean_object* x_99; 
+lean_dec(x_88);
+x_98 = l_Lean_Parser_Command_set__option___elambda__1___closed__15;
+lean_inc(x_7);
+x_99 = l_Lean_Parser_ParserState_mkErrorsAt(x_87, x_98, x_7);
+x_16 = x_99;
+goto block_86;
 }
-}
-else
+block_86:
 {
-lean_object* x_105; lean_object* x_106; 
-lean_dec(x_95);
-x_105 = l_Lean_Parser_Command_set__option___elambda__1___closed__15;
-lean_inc(x_14);
-x_106 = l_Lean_Parser_ParserState_mkErrorsAt(x_94, x_105, x_14);
-x_23 = x_106;
-goto block_93;
-}
-block_93:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_24; 
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-lean_object* x_25; lean_object* x_26; 
-lean_inc(x_2);
+lean_object* x_18; lean_object* x_19; 
 lean_inc(x_1);
-x_25 = lean_apply_3(x_9, x_1, x_2, x_23);
+x_18 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+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; 
+x_20 = lean_ctor_get(x_18, 0);
+lean_inc(x_20);
+x_21 = lean_array_get_size(x_20);
+lean_dec(x_20);
+x_22 = lean_ctor_get(x_18, 1);
+lean_inc(x_22);
+x_23 = l_Lean_Parser_Command_set__option___elambda__1___closed__7;
+x_24 = l_Lean_Parser_Command_set__option___elambda__1___closed__10;
+lean_inc(x_1);
+x_25 = l_Lean_Parser_nonReservedSymbolFnAux(x_23, x_24, x_1, x_18);
 x_26 = lean_ctor_get(x_25, 3);
 lean_inc(x_26);
 if (lean_obj_tag(x_26) == 0)
 {
-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; 
-x_27 = lean_ctor_get(x_25, 0);
-lean_inc(x_27);
-x_28 = lean_array_get_size(x_27);
-lean_dec(x_27);
-x_29 = lean_ctor_get(x_25, 1);
-lean_inc(x_29);
-x_30 = l_Lean_Parser_Command_set__option___elambda__1___closed__7;
-x_31 = l_Lean_Parser_Command_set__option___elambda__1___closed__10;
-lean_inc(x_2);
-x_32 = l_Lean_Parser_nonReservedSymbolFnAux(x_30, x_31, x_2, x_25);
-x_33 = lean_ctor_get(x_32, 3);
-lean_inc(x_33);
-if (lean_obj_tag(x_33) == 0)
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_29);
-lean_dec(x_28);
-lean_dec(x_7);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_22);
+lean_dec(x_21);
 lean_dec(x_1);
-x_34 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_32, x_34, x_22);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_17, x_14);
-lean_dec(x_14);
-return x_36;
+x_27 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_25, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
 }
 else
 {
-lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_37 = lean_ctor_get(x_33, 0);
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_26, 0);
+lean_inc(x_30);
+lean_dec(x_26);
+x_31 = lean_ctor_get(x_25, 1);
+lean_inc(x_31);
+x_32 = lean_nat_dec_eq(x_31, x_22);
+lean_dec(x_31);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_30);
+lean_dec(x_22);
+lean_dec(x_21);
+lean_dec(x_1);
+x_33 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_25, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+else
+{
+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_inc(x_22);
+x_36 = l_Lean_Parser_ParserState_restore(x_25, x_21, x_22);
+lean_dec(x_21);
+x_37 = lean_ctor_get(x_36, 0);
 lean_inc(x_37);
-lean_dec(x_33);
-x_38 = lean_ctor_get(x_32, 1);
-lean_inc(x_38);
-x_39 = lean_nat_dec_eq(x_38, x_29);
-lean_dec(x_38);
-if (x_39 == 0)
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_38 = lean_array_get_size(x_37);
 lean_dec(x_37);
-lean_dec(x_29);
-lean_dec(x_28);
-lean_dec(x_7);
-lean_dec(x_5);
-lean_dec(x_2);
+x_39 = l_Lean_Parser_Command_set__option___elambda__1___closed__8;
+x_40 = l_Lean_Parser_Command_set__option___elambda__1___closed__12;
+lean_inc(x_1);
+x_41 = l_Lean_Parser_nonReservedSymbolFnAux(x_39, x_40, x_1, x_36);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_38);
 lean_dec(x_1);
-x_40 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
-x_41 = l_Lean_Parser_ParserState_mkNode(x_32, x_40, x_22);
-x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_17, x_14);
-lean_dec(x_14);
-return x_42;
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_41, x_30, x_22);
+lean_dec(x_22);
+x_44 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_inc(x_29);
-x_43 = l_Lean_Parser_ParserState_restore(x_32, x_28, x_29);
-lean_dec(x_28);
-x_44 = lean_ctor_get(x_43, 0);
-lean_inc(x_44);
-x_45 = lean_array_get_size(x_44);
-lean_dec(x_44);
-x_46 = l_Lean_Parser_Command_set__option___elambda__1___closed__8;
-x_47 = l_Lean_Parser_Command_set__option___elambda__1___closed__12;
-lean_inc(x_2);
-x_48 = l_Lean_Parser_nonReservedSymbolFnAux(x_46, x_47, x_2, x_43);
-x_49 = lean_ctor_get(x_48, 3);
-lean_inc(x_49);
-if (lean_obj_tag(x_49) == 0)
+lean_object* x_47; lean_object* x_48; uint8_t x_49; 
+x_47 = lean_ctor_get(x_42, 0);
+lean_inc(x_47);
+lean_dec(x_42);
+x_48 = lean_ctor_get(x_41, 1);
+lean_inc(x_48);
+x_49 = lean_nat_dec_eq(x_48, x_22);
+lean_dec(x_48);
+if (x_49 == 0)
 {
 lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_dec(x_45);
-lean_dec(x_7);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_47);
+lean_dec(x_38);
 lean_dec(x_1);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_48, x_37, x_29);
-lean_dec(x_29);
+x_50 = l_Lean_Parser_mergeOrElseErrors(x_41, x_30, x_22);
+lean_dec(x_22);
 x_51 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
-x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_22);
-x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_17, x_14);
-lean_dec(x_14);
+x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_15);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_10, x_7);
+lean_dec(x_7);
 return x_53;
 }
 else
 {
-lean_object* x_54; lean_object* x_55; uint8_t x_56; 
-x_54 = lean_ctor_get(x_49, 0);
-lean_inc(x_54);
-lean_dec(x_49);
-x_55 = lean_ctor_get(x_48, 1);
+lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+lean_inc(x_22);
+x_54 = l_Lean_Parser_ParserState_restore(x_41, x_38, x_22);
+lean_dec(x_38);
+x_55 = lean_ctor_get(x_54, 0);
 lean_inc(x_55);
-x_56 = lean_nat_dec_eq(x_55, x_29);
+x_56 = lean_array_get_size(x_55);
 lean_dec(x_55);
-if (x_56 == 0)
-{
-lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-lean_dec(x_54);
-lean_dec(x_45);
-lean_dec(x_7);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_57 = l_Lean_Parser_mergeOrElseErrors(x_48, x_37, x_29);
-lean_dec(x_29);
-x_58 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_22);
-x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_17, x_14);
-lean_dec(x_14);
-return x_60;
-}
-else
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-lean_inc(x_29);
-x_61 = l_Lean_Parser_ParserState_restore(x_48, x_45, x_29);
-lean_dec(x_45);
-x_62 = lean_ctor_get(x_61, 0);
-lean_inc(x_62);
-x_63 = lean_array_get_size(x_62);
-lean_dec(x_62);
-lean_inc(x_2);
 lean_inc(x_1);
-x_64 = lean_apply_3(x_5, x_1, x_2, x_61);
-x_65 = lean_ctor_get(x_64, 3);
+x_57 = l_Lean_Parser_strLit___elambda__1(x_1, x_54);
+x_58 = lean_ctor_get(x_57, 3);
+lean_inc(x_58);
+if (lean_obj_tag(x_58) == 0)
+{
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+lean_dec(x_56);
+lean_dec(x_1);
+x_59 = l_Lean_Parser_mergeOrElseErrors(x_57, x_47, x_22);
+x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_30, x_22);
+lean_dec(x_22);
+x_61 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+x_62 = l_Lean_Parser_ParserState_mkNode(x_60, x_61, x_15);
+x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_10, x_7);
+lean_dec(x_7);
+return x_63;
+}
+else
+{
+lean_object* x_64; lean_object* x_65; uint8_t x_66; 
+x_64 = lean_ctor_get(x_58, 0);
+lean_inc(x_64);
+lean_dec(x_58);
+x_65 = lean_ctor_get(x_57, 1);
 lean_inc(x_65);
-if (lean_obj_tag(x_65) == 0)
-{
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
-lean_dec(x_63);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-x_66 = l_Lean_Parser_mergeOrElseErrors(x_64, x_54, x_29);
-x_67 = l_Lean_Parser_mergeOrElseErrors(x_66, x_37, x_29);
-lean_dec(x_29);
-x_68 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_67, x_68, x_22);
-x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_17, x_14);
-lean_dec(x_14);
-return x_70;
-}
-else
-{
-lean_object* x_71; lean_object* x_72; uint8_t x_73; 
-x_71 = lean_ctor_get(x_65, 0);
-lean_inc(x_71);
+x_66 = lean_nat_dec_eq(x_65, x_22);
 lean_dec(x_65);
-x_72 = lean_ctor_get(x_64, 1);
-lean_inc(x_72);
-x_73 = lean_nat_dec_eq(x_72, x_29);
-lean_dec(x_72);
-if (x_73 == 0)
+if (x_66 == 0)
 {
-lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
-lean_dec(x_71);
-lean_dec(x_63);
-lean_dec(x_7);
-lean_dec(x_2);
+lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+lean_dec(x_64);
+lean_dec(x_56);
 lean_dec(x_1);
-x_74 = l_Lean_Parser_mergeOrElseErrors(x_64, x_54, x_29);
-x_75 = l_Lean_Parser_mergeOrElseErrors(x_74, x_37, x_29);
-lean_dec(x_29);
-x_76 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
-x_77 = l_Lean_Parser_ParserState_mkNode(x_75, x_76, x_22);
-x_78 = l_Lean_Parser_mergeOrElseErrors(x_77, x_17, x_14);
-lean_dec(x_14);
-return x_78;
+x_67 = l_Lean_Parser_mergeOrElseErrors(x_57, x_47, x_22);
+x_68 = l_Lean_Parser_mergeOrElseErrors(x_67, x_30, x_22);
+lean_dec(x_22);
+x_69 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+x_70 = l_Lean_Parser_ParserState_mkNode(x_68, x_69, x_15);
+x_71 = l_Lean_Parser_mergeOrElseErrors(x_70, x_10, x_7);
+lean_dec(x_7);
+return x_71;
 }
 else
 {
-lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-lean_inc(x_29);
-x_79 = l_Lean_Parser_ParserState_restore(x_64, x_63, x_29);
-lean_dec(x_63);
-x_80 = lean_apply_3(x_7, x_1, x_2, x_79);
-x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_71, x_29);
-x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_54, x_29);
-x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_37, x_29);
-lean_dec(x_29);
-x_84 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
-x_85 = l_Lean_Parser_ParserState_mkNode(x_83, x_84, x_22);
-x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_17, x_14);
-lean_dec(x_14);
-return x_86;
+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_inc(x_22);
+x_72 = l_Lean_Parser_ParserState_restore(x_57, x_56, x_22);
+lean_dec(x_56);
+x_73 = l_Lean_Parser_numLit___elambda__1(x_1, x_72);
+x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_64, x_22);
+x_75 = l_Lean_Parser_mergeOrElseErrors(x_74, x_47, x_22);
+x_76 = l_Lean_Parser_mergeOrElseErrors(x_75, x_30, x_22);
+lean_dec(x_22);
+x_77 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+x_78 = l_Lean_Parser_ParserState_mkNode(x_76, x_77, x_15);
+x_79 = l_Lean_Parser_mergeOrElseErrors(x_78, x_10, x_7);
+lean_dec(x_7);
+return x_79;
 }
 }
 }
@@ -20971,33 +20467,26 @@ return x_86;
 }
 else
 {
-lean_object* x_87; lean_object* x_88; lean_object* x_89; 
-lean_dec(x_26);
-lean_dec(x_7);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_80; lean_object* x_81; lean_object* x_82; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_87 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
-x_88 = l_Lean_Parser_ParserState_mkNode(x_25, x_87, x_22);
-x_89 = l_Lean_Parser_mergeOrElseErrors(x_88, x_17, x_14);
-lean_dec(x_14);
-return x_89;
+x_80 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+x_81 = l_Lean_Parser_ParserState_mkNode(x_18, x_80, x_15);
+x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_10, x_7);
+lean_dec(x_7);
+return x_82;
 }
 }
 else
 {
-lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-lean_dec(x_24);
-lean_dec(x_9);
-lean_dec(x_7);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_90 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
-x_91 = l_Lean_Parser_ParserState_mkNode(x_23, x_90, x_22);
-x_92 = l_Lean_Parser_mergeOrElseErrors(x_91, x_17, x_14);
-lean_dec(x_14);
-return x_92;
+x_83 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+x_84 = l_Lean_Parser_ParserState_mkNode(x_16, x_83, x_15);
+x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_10, x_7);
+lean_dec(x_7);
+return x_85;
 }
 }
 }
@@ -21058,7 +20547,7 @@ lean_object* _init_l_Lean_Parser_Command_set__option___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_set__option___closed__5;
@@ -21102,7 +20591,7 @@ lean_object* _init_l_Lean_Parser_Command_set__option___closed__10() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_set__option___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_set__option___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -21129,10 +20618,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_set__option(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_set__option___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_set__option;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -21169,13 +20658,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_attribute___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_attribute___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_attribute___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_attribute___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_attribute___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_attribute___elambda__1___closed__5() {
@@ -21276,485 +20764,460 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_attribute___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_attribute___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_attribute___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_attribute___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_41; lean_object* x_68; lean_object* x_88; lean_object* x_108; lean_object* x_120; lean_object* x_121; 
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_120 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_121 = lean_ctor_get(x_120, 3);
-lean_inc(x_121);
-if (lean_obj_tag(x_121) == 0)
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_37; lean_object* x_63; lean_object* x_83; lean_object* x_103; lean_object* x_115; lean_object* x_116; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_115 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_116 = lean_ctor_get(x_115, 3);
+lean_inc(x_116);
+if (lean_obj_tag(x_116) == 0)
+{
+lean_object* x_117; lean_object* x_118; 
+x_117 = lean_ctor_get(x_115, 0);
+lean_inc(x_117);
+x_118 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_117);
+lean_dec(x_117);
+if (lean_obj_tag(x_118) == 2)
+{
+lean_object* x_119; lean_object* x_120; uint8_t x_121; 
+x_119 = lean_ctor_get(x_118, 1);
+lean_inc(x_119);
+lean_dec(x_118);
+x_120 = l_Lean_Parser_Command_attribute___elambda__1___closed__6;
+x_121 = lean_string_dec_eq(x_119, x_120);
+lean_dec(x_119);
+if (x_121 == 0)
 {
 lean_object* x_122; lean_object* x_123; 
-x_122 = lean_ctor_get(x_120, 0);
-lean_inc(x_122);
-x_123 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_122);
-lean_dec(x_122);
-if (lean_obj_tag(x_123) == 2)
-{
-lean_object* x_124; lean_object* x_125; uint8_t x_126; 
-x_124 = lean_ctor_get(x_123, 1);
-lean_inc(x_124);
-lean_dec(x_123);
-x_125 = l_Lean_Parser_Command_attribute___elambda__1___closed__6;
-x_126 = lean_string_dec_eq(x_124, x_125);
-lean_dec(x_124);
-if (x_126 == 0)
-{
-lean_object* x_127; lean_object* x_128; 
-x_127 = l_Lean_Parser_Command_attribute___elambda__1___closed__14;
-lean_inc(x_10);
-x_128 = l_Lean_Parser_ParserState_mkErrorsAt(x_120, x_127, x_10);
-x_108 = x_128;
-goto block_119;
+x_122 = l_Lean_Parser_Command_attribute___elambda__1___closed__14;
+lean_inc(x_7);
+x_123 = l_Lean_Parser_ParserState_mkErrorsAt(x_115, x_122, x_7);
+x_103 = x_123;
+goto block_114;
 }
 else
 {
-x_108 = x_120;
-goto block_119;
+x_103 = x_115;
+goto block_114;
 }
 }
 else
 {
-lean_object* x_129; lean_object* x_130; 
-lean_dec(x_123);
-x_129 = l_Lean_Parser_Command_attribute___elambda__1___closed__14;
-lean_inc(x_10);
-x_130 = l_Lean_Parser_ParserState_mkErrorsAt(x_120, x_129, x_10);
-x_108 = x_130;
-goto block_119;
+lean_object* x_124; lean_object* x_125; 
+lean_dec(x_118);
+x_124 = l_Lean_Parser_Command_attribute___elambda__1___closed__14;
+lean_inc(x_7);
+x_125 = l_Lean_Parser_ParserState_mkErrorsAt(x_115, x_124, x_7);
+x_103 = x_125;
+goto block_114;
 }
 }
 else
 {
-lean_object* x_131; lean_object* x_132; 
-lean_dec(x_121);
-x_131 = l_Lean_Parser_Command_attribute___elambda__1___closed__14;
-lean_inc(x_10);
-x_132 = l_Lean_Parser_ParserState_mkErrorsAt(x_120, x_131, x_10);
-x_108 = x_132;
-goto block_119;
+lean_object* x_126; lean_object* x_127; 
+lean_dec(x_116);
+x_126 = l_Lean_Parser_Command_attribute___elambda__1___closed__14;
+lean_inc(x_7);
+x_127 = l_Lean_Parser_ParserState_mkErrorsAt(x_115, x_126, x_7);
+x_103 = x_127;
+goto block_114;
 }
-block_40:
+block_36:
 {
-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_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = lean_ctor_get(x_19, 0);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = lean_ctor_get(x_16, 0);
+lean_inc(x_18);
+x_19 = lean_array_get_size(x_18);
+lean_dec(x_18);
+lean_inc(x_1);
+x_20 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_21 = lean_ctor_get(x_20, 3);
 lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+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 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(x_1, x_20);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_19);
+x_25 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
 lean_dec(x_21);
-lean_inc(x_5);
-lean_inc(x_2);
+lean_dec(x_1);
+x_28 = l_Lean_nullKind;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_19);
+x_30 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
+}
+}
+else
+{
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_33 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_16, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+block_62:
+{
+lean_object* x_38; 
+x_38 = lean_ctor_get(x_37, 3);
+lean_inc(x_38);
+if (lean_obj_tag(x_38) == 0)
+{
+uint8_t x_39; lean_object* x_40; lean_object* x_41; 
+x_39 = 0;
 lean_inc(x_1);
-x_23 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
+x_40 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(x_39, x_39, x_1, x_37);
+x_41 = lean_ctor_get(x_40, 3);
+lean_inc(x_41);
+if (lean_obj_tag(x_41) == 0)
 {
-uint8_t 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; 
-x_25 = 0;
-x_26 = l_Lean_Parser_manyAux___main(x_25, x_5, x_1, x_2, x_23);
-x_27 = l_Lean_nullKind;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_22);
-x_29 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_18);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_13, x_10);
-lean_dec(x_10);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_24);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_32 = l_Lean_nullKind;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_23, x_32, x_22);
-x_34 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_18);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
-lean_dec(x_10);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_37 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_19, x_37, x_18);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_13, x_10);
-lean_dec(x_10);
-return x_39;
-}
-}
-block_67:
-{
-lean_object* x_42; 
-x_42 = lean_ctor_get(x_41, 3);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_42 = lean_ctor_get(x_40, 1);
 lean_inc(x_42);
-if (lean_obj_tag(x_42) == 0)
-{
-uint8_t x_43; uint8_t x_44; lean_object* x_45; lean_object* x_46; 
-x_43 = 0;
-x_44 = 0;
-lean_inc(x_2);
 lean_inc(x_1);
-x_45 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_attributes___elambda__1___spec__1(x_43, x_44, x_44, x_1, x_2, x_41);
-x_46 = lean_ctor_get(x_45, 3);
-lean_inc(x_46);
-if (lean_obj_tag(x_46) == 0)
+x_43 = l_Lean_Parser_tokenFn(x_1, x_40);
+x_44 = lean_ctor_get(x_43, 3);
+lean_inc(x_44);
+if (lean_obj_tag(x_44) == 0)
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_47 = lean_ctor_get(x_45, 1);
+lean_object* x_45; lean_object* x_46; 
+x_45 = lean_ctor_get(x_43, 0);
+lean_inc(x_45);
+x_46 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_45);
+lean_dec(x_45);
+if (lean_obj_tag(x_46) == 2)
+{
+lean_object* x_47; lean_object* x_48; uint8_t x_49; 
+x_47 = lean_ctor_get(x_46, 1);
 lean_inc(x_47);
-lean_inc(x_2);
-x_48 = l_Lean_Parser_tokenFn(x_2, x_45);
-x_49 = lean_ctor_get(x_48, 3);
-lean_inc(x_49);
-if (lean_obj_tag(x_49) == 0)
+lean_dec(x_46);
+x_48 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
+x_49 = lean_string_dec_eq(x_47, x_48);
+lean_dec(x_47);
+if (x_49 == 0)
 {
 lean_object* x_50; lean_object* x_51; 
-x_50 = lean_ctor_get(x_48, 0);
-lean_inc(x_50);
-x_51 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_50);
-lean_dec(x_50);
-if (lean_obj_tag(x_51) == 2)
-{
-lean_object* x_52; lean_object* x_53; uint8_t x_54; 
-x_52 = lean_ctor_get(x_51, 1);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
-x_54 = lean_string_dec_eq(x_52, x_53);
-lean_dec(x_52);
-if (x_54 == 0)
-{
-lean_object* x_55; lean_object* x_56; 
-x_55 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_55, x_47);
-x_19 = x_56;
-goto block_40;
+x_50 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_50, x_42);
+x_16 = x_51;
+goto block_36;
 }
 else
 {
-lean_dec(x_47);
-x_19 = x_48;
-goto block_40;
-}
-}
-else
-{
-lean_object* x_57; lean_object* x_58; 
-lean_dec(x_51);
-x_57 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_57, x_47);
-x_19 = x_58;
-goto block_40;
-}
-}
-else
-{
-lean_object* x_59; lean_object* x_60; 
-lean_dec(x_49);
-x_59 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_59, x_47);
-x_19 = x_60;
-goto block_40;
-}
-}
-else
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-lean_dec(x_46);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_61 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
-x_62 = l_Lean_Parser_ParserState_mkNode(x_45, x_61, x_18);
-x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_13, x_10);
-lean_dec(x_10);
-return x_63;
-}
-}
-else
-{
-lean_object* x_64; lean_object* x_65; lean_object* x_66; 
 lean_dec(x_42);
-lean_dec(x_5);
-lean_dec(x_2);
+x_16 = x_43;
+goto block_36;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_46);
+x_52 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_52, x_42);
+x_16 = x_53;
+goto block_36;
+}
+}
+else
+{
+lean_object* x_54; lean_object* x_55; 
+lean_dec(x_44);
+x_54 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_54, x_42);
+x_16 = x_55;
+goto block_36;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+lean_dec(x_41);
 lean_dec(x_1);
-x_64 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
-x_65 = l_Lean_Parser_ParserState_mkNode(x_41, x_64, x_18);
-x_66 = l_Lean_Parser_mergeOrElseErrors(x_65, x_13, x_10);
-lean_dec(x_10);
-return x_66;
+x_56 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
+x_57 = l_Lean_Parser_ParserState_mkNode(x_40, x_56, x_15);
+x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_10, x_7);
+lean_dec(x_7);
+return x_58;
 }
 }
-block_87:
+else
 {
-lean_object* x_69; 
-x_69 = lean_ctor_get(x_68, 3);
-lean_inc(x_69);
-if (lean_obj_tag(x_69) == 0)
+lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+lean_dec(x_38);
+lean_dec(x_1);
+x_59 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
+x_60 = l_Lean_Parser_ParserState_mkNode(x_37, x_59, x_15);
+x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_10, x_7);
+lean_dec(x_7);
+return x_61;
+}
+}
+block_82:
 {
-lean_object* x_70; lean_object* x_71; lean_object* x_72; 
-x_70 = lean_ctor_get(x_68, 1);
+lean_object* x_64; 
+x_64 = lean_ctor_get(x_63, 3);
+lean_inc(x_64);
+if (lean_obj_tag(x_64) == 0)
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_65 = lean_ctor_get(x_63, 1);
+lean_inc(x_65);
+lean_inc(x_1);
+x_66 = l_Lean_Parser_tokenFn(x_1, x_63);
+x_67 = lean_ctor_get(x_66, 3);
+lean_inc(x_67);
+if (lean_obj_tag(x_67) == 0)
+{
+lean_object* x_68; lean_object* x_69; 
+x_68 = lean_ctor_get(x_66, 0);
+lean_inc(x_68);
+x_69 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_68);
+lean_dec(x_68);
+if (lean_obj_tag(x_69) == 2)
+{
+lean_object* x_70; lean_object* x_71; uint8_t x_72; 
+x_70 = lean_ctor_get(x_69, 1);
 lean_inc(x_70);
-lean_inc(x_2);
-x_71 = l_Lean_Parser_tokenFn(x_2, x_68);
-x_72 = lean_ctor_get(x_71, 3);
-lean_inc(x_72);
-if (lean_obj_tag(x_72) == 0)
+lean_dec(x_69);
+x_71 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
+x_72 = lean_string_dec_eq(x_70, x_71);
+lean_dec(x_70);
+if (x_72 == 0)
 {
 lean_object* x_73; lean_object* x_74; 
-x_73 = lean_ctor_get(x_71, 0);
-lean_inc(x_73);
-x_74 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_73);
-lean_dec(x_73);
-if (lean_obj_tag(x_74) == 2)
-{
-lean_object* x_75; lean_object* x_76; uint8_t x_77; 
-x_75 = lean_ctor_get(x_74, 1);
-lean_inc(x_75);
-lean_dec(x_74);
-x_76 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
-x_77 = lean_string_dec_eq(x_75, x_76);
-lean_dec(x_75);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; 
-x_78 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_78, x_70);
-x_41 = x_79;
-goto block_67;
+x_73 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_73, x_65);
+x_37 = x_74;
+goto block_62;
 }
 else
 {
-lean_dec(x_70);
-x_41 = x_71;
-goto block_67;
+lean_dec(x_65);
+x_37 = x_66;
+goto block_62;
 }
 }
 else
 {
-lean_object* x_80; lean_object* x_81; 
-lean_dec(x_74);
-x_80 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-x_81 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_80, x_70);
-x_41 = x_81;
-goto block_67;
-}
-}
-else
-{
-lean_object* x_82; lean_object* x_83; 
-lean_dec(x_72);
-x_82 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-x_83 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_82, x_70);
-x_41 = x_83;
-goto block_67;
-}
-}
-else
-{
-lean_object* x_84; lean_object* x_85; lean_object* x_86; 
+lean_object* x_75; lean_object* x_76; 
 lean_dec(x_69);
-lean_dec(x_5);
-lean_dec(x_2);
+x_75 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_75, x_65);
+x_37 = x_76;
+goto block_62;
+}
+}
+else
+{
+lean_object* x_77; lean_object* x_78; 
+lean_dec(x_67);
+x_77 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_77, x_65);
+x_37 = x_78;
+goto block_62;
+}
+}
+else
+{
+lean_object* x_79; lean_object* x_80; lean_object* x_81; 
+lean_dec(x_64);
 lean_dec(x_1);
-x_84 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
-x_85 = l_Lean_Parser_ParserState_mkNode(x_68, x_84, x_18);
-x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_13, x_10);
-lean_dec(x_10);
-return x_86;
+x_79 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
+x_80 = l_Lean_Parser_ParserState_mkNode(x_63, x_79, x_15);
+x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_10, x_7);
+lean_dec(x_7);
+return x_81;
 }
 }
-block_107:
+block_102:
 {
-lean_object* x_89; 
-x_89 = lean_ctor_get(x_88, 3);
-lean_inc(x_89);
-if (lean_obj_tag(x_89) == 0)
+lean_object* x_84; 
+x_84 = lean_ctor_get(x_83, 3);
+lean_inc(x_84);
+if (lean_obj_tag(x_84) == 0)
 {
-lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-x_90 = lean_ctor_get(x_88, 1);
+lean_object* x_85; lean_object* x_86; lean_object* x_87; 
+x_85 = lean_ctor_get(x_83, 1);
+lean_inc(x_85);
+lean_inc(x_1);
+x_86 = l_Lean_Parser_tokenFn(x_1, x_83);
+x_87 = lean_ctor_get(x_86, 3);
+lean_inc(x_87);
+if (lean_obj_tag(x_87) == 0)
+{
+lean_object* x_88; lean_object* x_89; 
+x_88 = lean_ctor_get(x_86, 0);
+lean_inc(x_88);
+x_89 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_88);
+lean_dec(x_88);
+if (lean_obj_tag(x_89) == 2)
+{
+lean_object* x_90; lean_object* x_91; uint8_t x_92; 
+x_90 = lean_ctor_get(x_89, 1);
 lean_inc(x_90);
-lean_inc(x_2);
-x_91 = l_Lean_Parser_tokenFn(x_2, x_88);
-x_92 = lean_ctor_get(x_91, 3);
-lean_inc(x_92);
-if (lean_obj_tag(x_92) == 0)
+lean_dec(x_89);
+x_91 = l_Lean_Parser_Command_attribute___elambda__1___closed__8;
+x_92 = lean_string_dec_eq(x_90, x_91);
+lean_dec(x_90);
+if (x_92 == 0)
 {
 lean_object* x_93; lean_object* x_94; 
-x_93 = lean_ctor_get(x_91, 0);
-lean_inc(x_93);
-x_94 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_93);
-lean_dec(x_93);
-if (lean_obj_tag(x_94) == 2)
-{
-lean_object* x_95; lean_object* x_96; uint8_t x_97; 
-x_95 = lean_ctor_get(x_94, 1);
-lean_inc(x_95);
-lean_dec(x_94);
-x_96 = l_Lean_Parser_Command_attribute___elambda__1___closed__8;
-x_97 = lean_string_dec_eq(x_95, x_96);
-lean_dec(x_95);
-if (x_97 == 0)
-{
-lean_object* x_98; lean_object* x_99; 
-x_98 = l_Lean_Parser_Command_attribute___elambda__1___closed__11;
-x_99 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_98, x_90);
-x_68 = x_99;
-goto block_87;
+x_93 = l_Lean_Parser_Command_attribute___elambda__1___closed__11;
+x_94 = l_Lean_Parser_ParserState_mkErrorsAt(x_86, x_93, x_85);
+x_63 = x_94;
+goto block_82;
 }
 else
 {
-lean_dec(x_90);
-x_68 = x_91;
-goto block_87;
+lean_dec(x_85);
+x_63 = x_86;
+goto block_82;
 }
 }
 else
 {
-lean_object* x_100; lean_object* x_101; 
-lean_dec(x_94);
-x_100 = l_Lean_Parser_Command_attribute___elambda__1___closed__11;
-x_101 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_100, x_90);
-x_68 = x_101;
-goto block_87;
-}
-}
-else
-{
-lean_object* x_102; lean_object* x_103; 
-lean_dec(x_92);
-x_102 = l_Lean_Parser_Command_attribute___elambda__1___closed__11;
-x_103 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_102, x_90);
-x_68 = x_103;
-goto block_87;
-}
-}
-else
-{
-lean_object* x_104; lean_object* x_105; lean_object* x_106; 
+lean_object* x_95; lean_object* x_96; 
 lean_dec(x_89);
-lean_dec(x_5);
-lean_dec(x_2);
+x_95 = l_Lean_Parser_Command_attribute___elambda__1___closed__11;
+x_96 = l_Lean_Parser_ParserState_mkErrorsAt(x_86, x_95, x_85);
+x_63 = x_96;
+goto block_82;
+}
+}
+else
+{
+lean_object* x_97; lean_object* x_98; 
+lean_dec(x_87);
+x_97 = l_Lean_Parser_Command_attribute___elambda__1___closed__11;
+x_98 = l_Lean_Parser_ParserState_mkErrorsAt(x_86, x_97, x_85);
+x_63 = x_98;
+goto block_82;
+}
+}
+else
+{
+lean_object* x_99; lean_object* x_100; lean_object* x_101; 
+lean_dec(x_84);
 lean_dec(x_1);
-x_104 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
-x_105 = l_Lean_Parser_ParserState_mkNode(x_88, x_104, x_18);
-x_106 = l_Lean_Parser_mergeOrElseErrors(x_105, x_13, x_10);
-lean_dec(x_10);
-return x_106;
+x_99 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
+x_100 = l_Lean_Parser_ParserState_mkNode(x_83, x_99, x_15);
+x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_10, x_7);
+lean_dec(x_7);
+return x_101;
 }
 }
-block_119:
+block_114:
 {
-lean_object* x_109; 
-x_109 = lean_ctor_get(x_108, 3);
-lean_inc(x_109);
-if (lean_obj_tag(x_109) == 0)
+lean_object* x_104; 
+x_104 = lean_ctor_get(x_103, 3);
+lean_inc(x_104);
+if (lean_obj_tag(x_104) == 0)
 {
-lean_object* x_110; lean_object* x_111; 
-x_110 = l_Lean_nullKind;
-lean_inc(x_18);
-x_111 = l_Lean_Parser_ParserState_mkNode(x_108, x_110, x_18);
-x_88 = x_111;
-goto block_107;
+lean_object* x_105; lean_object* x_106; 
+x_105 = l_Lean_nullKind;
+lean_inc(x_15);
+x_106 = l_Lean_Parser_ParserState_mkNode(x_103, x_105, x_15);
+x_83 = x_106;
+goto block_102;
 }
 else
 {
-lean_object* x_112; uint8_t x_113; 
-lean_dec(x_109);
-x_112 = lean_ctor_get(x_108, 1);
-lean_inc(x_112);
-x_113 = lean_nat_dec_eq(x_112, x_10);
-lean_dec(x_112);
-if (x_113 == 0)
+lean_object* x_107; uint8_t x_108; 
+lean_dec(x_104);
+x_107 = lean_ctor_get(x_103, 1);
+lean_inc(x_107);
+x_108 = lean_nat_dec_eq(x_107, x_7);
+lean_dec(x_107);
+if (x_108 == 0)
 {
-lean_object* x_114; lean_object* x_115; 
-x_114 = l_Lean_nullKind;
-lean_inc(x_18);
-x_115 = l_Lean_Parser_ParserState_mkNode(x_108, x_114, x_18);
-x_88 = x_115;
-goto block_107;
+lean_object* x_109; lean_object* x_110; 
+x_109 = l_Lean_nullKind;
+lean_inc(x_15);
+x_110 = l_Lean_Parser_ParserState_mkNode(x_103, x_109, x_15);
+x_83 = x_110;
+goto block_102;
 }
 else
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; 
-lean_inc(x_10);
-x_116 = l_Lean_Parser_ParserState_restore(x_108, x_18, x_10);
-x_117 = l_Lean_nullKind;
-lean_inc(x_18);
-x_118 = l_Lean_Parser_ParserState_mkNode(x_116, x_117, x_18);
-x_88 = x_118;
-goto block_107;
+lean_object* x_111; lean_object* x_112; lean_object* x_113; 
+lean_inc(x_7);
+x_111 = l_Lean_Parser_ParserState_restore(x_103, x_15, x_7);
+x_112 = l_Lean_nullKind;
+lean_inc(x_15);
+x_113 = l_Lean_Parser_ParserState_mkNode(x_111, x_112, x_15);
+x_83 = x_113;
+goto block_102;
 }
 }
 }
@@ -21795,7 +21258,7 @@ lean_object* _init_l_Lean_Parser_Command_attribute___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_listLit___closed__4;
@@ -21869,7 +21332,7 @@ lean_object* _init_l_Lean_Parser_Command_attribute___closed__11() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_attribute___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_attribute___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -21896,10 +21359,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_attribute(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_attribute___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_attribute;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -21936,13 +21399,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_export___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_export___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_export___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_export___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_export___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_export___elambda__1___closed__5() {
@@ -21994,366 +21456,345 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_export___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_export___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_export___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_export___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_51; lean_object* x_67; lean_object* x_92; lean_object* x_93; 
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_92 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_93 = lean_ctor_get(x_92, 3);
-lean_inc(x_93);
-if (lean_obj_tag(x_93) == 0)
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_94; lean_object* x_95; 
-x_94 = lean_ctor_get(x_92, 0);
-lean_inc(x_94);
-x_95 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_94);
-lean_dec(x_94);
-if (lean_obj_tag(x_95) == 2)
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
 {
-lean_object* x_96; lean_object* x_97; uint8_t x_98; 
-x_96 = lean_ctor_get(x_95, 1);
-lean_inc(x_96);
-lean_dec(x_95);
-x_97 = l_Lean_Parser_Command_export___elambda__1___closed__6;
-x_98 = lean_string_dec_eq(x_96, x_97);
-lean_dec(x_96);
-if (x_98 == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_48; lean_object* x_63; lean_object* x_88; lean_object* x_89; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_88 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_89 = lean_ctor_get(x_88, 3);
+lean_inc(x_89);
+if (lean_obj_tag(x_89) == 0)
+{
+lean_object* x_90; lean_object* x_91; 
+x_90 = lean_ctor_get(x_88, 0);
+lean_inc(x_90);
+x_91 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_90);
+lean_dec(x_90);
+if (lean_obj_tag(x_91) == 2)
+{
+lean_object* x_92; lean_object* x_93; uint8_t x_94; 
+x_92 = lean_ctor_get(x_91, 1);
+lean_inc(x_92);
+lean_dec(x_91);
+x_93 = l_Lean_Parser_Command_export___elambda__1___closed__6;
+x_94 = lean_string_dec_eq(x_92, x_93);
+lean_dec(x_92);
+if (x_94 == 0)
+{
+lean_object* x_95; lean_object* x_96; 
+x_95 = l_Lean_Parser_Command_export___elambda__1___closed__9;
+lean_inc(x_7);
+x_96 = l_Lean_Parser_ParserState_mkErrorsAt(x_88, x_95, x_7);
+x_63 = x_96;
+goto block_87;
+}
+else
+{
+x_63 = x_88;
+goto block_87;
+}
+}
+else
+{
+lean_object* x_97; lean_object* x_98; 
+lean_dec(x_91);
+x_97 = l_Lean_Parser_Command_export___elambda__1___closed__9;
+lean_inc(x_7);
+x_98 = l_Lean_Parser_ParserState_mkErrorsAt(x_88, x_97, x_7);
+x_63 = x_98;
+goto block_87;
+}
+}
+else
 {
 lean_object* x_99; lean_object* x_100; 
+lean_dec(x_89);
 x_99 = l_Lean_Parser_Command_export___elambda__1___closed__9;
-lean_inc(x_10);
-x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_99, x_10);
-x_67 = x_100;
-goto block_91;
+lean_inc(x_7);
+x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_88, x_99, x_7);
+x_63 = x_100;
+goto block_87;
 }
-else
+block_47:
 {
-x_67 = x_92;
-goto block_91;
-}
-}
-else
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_101; lean_object* x_102; 
-lean_dec(x_95);
-x_101 = l_Lean_Parser_Command_export___elambda__1___closed__9;
-lean_inc(x_10);
-x_102 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_101, x_10);
-x_67 = x_102;
-goto block_91;
-}
-}
-else
-{
-lean_object* x_103; lean_object* x_104; 
-lean_dec(x_93);
-x_103 = l_Lean_Parser_Command_export___elambda__1___closed__9;
-lean_inc(x_10);
-x_104 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_103, x_10);
-x_67 = x_104;
-goto block_91;
-}
-block_50:
-{
-lean_object* x_20; 
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_16, 1);
+lean_inc(x_18);
+x_19 = l_Lean_Parser_tokenFn(x_1, x_16);
 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; 
-x_21 = lean_ctor_get(x_19, 1);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_23 = lean_ctor_get(x_22, 3);
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
+lean_dec(x_21);
+if (lean_obj_tag(x_22) == 2)
+{
+lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 1);
 lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
+lean_dec(x_22);
+x_24 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_25 = lean_string_dec_eq(x_23, x_24);
+lean_dec(x_23);
+if (x_25 == 0)
 {
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_26 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18);
+x_28 = l_Lean_Parser_Command_export___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+else
 {
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_29 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_dec(x_18);
 x_31 = l_Lean_Parser_Command_export___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_18);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_13, x_10);
-lean_dec(x_10);
+x_32 = l_Lean_Parser_ParserState_mkNode(x_19, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
 return x_33;
 }
+}
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_21);
-x_34 = l_Lean_Parser_Command_export___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_18);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
-lean_dec(x_10);
-return x_36;
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_22);
+x_34 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_34, x_18);
+x_36 = l_Lean_Parser_Command_export___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
 }
 }
 else
 {
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_25);
-x_37 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
-x_39 = l_Lean_Parser_Command_export___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_18);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_13, x_10);
-lean_dec(x_10);
-return x_41;
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_20);
+x_39 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_39, x_18);
+x_41 = l_Lean_Parser_Command_export___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
 }
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-lean_dec(x_23);
-x_42 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_17);
+lean_dec(x_1);
 x_44 = l_Lean_Parser_Command_export___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_18);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_13, x_10);
-lean_dec(x_10);
+x_45 = l_Lean_Parser_ParserState_mkNode(x_16, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
 return x_46;
 }
 }
-else
+block_62:
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_47 = l_Lean_Parser_Command_export___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_18);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_13, x_10);
-lean_dec(x_10);
-return x_49;
-}
-}
-block_66:
+lean_object* x_49; 
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
 {
-lean_object* x_52; 
-x_52 = lean_ctor_get(x_51, 3);
-lean_inc(x_52);
-if (lean_obj_tag(x_52) == 0)
-{
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_53 = lean_ctor_get(x_51, 0);
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_50 = lean_ctor_get(x_48, 0);
+lean_inc(x_50);
+x_51 = lean_array_get_size(x_50);
+lean_dec(x_50);
+lean_inc(x_1);
+x_52 = l_Lean_Parser_ident___elambda__1(x_1, x_48);
+x_53 = lean_ctor_get(x_52, 3);
 lean_inc(x_53);
-x_54 = lean_array_get_size(x_53);
+if (lean_obj_tag(x_53) == 0)
+{
+lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+lean_inc(x_1);
+x_54 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(x_1, x_52);
+x_55 = l_Lean_nullKind;
+x_56 = l_Lean_Parser_ParserState_mkNode(x_54, x_55, x_51);
+x_16 = x_56;
+goto block_47;
+}
+else
+{
+lean_object* x_57; lean_object* x_58; 
 lean_dec(x_53);
-lean_inc(x_5);
-lean_inc(x_2);
-lean_inc(x_1);
-x_55 = lean_apply_3(x_5, x_1, x_2, x_51);
-x_56 = lean_ctor_get(x_55, 3);
-lean_inc(x_56);
-if (lean_obj_tag(x_56) == 0)
-{
-uint8_t x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_57 = 0;
-lean_inc(x_2);
-x_58 = l_Lean_Parser_manyAux___main(x_57, x_5, x_1, x_2, x_55);
-x_59 = l_Lean_nullKind;
-x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_54);
-x_19 = x_60;
-goto block_50;
-}
-else
-{
-lean_object* x_61; lean_object* x_62; 
-lean_dec(x_56);
-lean_dec(x_5);
-lean_dec(x_1);
-x_61 = l_Lean_nullKind;
-x_62 = l_Lean_Parser_ParserState_mkNode(x_55, x_61, x_54);
-x_19 = x_62;
-goto block_50;
+x_57 = l_Lean_nullKind;
+x_58 = l_Lean_Parser_ParserState_mkNode(x_52, x_57, x_51);
+x_16 = x_58;
+goto block_47;
 }
 }
 else
 {
-lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-lean_dec(x_52);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+lean_dec(x_49);
 lean_dec(x_1);
-x_63 = l_Lean_Parser_Command_export___elambda__1___closed__2;
-x_64 = l_Lean_Parser_ParserState_mkNode(x_51, x_63, x_18);
-x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_13, x_10);
-lean_dec(x_10);
-return x_65;
+x_59 = l_Lean_Parser_Command_export___elambda__1___closed__2;
+x_60 = l_Lean_Parser_ParserState_mkNode(x_48, x_59, x_15);
+x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_10, x_7);
+lean_dec(x_7);
+return x_61;
 }
 }
-block_91:
+block_87:
 {
-lean_object* x_68; 
-x_68 = lean_ctor_get(x_67, 3);
-lean_inc(x_68);
-if (lean_obj_tag(x_68) == 0)
+lean_object* x_64; 
+x_64 = lean_ctor_get(x_63, 3);
+lean_inc(x_64);
+if (lean_obj_tag(x_64) == 0)
 {
-lean_object* x_69; lean_object* x_70; 
-lean_inc(x_5);
-lean_inc(x_2);
+lean_object* x_65; lean_object* x_66; 
 lean_inc(x_1);
-x_69 = lean_apply_3(x_5, x_1, x_2, x_67);
-x_70 = lean_ctor_get(x_69, 3);
+x_65 = l_Lean_Parser_ident___elambda__1(x_1, x_63);
+x_66 = lean_ctor_get(x_65, 3);
+lean_inc(x_66);
+if (lean_obj_tag(x_66) == 0)
+{
+lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+x_67 = lean_ctor_get(x_65, 1);
+lean_inc(x_67);
+lean_inc(x_1);
+x_68 = l_Lean_Parser_tokenFn(x_1, x_65);
+x_69 = lean_ctor_get(x_68, 3);
+lean_inc(x_69);
+if (lean_obj_tag(x_69) == 0)
+{
+lean_object* x_70; lean_object* x_71; 
+x_70 = lean_ctor_get(x_68, 0);
 lean_inc(x_70);
-if (lean_obj_tag(x_70) == 0)
+x_71 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_70);
+lean_dec(x_70);
+if (lean_obj_tag(x_71) == 2)
 {
-lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-x_71 = lean_ctor_get(x_69, 1);
-lean_inc(x_71);
-lean_inc(x_2);
-x_72 = l_Lean_Parser_tokenFn(x_2, x_69);
-x_73 = lean_ctor_get(x_72, 3);
-lean_inc(x_73);
-if (lean_obj_tag(x_73) == 0)
+lean_object* x_72; lean_object* x_73; uint8_t x_74; 
+x_72 = lean_ctor_get(x_71, 1);
+lean_inc(x_72);
+lean_dec(x_71);
+x_73 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_74 = lean_string_dec_eq(x_72, x_73);
+lean_dec(x_72);
+if (x_74 == 0)
 {
-lean_object* x_74; lean_object* x_75; 
-x_74 = lean_ctor_get(x_72, 0);
-lean_inc(x_74);
-x_75 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_74);
-lean_dec(x_74);
-if (lean_obj_tag(x_75) == 2)
+lean_object* x_75; lean_object* x_76; 
+x_75 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_75, x_67);
+x_48 = x_76;
+goto block_62;
+}
+else
 {
-lean_object* x_76; lean_object* x_77; uint8_t x_78; 
-x_76 = lean_ctor_get(x_75, 1);
-lean_inc(x_76);
-lean_dec(x_75);
-x_77 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_78 = lean_string_dec_eq(x_76, x_77);
-lean_dec(x_76);
-if (x_78 == 0)
+lean_dec(x_67);
+x_48 = x_68;
+goto block_62;
+}
+}
+else
+{
+lean_object* x_77; lean_object* x_78; 
+lean_dec(x_71);
+x_77 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_77, x_67);
+x_48 = x_78;
+goto block_62;
+}
+}
+else
 {
 lean_object* x_79; lean_object* x_80; 
-x_79 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_79, x_71);
-x_51 = x_80;
-goto block_66;
-}
-else
-{
-lean_dec(x_71);
-x_51 = x_72;
-goto block_66;
+lean_dec(x_69);
+x_79 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_79, x_67);
+x_48 = x_80;
+goto block_62;
 }
 }
 else
 {
-lean_object* x_81; lean_object* x_82; 
-lean_dec(x_75);
-x_81 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-x_82 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_81, x_71);
-x_51 = x_82;
-goto block_66;
-}
-}
-else
-{
-lean_object* x_83; lean_object* x_84; 
-lean_dec(x_73);
-x_83 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-x_84 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_83, x_71);
-x_51 = x_84;
-goto block_66;
-}
-}
-else
-{
-lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-lean_dec(x_70);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+lean_dec(x_66);
 lean_dec(x_1);
-x_85 = l_Lean_Parser_Command_export___elambda__1___closed__2;
-x_86 = l_Lean_Parser_ParserState_mkNode(x_69, x_85, x_18);
-x_87 = l_Lean_Parser_mergeOrElseErrors(x_86, x_13, x_10);
-lean_dec(x_10);
-return x_87;
+x_81 = l_Lean_Parser_Command_export___elambda__1___closed__2;
+x_82 = l_Lean_Parser_ParserState_mkNode(x_65, x_81, x_15);
+x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_10, x_7);
+lean_dec(x_7);
+return x_83;
 }
 }
 else
 {
-lean_object* x_88; lean_object* x_89; lean_object* x_90; 
-lean_dec(x_68);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_84; lean_object* x_85; lean_object* x_86; 
+lean_dec(x_64);
 lean_dec(x_1);
-x_88 = l_Lean_Parser_Command_export___elambda__1___closed__2;
-x_89 = l_Lean_Parser_ParserState_mkNode(x_67, x_88, x_18);
-x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_13, x_10);
-lean_dec(x_10);
-return x_90;
+x_84 = l_Lean_Parser_Command_export___elambda__1___closed__2;
+x_85 = l_Lean_Parser_ParserState_mkNode(x_63, x_84, x_15);
+x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_10, x_7);
+lean_dec(x_7);
+return x_86;
 }
 }
 }
@@ -22374,10 +21815,10 @@ lean_object* _init_l_Lean_Parser_Command_export___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
@@ -22386,7 +21827,7 @@ lean_object* _init_l_Lean_Parser_Command_export___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 x_2 = l_Lean_Parser_Command_export___closed__2;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
@@ -22396,7 +21837,7 @@ lean_object* _init_l_Lean_Parser_Command_export___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_export___closed__3;
@@ -22440,7 +21881,7 @@ lean_object* _init_l_Lean_Parser_Command_export___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_export___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_export___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -22467,10 +21908,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_export(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_export___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_export___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_export;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -22507,13 +21948,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_openHiding___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_openHiding___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_openHiding___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_openHiding___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_openHiding___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_openHiding___elambda__1___closed__5() {
@@ -22565,287 +22005,268 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_openHiding___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_openHiding___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_openHiding___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_openHiding___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_8);
-lean_dec(x_8);
-lean_inc(x_3);
+x_6 = lean_ctor_get(x_2, 1);
+lean_inc(x_6);
+x_7 = lean_array_get_size(x_5);
+lean_dec(x_5);
 lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-if (lean_is_exclusive(x_3)) {
- lean_ctor_release(x_3, 0);
- lean_ctor_release(x_3, 1);
- lean_ctor_release(x_3, 2);
- lean_ctor_release(x_3, 3);
- x_12 = x_3;
+x_8 = lean_apply_2(x_4, x_1, x_2);
+if (lean_is_exclusive(x_2)) {
+ lean_ctor_release(x_2, 0);
+ lean_ctor_release(x_2, 1);
+ lean_ctor_release(x_2, 2);
+ lean_ctor_release(x_2, 3);
+ x_9 = x_2;
 } else {
- lean_dec_ref(x_3);
- x_12 = lean_box(0);
+ lean_dec_ref(x_2);
+ x_9 = lean_box(0);
 }
-x_13 = lean_ctor_get(x_11, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+x_10 = lean_ctor_get(x_8, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
 {
-lean_dec(x_12);
-lean_dec(x_10);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_11, 1);
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_8, 1);
+lean_inc(x_12);
+x_13 = lean_nat_dec_eq(x_12, x_6);
+lean_dec(x_12);
+if (x_13 == 0)
+{
+lean_dec(x_11);
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_46; lean_object* x_47; 
+lean_inc(x_6);
+x_14 = l_Lean_Parser_ParserState_restore(x_8, x_7, x_6);
+lean_dec(x_7);
+x_15 = lean_ctor_get(x_14, 0);
 lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_15, x_9);
+x_16 = lean_array_get_size(x_15);
 lean_dec(x_15);
-if (x_16 == 0)
-{
-lean_dec(x_14);
-lean_dec(x_12);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-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_50; lean_object* x_51; 
-lean_inc(x_9);
-x_17 = l_Lean_Parser_ParserState_restore(x_11, x_10, x_9);
-lean_dec(x_10);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_array_get_size(x_18);
-lean_dec(x_18);
-lean_inc(x_5);
-lean_inc(x_2);
 lean_inc(x_1);
-x_50 = lean_apply_3(x_5, x_1, x_2, x_17);
-x_51 = lean_ctor_get(x_50, 3);
+x_46 = l_Lean_Parser_ident___elambda__1(x_1, x_14);
+x_47 = lean_ctor_get(x_46, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_48 = lean_ctor_get(x_46, 1);
+lean_inc(x_48);
+lean_inc(x_1);
+x_49 = l_Lean_Parser_tokenFn(x_1, x_46);
+x_50 = lean_ctor_get(x_49, 3);
+lean_inc(x_50);
+if (lean_obj_tag(x_50) == 0)
+{
+lean_object* x_51; lean_object* x_52; 
+x_51 = lean_ctor_get(x_49, 0);
 lean_inc(x_51);
-if (lean_obj_tag(x_51) == 0)
-{
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-x_52 = lean_ctor_get(x_50, 1);
-lean_inc(x_52);
-lean_inc(x_2);
-x_53 = l_Lean_Parser_tokenFn(x_2, x_50);
-x_54 = lean_ctor_get(x_53, 3);
-lean_inc(x_54);
-if (lean_obj_tag(x_54) == 0)
-{
-lean_object* x_55; lean_object* x_56; 
-x_55 = lean_ctor_get(x_53, 0);
-lean_inc(x_55);
-x_56 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_55);
-lean_dec(x_55);
-if (lean_obj_tag(x_56) == 2)
-{
-lean_object* x_57; lean_object* x_58; uint8_t x_59; 
-x_57 = lean_ctor_get(x_56, 1);
-lean_inc(x_57);
-lean_dec(x_56);
-x_58 = l_Lean_Parser_Command_openHiding___elambda__1___closed__6;
-x_59 = lean_string_dec_eq(x_57, x_58);
-lean_dec(x_57);
-if (x_59 == 0)
-{
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_60 = l_Lean_Parser_Command_openHiding___elambda__1___closed__9;
-x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_60, x_52);
-x_62 = lean_ctor_get(x_61, 0);
-lean_inc(x_62);
-x_63 = lean_ctor_get(x_61, 2);
-lean_inc(x_63);
-x_64 = lean_ctor_get(x_61, 3);
-lean_inc(x_64);
-x_20 = x_61;
-x_21 = x_62;
-x_22 = x_63;
-x_23 = x_64;
-goto block_49;
-}
-else
-{
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-lean_dec(x_52);
-x_65 = lean_ctor_get(x_53, 0);
-lean_inc(x_65);
-x_66 = lean_ctor_get(x_53, 2);
-lean_inc(x_66);
-x_67 = lean_ctor_get(x_53, 3);
-lean_inc(x_67);
-x_20 = x_53;
-x_21 = x_65;
-x_22 = x_66;
-x_23 = x_67;
-goto block_49;
-}
-}
-else
-{
-lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
-lean_dec(x_56);
-x_68 = l_Lean_Parser_Command_openHiding___elambda__1___closed__9;
-x_69 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_68, x_52);
-x_70 = lean_ctor_get(x_69, 0);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_69, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_69, 3);
-lean_inc(x_72);
-x_20 = x_69;
-x_21 = x_70;
-x_22 = x_71;
-x_23 = x_72;
-goto block_49;
-}
-}
-else
-{
-lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; 
-lean_dec(x_54);
-x_73 = l_Lean_Parser_Command_openHiding___elambda__1___closed__9;
-x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_73, x_52);
-x_75 = lean_ctor_get(x_74, 0);
-lean_inc(x_75);
-x_76 = lean_ctor_get(x_74, 2);
-lean_inc(x_76);
-x_77 = lean_ctor_get(x_74, 3);
-lean_inc(x_77);
-x_20 = x_74;
-x_21 = x_75;
-x_22 = x_76;
-x_23 = x_77;
-goto block_49;
-}
-}
-else
-{
-lean_object* x_78; lean_object* x_79; lean_object* x_80; 
+x_52 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_51);
 lean_dec(x_51);
-x_78 = lean_ctor_get(x_50, 0);
-lean_inc(x_78);
-x_79 = lean_ctor_get(x_50, 2);
-lean_inc(x_79);
-x_80 = lean_ctor_get(x_50, 3);
-lean_inc(x_80);
-x_20 = x_50;
-x_21 = x_78;
-x_22 = x_79;
-x_23 = x_80;
-goto block_49;
+if (lean_obj_tag(x_52) == 2)
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; 
+x_53 = lean_ctor_get(x_52, 1);
+lean_inc(x_53);
+lean_dec(x_52);
+x_54 = l_Lean_Parser_Command_openHiding___elambda__1___closed__6;
+x_55 = lean_string_dec_eq(x_53, x_54);
+lean_dec(x_53);
+if (x_55 == 0)
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_56 = l_Lean_Parser_Command_openHiding___elambda__1___closed__9;
+x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_56, x_48);
+x_58 = lean_ctor_get(x_57, 0);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_57, 2);
+lean_inc(x_59);
+x_60 = lean_ctor_get(x_57, 3);
+lean_inc(x_60);
+x_17 = x_57;
+x_18 = x_58;
+x_19 = x_59;
+x_20 = x_60;
+goto block_45;
 }
-block_49:
+else
 {
-if (lean_obj_tag(x_23) == 0)
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+lean_dec(x_48);
+x_61 = lean_ctor_get(x_49, 0);
+lean_inc(x_61);
+x_62 = lean_ctor_get(x_49, 2);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_49, 3);
+lean_inc(x_63);
+x_17 = x_49;
+x_18 = x_61;
+x_19 = x_62;
+x_20 = x_63;
+goto block_45;
+}
+}
+else
 {
-lean_object* x_24; 
+lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+lean_dec(x_52);
+x_64 = l_Lean_Parser_Command_openHiding___elambda__1___closed__9;
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_64, x_48);
+x_66 = lean_ctor_get(x_65, 0);
+lean_inc(x_66);
+x_67 = lean_ctor_get(x_65, 2);
+lean_inc(x_67);
+x_68 = lean_ctor_get(x_65, 3);
+lean_inc(x_68);
+x_17 = x_65;
+x_18 = x_66;
+x_19 = x_67;
+x_20 = x_68;
+goto block_45;
+}
+}
+else
+{
+lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_dec(x_50);
+x_69 = l_Lean_Parser_Command_openHiding___elambda__1___closed__9;
+x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_69, x_48);
+x_71 = lean_ctor_get(x_70, 0);
+lean_inc(x_71);
+x_72 = lean_ctor_get(x_70, 2);
+lean_inc(x_72);
+x_73 = lean_ctor_get(x_70, 3);
+lean_inc(x_73);
+x_17 = x_70;
+x_18 = x_71;
+x_19 = x_72;
+x_20 = x_73;
+goto block_45;
+}
+}
+else
+{
+lean_object* x_74; lean_object* x_75; lean_object* x_76; 
+lean_dec(x_47);
+x_74 = lean_ctor_get(x_46, 0);
+lean_inc(x_74);
+x_75 = lean_ctor_get(x_46, 2);
+lean_inc(x_75);
+x_76 = lean_ctor_get(x_46, 3);
+lean_inc(x_76);
+x_17 = x_46;
+x_18 = x_74;
+x_19 = x_75;
+x_20 = x_76;
+goto block_45;
+}
+block_45:
+{
+if (lean_obj_tag(x_20) == 0)
+{
+lean_object* x_21; 
+lean_dec(x_19);
+lean_dec(x_18);
+lean_dec(x_9);
+x_21 = lean_ctor_get(x_17, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_22 = lean_ctor_get(x_17, 0);
+lean_inc(x_22);
+x_23 = lean_array_get_size(x_22);
 lean_dec(x_22);
-lean_dec(x_21);
-lean_dec(x_12);
-x_24 = lean_ctor_get(x_20, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_25 = lean_ctor_get(x_20, 0);
-lean_inc(x_25);
-x_26 = lean_array_get_size(x_25);
-lean_dec(x_25);
-lean_inc(x_5);
-lean_inc(x_2);
 lean_inc(x_1);
-x_27 = lean_apply_3(x_5, x_1, x_2, x_20);
-x_28 = lean_ctor_get(x_27, 3);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
+x_24 = l_Lean_Parser_ident___elambda__1(x_1, x_17);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
 {
-uint8_t 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; 
-x_29 = 0;
-x_30 = l_Lean_Parser_manyAux___main(x_29, x_5, x_1, x_2, x_27);
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_26);
-x_33 = l_Lean_Parser_Command_openHiding___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_19);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_14, x_9);
-lean_dec(x_9);
-return x_35;
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+x_26 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(x_1, x_24);
+x_27 = l_Lean_nullKind;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_23);
+x_29 = l_Lean_Parser_Command_openHiding___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_6);
+lean_dec(x_6);
+return x_31;
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-lean_dec(x_28);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_25);
 lean_dec(x_1);
-x_36 = l_Lean_nullKind;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_27, x_36, x_26);
-x_38 = l_Lean_Parser_Command_openHiding___elambda__1___closed__2;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_19);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_14, x_9);
-lean_dec(x_9);
-return x_40;
+x_32 = l_Lean_nullKind;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_24, x_32, x_23);
+x_34 = l_Lean_Parser_Command_openHiding___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_6);
+lean_dec(x_6);
+return x_36;
 }
 }
 else
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_24);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_41 = l_Lean_Parser_Command_openHiding___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_20, x_41, x_19);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_14, x_9);
-lean_dec(x_9);
-return x_43;
+x_37 = l_Lean_Parser_Command_openHiding___elambda__1___closed__2;
+x_38 = l_Lean_Parser_ParserState_mkNode(x_17, x_37, x_16);
+x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_6);
+lean_dec(x_6);
+return x_39;
 }
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_44 = l_Array_shrink___main___rarg(x_21, x_19);
-lean_inc(x_9);
-if (lean_is_scalar(x_12)) {
- x_45 = lean_alloc_ctor(0, 4, 0);
+x_40 = l_Array_shrink___main___rarg(x_18, x_16);
+lean_inc(x_6);
+if (lean_is_scalar(x_9)) {
+ x_41 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_45 = x_12;
+ x_41 = x_9;
 }
-lean_ctor_set(x_45, 0, x_44);
-lean_ctor_set(x_45, 1, x_9);
-lean_ctor_set(x_45, 2, x_22);
-lean_ctor_set(x_45, 3, x_23);
-x_46 = l_Lean_Parser_Command_openHiding___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_19);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_14, x_9);
-lean_dec(x_9);
-return x_48;
+lean_ctor_set(x_41, 0, x_40);
+lean_ctor_set(x_41, 1, x_6);
+lean_ctor_set(x_41, 2, x_19);
+lean_ctor_set(x_41, 3, x_20);
+x_42 = l_Lean_Parser_Command_openHiding___elambda__1___closed__2;
+x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_16);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_11, x_6);
+lean_dec(x_6);
+return x_44;
 }
 }
 }
@@ -22866,7 +22287,7 @@ lean_object* _init_l_Lean_Parser_Command_openHiding___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_openHiding___closed__1;
@@ -22878,7 +22299,7 @@ lean_object* _init_l_Lean_Parser_Command_openHiding___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_openHiding___closed__2;
@@ -22912,7 +22333,7 @@ lean_object* _init_l_Lean_Parser_Command_openHiding___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openHiding___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openHiding___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -22967,13 +22388,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__5() {
@@ -23025,7 +22445,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__9;
-x_2 = l_Lean_Parser_unicodeSymbolFn___rarg___closed__1;
+x_2 = l_Lean_Parser_unicodeSymbolFn___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
@@ -23062,120 +22482,106 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_16 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__6;
+x_19 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__8;
+x_20 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__13;
+lean_inc(x_1);
+x_21 = l_Lean_Parser_unicodeSymbolFnAux(x_18, x_19, x_20, x_1, x_16);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+x_23 = l_Lean_Parser_ident___elambda__1(x_1, x_21);
+x_24 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_5);
-lean_inc(x_2);
-lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-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_24; lean_object* x_25; 
-x_21 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__6;
-x_22 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__8;
-x_23 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__13;
-lean_inc(x_2);
-x_24 = l_Lean_Parser_unicodeSymbolFnAux(x_21, x_22, x_23, x_2, x_19);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_26 = lean_apply_3(x_5, x_1, x_2, x_24);
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_22);
+lean_dec(x_1);
 x_27 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_18);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_13, x_10);
-lean_dec(x_10);
+x_28 = l_Lean_Parser_ParserState_mkNode(x_21, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
 return x_29;
 }
+}
 else
 {
 lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_25);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_17);
 lean_dec(x_1);
 x_30 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_24, x_30, x_18);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_13, x_10);
-lean_dec(x_10);
+x_31 = l_Lean_Parser_ParserState_mkNode(x_16, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
 return x_32;
 }
 }
-else
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_33 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_19, x_33, x_18);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_13, x_10);
-lean_dec(x_10);
-return x_35;
-}
-}
 }
 }
 }
@@ -23194,7 +22600,7 @@ lean_object* _init_l_Lean_Parser_Command_openRenamingItem___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_openRenamingItem___closed__1;
@@ -23206,7 +22612,7 @@ lean_object* _init_l_Lean_Parser_Command_openRenamingItem___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_openRenamingItem___closed__2;
@@ -23240,7 +22646,7 @@ lean_object* _init_l_Lean_Parser_Command_openRenamingItem___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openRenamingItem___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openRenamingItem___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -23264,216 +22670,213 @@ x_1 = l_Lean_Parser_Command_openRenamingItem___closed__7;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
-lean_dec(x_9);
-x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_5);
+x_10 = l_Lean_Parser_Command_openRenamingItem___elambda__1(x_5, x_6);
+x_11 = lean_ctor_get(x_10, 3);
 lean_inc(x_11);
-lean_inc(x_7);
-lean_inc(x_6);
-x_12 = l_Lean_Parser_Command_openRenamingItem___elambda__1(x_6, x_7, x_8);
-x_13 = lean_ctor_get(x_12, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+if (lean_obj_tag(x_11) == 0)
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_14 = lean_ctor_get(x_12, 0);
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_12 = lean_ctor_get(x_10, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+x_14 = lean_ctor_get(x_10, 1);
 lean_inc(x_14);
-x_15 = lean_array_get_size(x_14);
-lean_dec(x_14);
-x_16 = lean_ctor_get(x_12, 1);
-lean_inc(x_16);
-lean_inc(x_7);
-x_31 = l_Lean_Parser_tokenFn(x_7, x_12);
-x_32 = lean_ctor_get(x_31, 3);
-lean_inc(x_32);
-if (lean_obj_tag(x_32) == 0)
+lean_inc(x_5);
+x_29 = l_Lean_Parser_tokenFn(x_5, x_10);
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_31, 0);
+lean_object* x_31; lean_object* x_32; 
+x_31 = lean_ctor_get(x_29, 0);
+lean_inc(x_31);
+x_32 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_31);
+lean_dec(x_31);
+if (lean_obj_tag(x_32) == 2)
+{
+lean_object* x_33; lean_object* x_34; uint8_t x_35; 
+x_33 = lean_ctor_get(x_32, 1);
 lean_inc(x_33);
-x_34 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_33);
+lean_dec(x_32);
+x_34 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_35 = lean_string_dec_eq(x_33, x_34);
 lean_dec(x_33);
-if (lean_obj_tag(x_34) == 2)
+if (x_35 == 0)
 {
-lean_object* x_35; lean_object* x_36; uint8_t x_37; 
-x_35 = lean_ctor_get(x_34, 1);
-lean_inc(x_35);
-lean_dec(x_34);
-x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_37 = lean_string_dec_eq(x_35, x_36);
-lean_dec(x_35);
-if (x_37 == 0)
-{
-lean_object* x_38; lean_object* x_39; 
-x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_16);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_16);
-x_17 = x_39;
-goto block_30;
+lean_object* x_36; lean_object* x_37; 
+x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_14);
+x_15 = x_37;
+goto block_28;
 }
 else
 {
-x_17 = x_31;
-goto block_30;
+x_15 = x_29;
+goto block_28;
+}
+}
+else
+{
+lean_object* x_38; lean_object* x_39; 
+lean_dec(x_32);
+x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_14);
+x_15 = x_39;
+goto block_28;
 }
 }
 else
 {
 lean_object* x_40; lean_object* x_41; 
-lean_dec(x_34);
+lean_dec(x_30);
 x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_14);
+x_15 = x_41;
+goto block_28;
+}
+block_28:
+{
+lean_object* x_16; 
+x_16 = lean_ctor_get(x_15, 3);
 lean_inc(x_16);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_16);
-x_17 = x_41;
-goto block_30;
-}
-}
-else
+if (lean_obj_tag(x_16) == 0)
 {
-lean_object* x_42; lean_object* x_43; 
-lean_dec(x_32);
-x_42 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_16);
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_16);
-x_17 = x_43;
-goto block_30;
-}
-block_30:
+lean_dec(x_14);
+lean_dec(x_13);
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_dec(x_16);
-lean_dec(x_15);
-{
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_17;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_15;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-lean_dec(x_18);
-lean_dec(x_7);
-lean_dec(x_6);
-x_20 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
-lean_dec(x_15);
-x_21 = lean_ctor_get(x_20, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+lean_dec(x_16);
+lean_dec(x_5);
+x_18 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
+lean_dec(x_13);
+x_19 = lean_ctor_get(x_18, 0);
+lean_inc(x_19);
+x_20 = lean_array_get_size(x_19);
+lean_dec(x_19);
+x_21 = lean_nat_sub(x_20, x_2);
+lean_dec(x_20);
+x_22 = lean_unsigned_to_nat(1u);
+x_23 = lean_nat_dec_eq(x_21, x_22);
 lean_dec(x_21);
-x_23 = lean_nat_sub(x_22, x_3);
-lean_dec(x_22);
-x_24 = lean_unsigned_to_nat(1u);
-x_25 = lean_nat_dec_eq(x_23, x_24);
-lean_dec(x_23);
-if (x_25 == 0)
+if (x_23 == 0)
+{
+lean_object* x_24; lean_object* x_25; 
+x_24 = l_Lean_nullKind;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_2);
+return x_25;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_26; lean_object* x_27; 
 x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_3);
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_2);
 return x_27;
 }
 else
 {
+lean_dec(x_2);
+return x_18;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_11);
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_3);
-return x_29;
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_42 = lean_box(0);
+x_43 = l_Lean_Parser_ParserState_pushSyntax(x_10, x_42);
+x_44 = l_Lean_nullKind;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_2);
+return x_45;
 }
 else
 {
-lean_dec(x_3);
-return x_20;
-}
-}
-}
-}
-}
-else
-{
-lean_dec(x_13);
-lean_dec(x_7);
-lean_dec(x_6);
-if (x_5 == 0)
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_44 = lean_box(0);
-x_45 = l_Lean_Parser_ParserState_pushSyntax(x_12, x_44);
-x_46 = l_Lean_nullKind;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_3);
-return x_47;
-}
-else
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
-x_48 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_11);
-lean_dec(x_10);
-x_49 = lean_ctor_get(x_48, 0);
-lean_inc(x_49);
-x_50 = lean_array_get_size(x_49);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; 
+x_46 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_47 = lean_ctor_get(x_46, 0);
+lean_inc(x_47);
+x_48 = lean_array_get_size(x_47);
+lean_dec(x_47);
+x_49 = lean_nat_sub(x_48, x_2);
+lean_dec(x_48);
+x_50 = lean_unsigned_to_nat(2u);
+x_51 = lean_nat_dec_eq(x_49, x_50);
 lean_dec(x_49);
-x_51 = lean_nat_sub(x_50, x_3);
-lean_dec(x_50);
-x_52 = lean_unsigned_to_nat(2u);
-x_53 = lean_nat_dec_eq(x_51, x_52);
-lean_dec(x_51);
-if (x_53 == 0)
+if (x_51 == 0)
+{
+lean_object* x_52; lean_object* x_53; 
+x_52 = l_Lean_nullKind;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_46, x_52, x_2);
+return x_53;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_54; lean_object* x_55; 
 x_54 = l_Lean_nullKind;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_3);
+x_55 = l_Lean_Parser_ParserState_mkNode(x_46, x_54, x_2);
 return x_55;
 }
 else
 {
-if (x_4 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_3);
-return x_57;
-}
-else
-{
-lean_object* x_58; 
-lean_dec(x_3);
-x_58 = l_Lean_Parser_ParserState_popSyntax(x_48);
-return x_58;
+lean_object* x_56; 
+lean_dec(x_2);
+x_56 = l_Lean_Parser_ParserState_popSyntax(x_46);
+return x_56;
 }
 }
 }
 }
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = 0;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2(x_1, x_2, x_8, x_3, x_9, x_4, x_5, x_6);
-return x_10;
+lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = 0;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2(x_1, x_6, x_2, x_7, x_3, x_4);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_openRenaming___elambda__1___closed__1() {
@@ -23507,13 +22910,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_openRenaming___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_openRenaming___elambda__1___closed__5() {
@@ -23565,254 +22967,242 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_openRenaming___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_openRenaming___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_8);
-lean_dec(x_8);
-lean_inc(x_3);
+x_6 = lean_ctor_get(x_2, 1);
+lean_inc(x_6);
+x_7 = lean_array_get_size(x_5);
+lean_dec(x_5);
 lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-if (lean_is_exclusive(x_3)) {
- lean_ctor_release(x_3, 0);
- lean_ctor_release(x_3, 1);
- lean_ctor_release(x_3, 2);
- lean_ctor_release(x_3, 3);
- x_12 = x_3;
+x_8 = lean_apply_2(x_4, x_1, x_2);
+if (lean_is_exclusive(x_2)) {
+ lean_ctor_release(x_2, 0);
+ lean_ctor_release(x_2, 1);
+ lean_ctor_release(x_2, 2);
+ lean_ctor_release(x_2, 3);
+ x_9 = x_2;
 } else {
- lean_dec_ref(x_3);
- x_12 = lean_box(0);
+ lean_dec_ref(x_2);
+ x_9 = lean_box(0);
 }
-x_13 = lean_ctor_get(x_11, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+x_10 = lean_ctor_get(x_8, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
 {
-lean_dec(x_12);
-lean_dec(x_10);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_11, 1);
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_8, 1);
+lean_inc(x_12);
+x_13 = lean_nat_dec_eq(x_12, x_6);
+lean_dec(x_12);
+if (x_13 == 0)
+{
+lean_dec(x_11);
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_36; lean_object* x_37; 
+lean_inc(x_6);
+x_14 = l_Lean_Parser_ParserState_restore(x_8, x_7, x_6);
+lean_dec(x_7);
+x_15 = lean_ctor_get(x_14, 0);
 lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_15, x_9);
+x_16 = lean_array_get_size(x_15);
 lean_dec(x_15);
-if (x_16 == 0)
-{
-lean_dec(x_14);
-lean_dec(x_12);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-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_40; lean_object* x_41; 
-lean_inc(x_9);
-x_17 = l_Lean_Parser_ParserState_restore(x_11, x_10, x_9);
-lean_dec(x_10);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_array_get_size(x_18);
-lean_dec(x_18);
-lean_inc(x_2);
 lean_inc(x_1);
-x_40 = lean_apply_3(x_5, x_1, x_2, x_17);
-x_41 = lean_ctor_get(x_40, 3);
+x_36 = l_Lean_Parser_ident___elambda__1(x_1, x_14);
+x_37 = lean_ctor_get(x_36, 3);
+lean_inc(x_37);
+if (lean_obj_tag(x_37) == 0)
+{
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_38 = lean_ctor_get(x_36, 1);
+lean_inc(x_38);
+lean_inc(x_1);
+x_39 = l_Lean_Parser_tokenFn(x_1, x_36);
+x_40 = lean_ctor_get(x_39, 3);
+lean_inc(x_40);
+if (lean_obj_tag(x_40) == 0)
+{
+lean_object* x_41; lean_object* x_42; 
+x_41 = lean_ctor_get(x_39, 0);
 lean_inc(x_41);
-if (lean_obj_tag(x_41) == 0)
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_42 = lean_ctor_get(x_40, 1);
-lean_inc(x_42);
-lean_inc(x_2);
-x_43 = l_Lean_Parser_tokenFn(x_2, x_40);
-x_44 = lean_ctor_get(x_43, 3);
-lean_inc(x_44);
-if (lean_obj_tag(x_44) == 0)
-{
-lean_object* x_45; lean_object* x_46; 
-x_45 = lean_ctor_get(x_43, 0);
-lean_inc(x_45);
-x_46 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_45);
-lean_dec(x_45);
-if (lean_obj_tag(x_46) == 2)
-{
-lean_object* x_47; lean_object* x_48; uint8_t x_49; 
-x_47 = lean_ctor_get(x_46, 1);
-lean_inc(x_47);
-lean_dec(x_46);
-x_48 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__6;
-x_49 = lean_string_dec_eq(x_47, x_48);
-lean_dec(x_47);
-if (x_49 == 0)
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-x_50 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__9;
-x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_50, x_42);
-x_52 = lean_ctor_get(x_51, 0);
-lean_inc(x_52);
-x_53 = lean_ctor_get(x_51, 2);
-lean_inc(x_53);
-x_54 = lean_ctor_get(x_51, 3);
-lean_inc(x_54);
-x_20 = x_51;
-x_21 = x_52;
-x_22 = x_53;
-x_23 = x_54;
-goto block_39;
-}
-else
-{
-lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-lean_dec(x_42);
-x_55 = lean_ctor_get(x_43, 0);
-lean_inc(x_55);
-x_56 = lean_ctor_get(x_43, 2);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_43, 3);
-lean_inc(x_57);
-x_20 = x_43;
-x_21 = x_55;
-x_22 = x_56;
-x_23 = x_57;
-goto block_39;
-}
-}
-else
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
-lean_dec(x_46);
-x_58 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__9;
-x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_58, x_42);
-x_60 = lean_ctor_get(x_59, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_59, 2);
-lean_inc(x_61);
-x_62 = lean_ctor_get(x_59, 3);
-lean_inc(x_62);
-x_20 = x_59;
-x_21 = x_60;
-x_22 = x_61;
-x_23 = x_62;
-goto block_39;
-}
-}
-else
-{
-lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-lean_dec(x_44);
-x_63 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__9;
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_63, x_42);
-x_65 = lean_ctor_get(x_64, 0);
-lean_inc(x_65);
-x_66 = lean_ctor_get(x_64, 2);
-lean_inc(x_66);
-x_67 = lean_ctor_get(x_64, 3);
-lean_inc(x_67);
-x_20 = x_64;
-x_21 = x_65;
-x_22 = x_66;
-x_23 = x_67;
-goto block_39;
-}
-}
-else
-{
-lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+x_42 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_41);
 lean_dec(x_41);
-x_68 = lean_ctor_get(x_40, 0);
-lean_inc(x_68);
-x_69 = lean_ctor_get(x_40, 2);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_40, 3);
-lean_inc(x_70);
-x_20 = x_40;
-x_21 = x_68;
-x_22 = x_69;
-x_23 = x_70;
-goto block_39;
+if (lean_obj_tag(x_42) == 2)
+{
+lean_object* x_43; lean_object* x_44; uint8_t x_45; 
+x_43 = lean_ctor_get(x_42, 1);
+lean_inc(x_43);
+lean_dec(x_42);
+x_44 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__6;
+x_45 = lean_string_dec_eq(x_43, x_44);
+lean_dec(x_43);
+if (x_45 == 0)
+{
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_46 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__9;
+x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_46, x_38);
+x_48 = lean_ctor_get(x_47, 0);
+lean_inc(x_48);
+x_49 = lean_ctor_get(x_47, 2);
+lean_inc(x_49);
+x_50 = lean_ctor_get(x_47, 3);
+lean_inc(x_50);
+x_17 = x_47;
+x_18 = x_48;
+x_19 = x_49;
+x_20 = x_50;
+goto block_35;
 }
-block_39:
+else
 {
-if (lean_obj_tag(x_23) == 0)
+lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+lean_dec(x_38);
+x_51 = lean_ctor_get(x_39, 0);
+lean_inc(x_51);
+x_52 = lean_ctor_get(x_39, 2);
+lean_inc(x_52);
+x_53 = lean_ctor_get(x_39, 3);
+lean_inc(x_53);
+x_17 = x_39;
+x_18 = x_51;
+x_19 = x_52;
+x_20 = x_53;
+goto block_35;
+}
+}
+else
 {
-lean_object* x_24; 
-lean_dec(x_22);
+lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+lean_dec(x_42);
+x_54 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__9;
+x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_54, x_38);
+x_56 = lean_ctor_get(x_55, 0);
+lean_inc(x_56);
+x_57 = lean_ctor_get(x_55, 2);
+lean_inc(x_57);
+x_58 = lean_ctor_get(x_55, 3);
+lean_inc(x_58);
+x_17 = x_55;
+x_18 = x_56;
+x_19 = x_57;
+x_20 = x_58;
+goto block_35;
+}
+}
+else
+{
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+lean_dec(x_40);
+x_59 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__9;
+x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_59, x_38);
+x_61 = lean_ctor_get(x_60, 0);
+lean_inc(x_61);
+x_62 = lean_ctor_get(x_60, 2);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_60, 3);
+lean_inc(x_63);
+x_17 = x_60;
+x_18 = x_61;
+x_19 = x_62;
+x_20 = x_63;
+goto block_35;
+}
+}
+else
+{
+lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+lean_dec(x_37);
+x_64 = lean_ctor_get(x_36, 0);
+lean_inc(x_64);
+x_65 = lean_ctor_get(x_36, 2);
+lean_inc(x_65);
+x_66 = lean_ctor_get(x_36, 3);
+lean_inc(x_66);
+x_17 = x_36;
+x_18 = x_64;
+x_19 = x_65;
+x_20 = x_66;
+goto block_35;
+}
+block_35:
+{
+if (lean_obj_tag(x_20) == 0)
+{
+lean_object* x_21; 
+lean_dec(x_19);
+lean_dec(x_18);
+lean_dec(x_9);
+x_21 = lean_ctor_get(x_17, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+uint8_t x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+x_22 = 0;
+x_23 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1(x_22, x_22, x_1, x_17);
+x_24 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_6);
+lean_dec(x_6);
+return x_26;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
 lean_dec(x_21);
-lean_dec(x_12);
-x_24 = lean_ctor_get(x_20, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-uint8_t x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-x_25 = 0;
-x_26 = 0;
-x_27 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1(x_25, x_26, x_26, x_1, x_2, x_20);
-x_28 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_19);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_14, x_9);
-lean_dec(x_9);
-return x_30;
-}
-else
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-lean_dec(x_24);
-lean_dec(x_2);
 lean_dec(x_1);
-x_31 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_20, x_31, x_19);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_14, x_9);
-lean_dec(x_9);
-return x_33;
+x_27 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_17, x_27, x_16);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_6);
+lean_dec(x_6);
+return x_29;
 }
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_34 = l_Array_shrink___main___rarg(x_21, x_19);
-lean_inc(x_9);
-if (lean_is_scalar(x_12)) {
- x_35 = lean_alloc_ctor(0, 4, 0);
+x_30 = l_Array_shrink___main___rarg(x_18, x_16);
+lean_inc(x_6);
+if (lean_is_scalar(x_9)) {
+ x_31 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_35 = x_12;
+ x_31 = x_9;
 }
-lean_ctor_set(x_35, 0, x_34);
-lean_ctor_set(x_35, 1, x_9);
-lean_ctor_set(x_35, 2, x_22);
-lean_ctor_set(x_35, 3, x_23);
-x_36 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_19);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_14, x_9);
-lean_dec(x_9);
-return x_38;
+lean_ctor_set(x_31, 0, x_30);
+lean_ctor_set(x_31, 1, x_6);
+lean_ctor_set(x_31, 2, x_19);
+lean_ctor_set(x_31, 3, x_20);
+x_32 = l_Lean_Parser_Command_openRenaming___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_16);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_6);
+lean_dec(x_6);
+return x_34;
 }
 }
 }
@@ -23833,7 +23223,7 @@ lean_object* _init_l_Lean_Parser_Command_openRenaming___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_openRenaming___closed__1;
@@ -23889,7 +23279,7 @@ lean_object* _init_l_Lean_Parser_Command_openRenaming___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openRenaming___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openRenaming___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -23913,36 +23303,32 @@ x_1 = l_Lean_Parser_Command_openRenaming___closed__8;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
-lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-return x_13;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
 x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_8 = lean_unbox(x_2);
-lean_dec(x_2);
-x_9 = lean_unbox(x_3);
+x_8 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1(x_7, x_8, x_9, x_4, x_5, x_6);
+x_9 = lean_unbox(x_4);
+lean_dec(x_4);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Command_openRenaming___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
 return x_10;
 }
 }
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox(x_1);
+lean_dec(x_1);
+x_6 = lean_unbox(x_2);
+lean_dec(x_2);
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Command_openRenaming___elambda__1___spec__1(x_5, x_6, x_3, x_4);
+return x_7;
+}
+}
 lean_object* _init_l_Lean_Parser_Command_openOnly___elambda__1___closed__1() {
 _start:
 {
@@ -23974,379 +23360,359 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_openOnly___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_openOnly___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_openOnly___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_openOnly___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_openOnly___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_openOnly___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_openOnly___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_openOnly___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_openOnly___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_8);
-lean_dec(x_8);
-lean_inc(x_3);
+x_6 = lean_ctor_get(x_2, 1);
+lean_inc(x_6);
+x_7 = lean_array_get_size(x_5);
+lean_dec(x_5);
 lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-if (lean_is_exclusive(x_3)) {
- lean_ctor_release(x_3, 0);
- lean_ctor_release(x_3, 1);
- lean_ctor_release(x_3, 2);
- lean_ctor_release(x_3, 3);
- x_12 = x_3;
+x_8 = lean_apply_2(x_4, x_1, x_2);
+if (lean_is_exclusive(x_2)) {
+ lean_ctor_release(x_2, 0);
+ lean_ctor_release(x_2, 1);
+ lean_ctor_release(x_2, 2);
+ lean_ctor_release(x_2, 3);
+ x_9 = x_2;
 } else {
- lean_dec_ref(x_3);
- x_12 = lean_box(0);
+ lean_dec_ref(x_2);
+ x_9 = lean_box(0);
 }
-x_13 = lean_ctor_get(x_11, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+x_10 = lean_ctor_get(x_8, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
 {
-lean_dec(x_12);
-lean_dec(x_10);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_11, 1);
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_8, 1);
+lean_inc(x_12);
+x_13 = lean_nat_dec_eq(x_12, x_6);
+lean_dec(x_12);
+if (x_13 == 0)
+{
+lean_dec(x_11);
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_72; lean_object* x_73; 
+lean_inc(x_6);
+x_14 = l_Lean_Parser_ParserState_restore(x_8, x_7, x_6);
+lean_dec(x_7);
+x_15 = lean_ctor_get(x_14, 0);
 lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_15, x_9);
+x_16 = lean_array_get_size(x_15);
 lean_dec(x_15);
-if (x_16 == 0)
-{
-lean_dec(x_14);
-lean_dec(x_12);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_76; lean_object* x_77; 
-lean_inc(x_9);
-x_17 = l_Lean_Parser_ParserState_restore(x_11, x_10, x_9);
-lean_dec(x_10);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_array_get_size(x_18);
-lean_dec(x_18);
-lean_inc(x_5);
-lean_inc(x_2);
 lean_inc(x_1);
-x_76 = lean_apply_3(x_5, x_1, x_2, x_17);
-x_77 = lean_ctor_get(x_76, 3);
+x_72 = l_Lean_Parser_ident___elambda__1(x_1, x_14);
+x_73 = lean_ctor_get(x_72, 3);
+lean_inc(x_73);
+if (lean_obj_tag(x_73) == 0)
+{
+lean_object* x_74; lean_object* x_75; lean_object* x_76; 
+x_74 = lean_ctor_get(x_72, 1);
+lean_inc(x_74);
+lean_inc(x_1);
+x_75 = l_Lean_Parser_tokenFn(x_1, x_72);
+x_76 = lean_ctor_get(x_75, 3);
+lean_inc(x_76);
+if (lean_obj_tag(x_76) == 0)
+{
+lean_object* x_77; lean_object* x_78; 
+x_77 = lean_ctor_get(x_75, 0);
 lean_inc(x_77);
-if (lean_obj_tag(x_77) == 0)
-{
-lean_object* x_78; lean_object* x_79; lean_object* x_80; 
-x_78 = lean_ctor_get(x_76, 1);
-lean_inc(x_78);
-lean_inc(x_2);
-x_79 = l_Lean_Parser_tokenFn(x_2, x_76);
-x_80 = lean_ctor_get(x_79, 3);
-lean_inc(x_80);
-if (lean_obj_tag(x_80) == 0)
-{
-lean_object* x_81; lean_object* x_82; 
-x_81 = lean_ctor_get(x_79, 0);
-lean_inc(x_81);
-x_82 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_81);
-lean_dec(x_81);
-if (lean_obj_tag(x_82) == 2)
-{
-lean_object* x_83; lean_object* x_84; uint8_t x_85; 
-x_83 = lean_ctor_get(x_82, 1);
-lean_inc(x_83);
-lean_dec(x_82);
-x_84 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_85 = lean_string_dec_eq(x_83, x_84);
-lean_dec(x_83);
-if (x_85 == 0)
-{
-lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
-x_86 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_78);
-x_88 = lean_ctor_get(x_87, 0);
-lean_inc(x_88);
-x_89 = lean_ctor_get(x_87, 2);
-lean_inc(x_89);
-x_90 = lean_ctor_get(x_87, 3);
-lean_inc(x_90);
-x_52 = x_87;
-x_53 = x_88;
-x_54 = x_89;
-x_55 = x_90;
-goto block_75;
-}
-else
-{
-lean_object* x_91; lean_object* x_92; lean_object* x_93; 
-lean_dec(x_78);
-x_91 = lean_ctor_get(x_79, 0);
-lean_inc(x_91);
-x_92 = lean_ctor_get(x_79, 2);
-lean_inc(x_92);
-x_93 = lean_ctor_get(x_79, 3);
-lean_inc(x_93);
-x_52 = x_79;
-x_53 = x_91;
-x_54 = x_92;
-x_55 = x_93;
-goto block_75;
-}
-}
-else
-{
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; 
-lean_dec(x_82);
-x_94 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_94, x_78);
-x_96 = lean_ctor_get(x_95, 0);
-lean_inc(x_96);
-x_97 = lean_ctor_get(x_95, 2);
-lean_inc(x_97);
-x_98 = lean_ctor_get(x_95, 3);
-lean_inc(x_98);
-x_52 = x_95;
-x_53 = x_96;
-x_54 = x_97;
-x_55 = x_98;
-goto block_75;
-}
-}
-else
-{
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; 
-lean_dec(x_80);
-x_99 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_99, x_78);
-x_101 = lean_ctor_get(x_100, 0);
-lean_inc(x_101);
-x_102 = lean_ctor_get(x_100, 2);
-lean_inc(x_102);
-x_103 = lean_ctor_get(x_100, 3);
-lean_inc(x_103);
-x_52 = x_100;
-x_53 = x_101;
-x_54 = x_102;
-x_55 = x_103;
-goto block_75;
-}
-}
-else
-{
-lean_object* x_104; lean_object* x_105; lean_object* x_106; 
+x_78 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_77);
 lean_dec(x_77);
-x_104 = lean_ctor_get(x_76, 0);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_76, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_76, 3);
-lean_inc(x_106);
-x_52 = x_76;
-x_53 = x_104;
-x_54 = x_105;
-x_55 = x_106;
-goto block_75;
-}
-block_51:
+if (lean_obj_tag(x_78) == 2)
 {
-lean_object* x_21; 
+lean_object* x_79; lean_object* x_80; uint8_t x_81; 
+x_79 = lean_ctor_get(x_78, 1);
+lean_inc(x_79);
+lean_dec(x_78);
+x_80 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_81 = lean_string_dec_eq(x_79, x_80);
+lean_dec(x_79);
+if (x_81 == 0)
+{
+lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
+x_82 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+x_83 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_82, x_74);
+x_84 = lean_ctor_get(x_83, 0);
+lean_inc(x_84);
+x_85 = lean_ctor_get(x_83, 2);
+lean_inc(x_85);
+x_86 = lean_ctor_get(x_83, 3);
+lean_inc(x_86);
+x_49 = x_83;
+x_50 = x_84;
+x_51 = x_85;
+x_52 = x_86;
+goto block_71;
+}
+else
+{
+lean_object* x_87; lean_object* x_88; lean_object* x_89; 
+lean_dec(x_74);
+x_87 = lean_ctor_get(x_75, 0);
+lean_inc(x_87);
+x_88 = lean_ctor_get(x_75, 2);
+lean_inc(x_88);
+x_89 = lean_ctor_get(x_75, 3);
+lean_inc(x_89);
+x_49 = x_75;
+x_50 = x_87;
+x_51 = x_88;
+x_52 = x_89;
+goto block_71;
+}
+}
+else
+{
+lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; 
+lean_dec(x_78);
+x_90 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_90, x_74);
+x_92 = lean_ctor_get(x_91, 0);
+lean_inc(x_92);
+x_93 = lean_ctor_get(x_91, 2);
+lean_inc(x_93);
+x_94 = lean_ctor_get(x_91, 3);
+lean_inc(x_94);
+x_49 = x_91;
+x_50 = x_92;
+x_51 = x_93;
+x_52 = x_94;
+goto block_71;
+}
+}
+else
+{
+lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; 
+lean_dec(x_76);
+x_95 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+x_96 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_95, x_74);
+x_97 = lean_ctor_get(x_96, 0);
+lean_inc(x_97);
+x_98 = lean_ctor_get(x_96, 2);
+lean_inc(x_98);
+x_99 = lean_ctor_get(x_96, 3);
+lean_inc(x_99);
+x_49 = x_96;
+x_50 = x_97;
+x_51 = x_98;
+x_52 = x_99;
+goto block_71;
+}
+}
+else
+{
+lean_object* x_100; lean_object* x_101; lean_object* x_102; 
+lean_dec(x_73);
+x_100 = lean_ctor_get(x_72, 0);
+lean_inc(x_100);
+x_101 = lean_ctor_get(x_72, 2);
+lean_inc(x_101);
+x_102 = lean_ctor_get(x_72, 3);
+lean_inc(x_102);
+x_49 = x_72;
+x_50 = x_100;
+x_51 = x_101;
+x_52 = x_102;
+goto block_71;
+}
+block_48:
+{
+lean_object* x_18; 
+x_18 = lean_ctor_get(x_17, 3);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
+{
+lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_19 = lean_ctor_get(x_17, 1);
+lean_inc(x_19);
+x_20 = l_Lean_Parser_tokenFn(x_1, x_17);
 x_21 = lean_ctor_get(x_20, 3);
 lean_inc(x_21);
 if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_22 = lean_ctor_get(x_20, 1);
+lean_object* x_22; lean_object* x_23; 
+x_22 = lean_ctor_get(x_20, 0);
 lean_inc(x_22);
-x_23 = l_Lean_Parser_tokenFn(x_2, x_20);
-x_24 = lean_ctor_get(x_23, 3);
+x_23 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_22);
+lean_dec(x_22);
+if (lean_obj_tag(x_23) == 2)
+{
+lean_object* x_24; lean_object* x_25; uint8_t x_26; 
+x_24 = lean_ctor_get(x_23, 1);
 lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
+lean_dec(x_23);
+x_25 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_26 = lean_string_dec_eq(x_24, x_25);
+lean_dec(x_24);
+if (x_26 == 0)
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = lean_ctor_get(x_23, 0);
-lean_inc(x_25);
-x_26 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_25);
-lean_dec(x_25);
-if (lean_obj_tag(x_26) == 2)
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+x_27 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_27, x_19);
+x_29 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_6);
+lean_dec(x_6);
+return x_31;
+}
+else
 {
-lean_object* x_27; lean_object* x_28; uint8_t x_29; 
-x_27 = lean_ctor_get(x_26, 1);
-lean_inc(x_27);
-lean_dec(x_26);
-x_28 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_29 = lean_string_dec_eq(x_27, x_28);
-lean_dec(x_27);
-if (x_29 == 0)
-{
-lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_30 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22);
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_19);
 x_32 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_19);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_14, x_9);
-lean_dec(x_9);
+x_33 = l_Lean_Parser_ParserState_mkNode(x_20, x_32, x_16);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_6);
+lean_dec(x_6);
 return x_34;
 }
+}
 else
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_22);
-x_35 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_23, x_35, x_19);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_14, x_9);
-lean_dec(x_9);
-return x_37;
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+lean_dec(x_23);
+x_35 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_35, x_19);
+x_37 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
+x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_16);
+x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_6);
+lean_dec(x_6);
+return x_39;
 }
 }
 else
 {
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-lean_dec(x_26);
-x_38 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_38, x_22);
-x_40 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
-x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_19);
-x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_14, x_9);
-lean_dec(x_9);
-return x_42;
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+lean_dec(x_21);
+x_40 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_40, x_19);
+x_42 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
+x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_16);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_11, x_6);
+lean_dec(x_6);
+return x_44;
 }
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_dec(x_24);
-x_43 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_43, x_22);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_18);
+lean_dec(x_1);
 x_45 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_19);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_14, x_9);
-lean_dec(x_9);
+x_46 = l_Lean_Parser_ParserState_mkNode(x_17, x_45, x_16);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_11, x_6);
+lean_dec(x_6);
 return x_47;
 }
 }
-else
+block_71:
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-lean_dec(x_21);
-lean_dec(x_2);
-x_48 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_20, x_48, x_19);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_14, x_9);
+if (lean_obj_tag(x_52) == 0)
+{
+lean_object* x_53; 
+lean_dec(x_51);
+lean_dec(x_50);
 lean_dec(x_9);
-return x_50;
-}
-}
-block_75:
+x_53 = lean_ctor_get(x_49, 3);
+lean_inc(x_53);
+if (lean_obj_tag(x_53) == 0)
 {
-if (lean_obj_tag(x_55) == 0)
-{
-lean_object* x_56; 
+lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_54 = lean_ctor_get(x_49, 0);
+lean_inc(x_54);
+x_55 = lean_array_get_size(x_54);
 lean_dec(x_54);
-lean_dec(x_53);
-lean_dec(x_12);
-x_56 = lean_ctor_get(x_52, 3);
-lean_inc(x_56);
-if (lean_obj_tag(x_56) == 0)
-{
-lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_57 = lean_ctor_get(x_52, 0);
-lean_inc(x_57);
-x_58 = lean_array_get_size(x_57);
-lean_dec(x_57);
-lean_inc(x_5);
-lean_inc(x_2);
 lean_inc(x_1);
-x_59 = lean_apply_3(x_5, x_1, x_2, x_52);
-x_60 = lean_ctor_get(x_59, 3);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
+x_56 = l_Lean_Parser_ident___elambda__1(x_1, x_49);
+x_57 = lean_ctor_get(x_56, 3);
+lean_inc(x_57);
+if (lean_obj_tag(x_57) == 0)
 {
-uint8_t x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_61 = 0;
-lean_inc(x_2);
-x_62 = l_Lean_Parser_manyAux___main(x_61, x_5, x_1, x_2, x_59);
-x_63 = l_Lean_nullKind;
-x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_58);
-x_20 = x_64;
-goto block_51;
+lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+lean_inc(x_1);
+x_58 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(x_1, x_56);
+x_59 = l_Lean_nullKind;
+x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_55);
+x_17 = x_60;
+goto block_48;
 }
 else
 {
-lean_object* x_65; lean_object* x_66; 
-lean_dec(x_60);
-lean_dec(x_5);
-lean_dec(x_1);
-x_65 = l_Lean_nullKind;
-x_66 = l_Lean_Parser_ParserState_mkNode(x_59, x_65, x_58);
-x_20 = x_66;
-goto block_51;
+lean_object* x_61; lean_object* x_62; 
+lean_dec(x_57);
+x_61 = l_Lean_nullKind;
+x_62 = l_Lean_Parser_ParserState_mkNode(x_56, x_61, x_55);
+x_17 = x_62;
+goto block_48;
 }
 }
 else
 {
-lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-lean_dec(x_56);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_53);
 lean_dec(x_1);
-x_67 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
-x_68 = l_Lean_Parser_ParserState_mkNode(x_52, x_67, x_19);
-x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_14, x_9);
-lean_dec(x_9);
-return x_69;
+x_63 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
+x_64 = l_Lean_Parser_ParserState_mkNode(x_49, x_63, x_16);
+x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_11, x_6);
+lean_dec(x_6);
+return x_65;
 }
 }
 else
 {
-lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; 
-lean_dec(x_52);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+lean_dec(x_49);
 lean_dec(x_1);
-x_70 = l_Array_shrink___main___rarg(x_53, x_19);
-lean_inc(x_9);
-if (lean_is_scalar(x_12)) {
- x_71 = lean_alloc_ctor(0, 4, 0);
+x_66 = l_Array_shrink___main___rarg(x_50, x_16);
+lean_inc(x_6);
+if (lean_is_scalar(x_9)) {
+ x_67 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_71 = x_12;
+ x_67 = x_9;
 }
-lean_ctor_set(x_71, 0, x_70);
-lean_ctor_set(x_71, 1, x_9);
-lean_ctor_set(x_71, 2, x_54);
-lean_ctor_set(x_71, 3, x_55);
-x_72 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
-x_73 = l_Lean_Parser_ParserState_mkNode(x_71, x_72, x_19);
-x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_14, x_9);
-lean_dec(x_9);
-return x_74;
+lean_ctor_set(x_67, 0, x_66);
+lean_ctor_set(x_67, 1, x_6);
+lean_ctor_set(x_67, 2, x_51);
+lean_ctor_set(x_67, 3, x_52);
+x_68 = l_Lean_Parser_Command_openOnly___elambda__1___closed__2;
+x_69 = l_Lean_Parser_ParserState_mkNode(x_67, x_68, x_16);
+x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_11, x_6);
+lean_dec(x_6);
+return x_70;
 }
 }
 }
@@ -24357,10 +23723,10 @@ lean_object* _init_l_Lean_Parser_Command_openOnly___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
@@ -24401,7 +23767,7 @@ lean_object* _init_l_Lean_Parser_Command_openOnly___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openOnly___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openOnly___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -24456,110 +23822,96 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_openSimple___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_openSimple___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_openSimple___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_openSimple___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_openSimple___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_openSimple___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_openSimple___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_openSimple___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_openSimple___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_5);
-lean_inc(x_2);
 lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_16 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-uint8_t 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; 
-x_21 = 0;
-x_22 = l_Lean_Parser_manyAux___main(x_21, x_5, x_1, x_2, x_19);
-x_23 = l_Lean_nullKind;
-lean_inc(x_18);
-x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_18);
-x_25 = l_Lean_Parser_Command_openSimple___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplicitBinder___elambda__1___spec__1(x_1, x_16);
+x_19 = l_Lean_nullKind;
+lean_inc(x_15);
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_Command_openSimple___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
 }
 else
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_28 = l_Lean_nullKind;
-lean_inc(x_18);
-x_29 = l_Lean_Parser_ParserState_mkNode(x_19, x_28, x_18);
-x_30 = l_Lean_Parser_Command_openSimple___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_18);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_13, x_10);
-lean_dec(x_10);
-return x_32;
+x_24 = l_Lean_nullKind;
+lean_inc(x_15);
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_Command_openSimple___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 }
@@ -24569,7 +23921,7 @@ lean_object* _init_l_Lean_Parser_Command_openSimple___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_openSimple___elambda__1___closed__2;
@@ -24593,7 +23945,7 @@ lean_object* _init_l_Lean_Parser_Command_openSimple___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openSimple___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_openSimple___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -24648,13 +24000,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_open___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_open___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_open___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_open___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_open___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_open___elambda__1___closed__5() {
@@ -24706,317 +24057,304 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_open___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_open___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_open___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_open___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_79; lean_object* x_80; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_79 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_80 = lean_ctor_get(x_79, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_78; lean_object* x_79; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_78 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_79 = lean_ctor_get(x_78, 3);
+lean_inc(x_79);
+if (lean_obj_tag(x_79) == 0)
+{
+lean_object* x_80; lean_object* x_81; 
+x_80 = lean_ctor_get(x_78, 0);
 lean_inc(x_80);
-if (lean_obj_tag(x_80) == 0)
-{
-lean_object* x_81; lean_object* x_82; 
-x_81 = lean_ctor_get(x_79, 0);
-lean_inc(x_81);
-x_82 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_81);
-lean_dec(x_81);
-if (lean_obj_tag(x_82) == 2)
-{
-lean_object* x_83; lean_object* x_84; uint8_t x_85; 
-x_83 = lean_ctor_get(x_82, 1);
-lean_inc(x_83);
-lean_dec(x_82);
-x_84 = l_Lean_Parser_Command_open___elambda__1___closed__6;
-x_85 = lean_string_dec_eq(x_83, x_84);
-lean_dec(x_83);
-if (x_85 == 0)
-{
-lean_object* x_86; lean_object* x_87; 
-x_86 = l_Lean_Parser_Command_open___elambda__1___closed__9;
-lean_inc(x_8);
-x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_8);
-x_17 = x_87;
-goto block_78;
-}
-else
-{
-x_17 = x_79;
-goto block_78;
-}
-}
-else
-{
-lean_object* x_88; lean_object* x_89; 
-lean_dec(x_82);
-x_88 = l_Lean_Parser_Command_open___elambda__1___closed__9;
-lean_inc(x_8);
-x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_88, x_8);
-x_17 = x_89;
-goto block_78;
-}
-}
-else
-{
-lean_object* x_90; lean_object* x_91; 
+x_81 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_80);
 lean_dec(x_80);
-x_90 = l_Lean_Parser_Command_open___elambda__1___closed__9;
-lean_inc(x_8);
-x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_90, x_8);
-x_17 = x_91;
-goto block_78;
-}
-block_78:
+if (lean_obj_tag(x_81) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_82; lean_object* x_83; uint8_t x_84; 
+x_82 = lean_ctor_get(x_81, 1);
+lean_inc(x_82);
+lean_dec(x_81);
+x_83 = l_Lean_Parser_Command_open___elambda__1___closed__6;
+x_84 = lean_string_dec_eq(x_82, x_83);
+lean_dec(x_82);
+if (x_84 == 0)
+{
+lean_object* x_85; lean_object* x_86; 
+x_85 = l_Lean_Parser_Command_open___elambda__1___closed__9;
+lean_inc(x_7);
+x_86 = l_Lean_Parser_ParserState_mkErrorsAt(x_78, x_85, x_7);
+x_16 = x_86;
+goto block_77;
+}
+else
+{
+x_16 = x_78;
+goto block_77;
+}
+}
+else
+{
+lean_object* x_87; lean_object* x_88; 
+lean_dec(x_81);
+x_87 = l_Lean_Parser_Command_open___elambda__1___closed__9;
+lean_inc(x_7);
+x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_78, x_87, x_7);
+x_16 = x_88;
+goto block_77;
+}
+}
+else
+{
+lean_object* x_89; lean_object* x_90; 
+lean_dec(x_79);
+x_89 = l_Lean_Parser_Command_open___elambda__1___closed__9;
+lean_inc(x_7);
+x_90 = l_Lean_Parser_ParserState_mkErrorsAt(x_78, x_89, x_7);
+x_16 = x_90;
+goto block_77;
+}
+block_77:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-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);
-lean_inc(x_2);
-lean_inc(x_1);
-x_22 = l_Lean_Parser_Command_openHiding___elambda__1(x_1, x_2, x_17);
-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);
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_24 = l_Lean_Parser_Command_open___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_22, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
-}
-else
-{
-lean_object* x_27; lean_object* x_28; uint8_t x_29; 
-x_27 = lean_ctor_get(x_23, 0);
-lean_inc(x_27);
-lean_dec(x_23);
-x_28 = lean_ctor_get(x_22, 1);
-lean_inc(x_28);
-x_29 = lean_nat_dec_eq(x_28, x_21);
-lean_dec(x_28);
-if (x_29 == 0)
-{
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_27);
-lean_dec(x_21);
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_30 = l_Lean_Parser_Command_open___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_inc(x_21);
-x_33 = l_Lean_Parser_ParserState_restore(x_22, x_20, x_21);
-lean_dec(x_20);
-x_34 = lean_ctor_get(x_33, 0);
-lean_inc(x_34);
-x_35 = lean_array_get_size(x_34);
-lean_dec(x_34);
-lean_inc(x_2);
-lean_inc(x_1);
-x_36 = l_Lean_Parser_Command_openRenaming___elambda__1(x_1, x_2, x_33);
-x_37 = lean_ctor_get(x_36, 3);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_35);
-lean_dec(x_2);
-lean_dec(x_1);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_36, x_27, x_21);
-lean_dec(x_21);
-x_39 = l_Lean_Parser_Command_open___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
-}
-else
-{
-lean_object* x_42; lean_object* x_43; uint8_t x_44; 
-x_42 = lean_ctor_get(x_37, 0);
-lean_inc(x_42);
-lean_dec(x_37);
-x_43 = lean_ctor_get(x_36, 1);
-lean_inc(x_43);
-x_44 = lean_nat_dec_eq(x_43, x_21);
-lean_dec(x_43);
-if (x_44 == 0)
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_42);
-lean_dec(x_35);
-lean_dec(x_2);
-lean_dec(x_1);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_36, x_27, x_21);
-lean_dec(x_21);
-x_46 = l_Lean_Parser_Command_open___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
-}
-else
-{
-lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_inc(x_21);
-x_49 = l_Lean_Parser_ParserState_restore(x_36, x_35, x_21);
-lean_dec(x_35);
-x_50 = lean_ctor_get(x_49, 0);
-lean_inc(x_50);
-x_51 = lean_array_get_size(x_50);
-lean_dec(x_50);
-lean_inc(x_2);
-lean_inc(x_1);
-x_52 = l_Lean_Parser_Command_openOnly___elambda__1(x_1, x_2, x_49);
-x_53 = lean_ctor_get(x_52, 3);
-lean_inc(x_53);
-if (lean_obj_tag(x_53) == 0)
-{
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-lean_dec(x_51);
-lean_dec(x_2);
-lean_dec(x_1);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_52, x_42, x_21);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_27, x_21);
-lean_dec(x_21);
-x_56 = l_Lean_Parser_Command_open___elambda__1___closed__2;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_16);
-x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_11, x_8);
-lean_dec(x_8);
-return x_58;
-}
-else
-{
-lean_object* x_59; lean_object* x_60; uint8_t x_61; 
-x_59 = lean_ctor_get(x_53, 0);
-lean_inc(x_59);
-lean_dec(x_53);
-x_60 = lean_ctor_get(x_52, 1);
-lean_inc(x_60);
-x_61 = lean_nat_dec_eq(x_60, x_21);
-lean_dec(x_60);
-if (x_61 == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
-lean_dec(x_51);
-lean_dec(x_2);
-lean_dec(x_1);
-x_62 = l_Lean_Parser_mergeOrElseErrors(x_52, x_42, x_21);
-x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_27, x_21);
-lean_dec(x_21);
-x_64 = l_Lean_Parser_Command_open___elambda__1___closed__2;
-x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_16);
-x_66 = l_Lean_Parser_mergeOrElseErrors(x_65, x_11, x_8);
-lean_dec(x_8);
-return x_66;
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; 
-lean_inc(x_21);
-x_67 = l_Lean_Parser_ParserState_restore(x_52, x_51, x_21);
-lean_dec(x_51);
-x_68 = l_Lean_Parser_Command_openSimple___elambda__1(x_1, x_2, x_67);
-x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_59, x_21);
-x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_42, x_21);
-x_71 = l_Lean_Parser_mergeOrElseErrors(x_70, x_27, x_21);
-lean_dec(x_21);
-x_72 = l_Lean_Parser_Command_open___elambda__1___closed__2;
-x_73 = l_Lean_Parser_ParserState_mkNode(x_71, x_72, x_16);
-x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_11, x_8);
-lean_dec(x_8);
-return x_74;
-}
-}
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_75; lean_object* x_76; lean_object* x_77; 
+x_19 = lean_array_get_size(x_18);
 lean_dec(x_18);
-lean_dec(x_2);
+x_20 = lean_ctor_get(x_16, 1);
+lean_inc(x_20);
+lean_inc(x_1);
+x_21 = l_Lean_Parser_Command_openHiding___elambda__1(x_1, x_16);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_20);
+lean_dec(x_19);
 lean_dec(x_1);
-x_75 = l_Lean_Parser_Command_open___elambda__1___closed__2;
-x_76 = l_Lean_Parser_ParserState_mkNode(x_17, x_75, x_16);
-x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_11, x_8);
-lean_dec(x_8);
-return x_77;
+x_23 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
+}
+else
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_22, 0);
+lean_inc(x_26);
+lean_dec(x_22);
+x_27 = lean_ctor_get(x_21, 1);
+lean_inc(x_27);
+x_28 = lean_nat_dec_eq(x_27, x_20);
+lean_dec(x_27);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_26);
+lean_dec(x_20);
+lean_dec(x_19);
+lean_dec(x_1);
+x_29 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_21, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
+}
+else
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_inc(x_20);
+x_32 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+lean_dec(x_19);
+x_33 = lean_ctor_get(x_32, 0);
+lean_inc(x_33);
+x_34 = lean_array_get_size(x_33);
+lean_dec(x_33);
+lean_inc(x_1);
+x_35 = l_Lean_Parser_Command_openRenaming___elambda__1(x_1, x_32);
+x_36 = lean_ctor_get(x_35, 3);
+lean_inc(x_36);
+if (lean_obj_tag(x_36) == 0)
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_34);
+lean_dec(x_1);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_35, x_26, x_20);
+lean_dec(x_20);
+x_38 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+else
+{
+lean_object* x_41; lean_object* x_42; uint8_t x_43; 
+x_41 = lean_ctor_get(x_36, 0);
+lean_inc(x_41);
+lean_dec(x_36);
+x_42 = lean_ctor_get(x_35, 1);
+lean_inc(x_42);
+x_43 = lean_nat_dec_eq(x_42, x_20);
+lean_dec(x_42);
+if (x_43 == 0)
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_41);
+lean_dec(x_34);
+lean_dec(x_1);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_35, x_26, x_20);
+lean_dec(x_20);
+x_45 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_10, x_7);
+lean_dec(x_7);
+return x_47;
+}
+else
+{
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_inc(x_20);
+x_48 = l_Lean_Parser_ParserState_restore(x_35, x_34, x_20);
+lean_dec(x_34);
+x_49 = lean_ctor_get(x_48, 0);
+lean_inc(x_49);
+x_50 = lean_array_get_size(x_49);
+lean_dec(x_49);
+lean_inc(x_1);
+x_51 = l_Lean_Parser_Command_openOnly___elambda__1(x_1, x_48);
+x_52 = lean_ctor_get(x_51, 3);
+lean_inc(x_52);
+if (lean_obj_tag(x_52) == 0)
+{
+lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_dec(x_50);
+lean_dec(x_1);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_51, x_41, x_20);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_26, x_20);
+lean_dec(x_20);
+x_55 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+x_56 = l_Lean_Parser_ParserState_mkNode(x_54, x_55, x_15);
+x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_10, x_7);
+lean_dec(x_7);
+return x_57;
+}
+else
+{
+lean_object* x_58; lean_object* x_59; uint8_t x_60; 
+x_58 = lean_ctor_get(x_52, 0);
+lean_inc(x_58);
+lean_dec(x_52);
+x_59 = lean_ctor_get(x_51, 1);
+lean_inc(x_59);
+x_60 = lean_nat_dec_eq(x_59, x_20);
+lean_dec(x_59);
+if (x_60 == 0)
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_58);
+lean_dec(x_50);
+lean_dec(x_1);
+x_61 = l_Lean_Parser_mergeOrElseErrors(x_51, x_41, x_20);
+x_62 = l_Lean_Parser_mergeOrElseErrors(x_61, x_26, x_20);
+lean_dec(x_20);
+x_63 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_15);
+x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_10, x_7);
+lean_dec(x_7);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_inc(x_20);
+x_66 = l_Lean_Parser_ParserState_restore(x_51, x_50, x_20);
+lean_dec(x_50);
+x_67 = l_Lean_Parser_Command_openSimple___elambda__1(x_1, x_66);
+x_68 = l_Lean_Parser_mergeOrElseErrors(x_67, x_58, x_20);
+x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_41, x_20);
+x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_26, x_20);
+lean_dec(x_20);
+x_71 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+x_72 = l_Lean_Parser_ParserState_mkNode(x_70, x_71, x_15);
+x_73 = l_Lean_Parser_mergeOrElseErrors(x_72, x_10, x_7);
+lean_dec(x_7);
+return x_73;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_74; lean_object* x_75; lean_object* x_76; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_74 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_16, x_74, x_15);
+x_76 = l_Lean_Parser_mergeOrElseErrors(x_75, x_10, x_7);
+lean_dec(x_7);
+return x_76;
 }
 }
 }
@@ -25107,7 +24445,7 @@ lean_object* _init_l_Lean_Parser_Command_open___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_open___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_open___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -25134,10 +24472,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_open(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_open___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_open;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -25280,8 +24618,6 @@ l_Lean_Parser_Command_attrInstance___elambda__1___closed__3 = _init_l_Lean_Parse
 lean_mark_persistent(l_Lean_Parser_Command_attrInstance___elambda__1___closed__3);
 l_Lean_Parser_Command_attrInstance___elambda__1___closed__4 = _init_l_Lean_Parser_Command_attrInstance___elambda__1___closed__4();
 lean_mark_persistent(l_Lean_Parser_Command_attrInstance___elambda__1___closed__4);
-l_Lean_Parser_Command_attrInstance___elambda__1___closed__5 = _init_l_Lean_Parser_Command_attrInstance___elambda__1___closed__5();
-lean_mark_persistent(l_Lean_Parser_Command_attrInstance___elambda__1___closed__5);
 l_Lean_Parser_Command_attrInstance___closed__1 = _init_l_Lean_Parser_Command_attrInstance___closed__1();
 lean_mark_persistent(l_Lean_Parser_Command_attrInstance___closed__1);
 l_Lean_Parser_Command_attrInstance___closed__2 = _init_l_Lean_Parser_Command_attrInstance___closed__2();
diff --git a/stage0/stdlib/Init/Lean/Parser/Level.c b/stage0/stdlib/Init/Lean/Parser/Level.c
index 29c9944082..2342d10cdf 100644
--- a/stage0/stdlib/Init/Lean/Parser/Level.c
+++ b/stage0/stdlib/Init/Lean/Parser/Level.c
@@ -18,7 +18,7 @@ extern lean_object* l_Lean_Parser_manyAux___main___closed__1;
 lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__4;
 lean_object* l_Lean_Parser_andthenInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_regBuiltinLevelParserAttr___closed__1;
-lean_object* l_Lean_Parser_Level_ident___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Level_ident___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_addLit___closed__2;
 extern lean_object* l_Lean_nullKind;
 lean_object* l_Lean_Parser_Level_paren___closed__2;
@@ -32,12 +32,12 @@ lean_object* l_Lean_Parser_Level_num___elambda__1___closed__4;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 lean_object* l_Lean_Parser_Level_hole___closed__5;
 lean_object* l_Lean_Parser_Level_hole___closed__3;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_regBuiltinLevelParserAttr___closed__2;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Level_ident;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_num(lean_object*);
 extern lean_object* l_Lean_Level_LevelToFormat_Result_format___main___closed__1;
-lean_object* l_Lean_Parser_ident(uint8_t);
+extern lean_object* l_Lean_Parser_ident;
 lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_max(lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkNode(lean_object*, lean_object*, lean_object*);
@@ -48,13 +48,14 @@ lean_object* l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
 lean_object* l_Lean_Parser_Level_paren___closed__7;
 lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__5;
 lean_object* l_Lean_Parser_ParserState_mkTrailingNode(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Level_hole___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_addBuiltinParser(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Level_hole___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_addBuiltinParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__3;
 lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_tokenFn(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_paren___closed__5;
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_Level_paren___closed__3;
 lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Level_num___closed__1;
@@ -66,7 +67,7 @@ lean_object* l_Lean_Parser_Level_max___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Level_max___closed__3;
 lean_object* l_Lean_Parser_Level_max___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Level_paren___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Level_paren___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_regBuiltinLevelParserAttr___closed__3;
 lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Level_ident___closed__3;
@@ -74,82 +75,76 @@ lean_object* l___regBuiltinParser_Lean_Parser_Level_paren(lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nonReservedSymbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nodeInfo(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Level_addLit___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Level_addLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__7;
 lean_object* l_Lean_Parser_nonReservedSymbolInfo(lean_object*, uint8_t);
 lean_object* l_Lean_Parser_Level_paren;
 lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Level_num___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_levelParser___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Level_num___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Level_max___closed__6;
 lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Level_imax;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
 extern lean_object* l_Char_HasRepr___closed__1;
 lean_object* l_Lean_Parser_Level_hole;
 extern lean_object* l_Lean_Level_LevelToFormat_Result_format___main___closed__5;
 lean_object* l_Lean_Parser_orelseInfo(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_levelParser(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_levelParser(lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_num___elambda__1___closed__3;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Level_num___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_object* l_Lean_Parser_Level_imax___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Level_imax___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_ident___closed__1;
 lean_object* l_Lean_Parser_registerBuiltinParserAttribute(lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Parser_Level_addLit___closed__5;
 lean_object* l_Lean_Parser_Level_addLit___closed__3;
 lean_object* l_Lean_Parser_Level_imax___closed__2;
-lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__4;
 lean_object* l_Lean_Parser_ParserState_restore(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Level_paren___closed__4;
 lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Level_paren___closed__9;
-lean_object* l_Lean_Parser_categoryParserFn(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__2;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Level_ident___closed__2;
 extern lean_object* l_Lean_Parser_appPrec;
 lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__3;
+lean_object* l_Lean_Parser_ident___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_max___closed__4;
 lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__5;
-lean_object* l_Lean_Parser_numLit(uint8_t);
+extern lean_object* l_Lean_Parser_numLit;
 lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__3;
+lean_object* l_Lean_Parser_numLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_max;
 lean_object* l_Lean_Parser_Level_num;
-lean_object* l_Lean_Parser_categoryParser(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParser(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_max___closed__5;
 lean_object* l_Lean_Parser_Level_num___closed__3;
-lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__10;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
 lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__6;
-extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 extern lean_object* l_Lean_mkHole___closed__1;
+lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_ident___closed__4;
 lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__7;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_addLit(lean_object*);
-lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__9;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_hole(lean_object*);
 lean_object* l_Lean_Parser_Level_hole___closed__1;
 extern lean_object* l_Lean_Level_LevelToFormat_Result_format___main___closed__3;
-extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
 lean_object* l_String_trim(lean_object*);
-lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__8;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Level_hole___closed__2;
 lean_object* l_Lean_Parser_Level_imax___closed__5;
 lean_object* l_Lean_Parser_Level_addLit___closed__6;
 lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Level_max___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Level_max___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Level_ident(lean_object*);
 lean_object* l_Lean_Parser_Level_addLit;
-lean_object* l_Lean_Parser_mkAntiquot(uint8_t, lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_Parser_mkAntiquot(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Parser_Level_max___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Level_max___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__5;
@@ -165,7 +160,6 @@ lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Level_paren___closed__8;
 lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Level_hole___closed__4;
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_Level_addLit___closed__1;
 lean_object* l_Lean_Parser_Level_max___closed__1;
 lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__5;
@@ -173,7 +167,6 @@ lean_object* l_Lean_Parser_Level_paren___closed__1;
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Level_max___closed__2;
 lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__7;
 lean_object* _init_l_Lean_Parser_regBuiltinLevelParserAttr___closed__1() {
 _start:
 {
@@ -221,23 +214,13 @@ x_5 = l_Lean_Parser_registerBuiltinParserAttribute(x_2, x_3, x_4, x_1);
 return x_5;
 }
 }
-lean_object* l_Lean_Parser_levelParser(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_levelParser(lean_object* x_1) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; 
-x_3 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_levelParser___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_levelParser(x_3, x_2);
-return x_4;
+lean_object* x_2; lean_object* x_3; 
+x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_3 = l_Lean_Parser_categoryParser(x_2, x_1);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Level_paren___elambda__1___closed__1() {
@@ -281,295 +264,230 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Level_paren___elambda__1___closed__5() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Level_paren___elambda__1___closed__4;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Level_paren___elambda__1___closed__4;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Level_paren___elambda__1___closed__6() {
+lean_object* l_Lean_Parser_Level_paren___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Char_HasRepr___closed__1;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_3 = lean_string_append(x_1, x_2);
-return x_3;
-}
-}
-lean_object* _init_l_Lean_Parser_Level_paren___elambda__1___closed__7() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Level_paren___elambda__1___closed__6;
-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_Level_paren___elambda__1___closed__8() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Level_paren___elambda__1___closed__7;
-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_Level_paren___elambda__1___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___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_3 = lean_string_append(x_1, x_2);
-return x_3;
-}
-}
-lean_object* _init_l_Lean_Parser_Level_paren___elambda__1___closed__10() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Level_paren___elambda__1___closed__9;
-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_Level_paren___elambda__1___closed__11() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Level_paren___elambda__1___closed__10;
-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* l_Lean_Parser_Level_paren___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_Level_paren___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Level_paren___elambda__1___closed__5;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_56; lean_object* x_57; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_57 = lean_ctor_get(x_56, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_55; lean_object* x_56; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_55 = l_Lean_Parser_tokenFn(x_1, x_13);
+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);
-if (lean_obj_tag(x_57) == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-x_58 = lean_ctor_get(x_56, 0);
-lean_inc(x_58);
-x_59 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_58);
-lean_dec(x_58);
-if (lean_obj_tag(x_59) == 2)
-{
-lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_60 = lean_ctor_get(x_59, 1);
-lean_inc(x_60);
-lean_dec(x_59);
-x_61 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_62 = lean_string_dec_eq(x_60, x_61);
-lean_dec(x_60);
-if (x_62 == 0)
-{
-lean_object* x_63; lean_object* x_64; 
-x_63 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_8);
-x_17 = x_64;
-goto block_55;
-}
-else
-{
-x_17 = x_56;
-goto block_55;
-}
-}
-else
-{
-lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
-x_65 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_8);
-x_17 = x_66;
-goto block_55;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; 
+x_58 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_57);
 lean_dec(x_57);
-x_67 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_8);
-x_17 = x_68;
-goto block_55;
+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);
+lean_inc(x_59);
+lean_dec(x_58);
+x_60 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_61 = lean_string_dec_eq(x_59, x_60);
+lean_dec(x_59);
+if (x_61 == 0)
+{
+lean_object* x_62; lean_object* x_63; 
+x_62 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_7);
+x_16 = x_63;
+goto block_54;
 }
-block_55:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_55;
+goto block_54;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_20 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = lean_ctor_get(x_21, 3);
+lean_object* x_64; lean_object* x_65; 
+lean_dec(x_58);
+x_64 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_7);
+x_16 = x_65;
+goto block_54;
+}
+}
+else
+{
+lean_object* x_66; lean_object* x_67; 
+lean_dec(x_56);
+x_66 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_7);
+x_16 = x_67;
+goto block_54;
+}
+block_54:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_19 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_22 = lean_ctor_get(x_20, 1);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
+x_23 = l_Lean_Parser_tokenFn(x_1, x_20);
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
-lean_inc(x_23);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
+lean_object* x_25; lean_object* x_26; 
+x_25 = lean_ctor_get(x_23, 0);
 lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
-lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
-{
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_31 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
-x_33 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_16);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_8);
-lean_dec(x_8);
-return x_38;
-}
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_39 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
-x_41 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+x_26 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_25);
 lean_dec(x_25);
-x_44 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
-x_46 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
-}
+if (lean_obj_tag(x_26) == 2)
+{
+lean_object* x_27; lean_object* x_28; uint8_t x_29; 
+x_27 = lean_ctor_get(x_26, 1);
+lean_inc(x_27);
+lean_dec(x_26);
+x_28 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_29 = lean_string_dec_eq(x_27, x_28);
+lean_dec(x_27);
+if (x_29 == 0)
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_30 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22);
+x_32 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
 lean_dec(x_22);
-lean_dec(x_2);
-x_49 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_16);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_11, x_8);
-lean_dec(x_8);
-return x_51;
+x_35 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_23, x_35, x_15);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_10, x_7);
+lean_dec(x_7);
+return x_37;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_52 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_17, x_52, x_16);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_8);
-lean_dec(x_8);
-return x_54;
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+lean_dec(x_26);
+x_38 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_38, x_22);
+x_40 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_15);
+x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_10, x_7);
+lean_dec(x_7);
+return x_42;
+}
+}
+else
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_24);
+x_43 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_43, x_22);
+x_45 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
+x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_10, x_7);
+lean_dec(x_7);
+return x_47;
+}
+}
+else
+{
+lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_dec(x_21);
+lean_dec(x_1);
+x_48 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
+x_49 = l_Lean_Parser_ParserState_mkNode(x_20, x_48, x_15);
+x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_10, x_7);
+lean_dec(x_7);
+return x_50;
+}
+}
+else
+{
+lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_51 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
+x_52 = l_Lean_Parser_ParserState_mkNode(x_16, x_51, x_15);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_10, x_7);
+lean_dec(x_7);
+return x_53;
 }
 }
 }
@@ -590,7 +508,7 @@ lean_object* _init_l_Lean_Parser_Level_paren___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
 x_2 = l_Lean_Parser_Level_paren___closed__1;
 x_3 = l_Lean_Parser_symbolInfo(x_1, x_2);
 return x_3;
@@ -599,12 +517,11 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Level_paren___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_2 = lean_unsigned_to_nat(0u);
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Level_paren___closed__4() {
@@ -614,7 +531,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4;
 x_1 = l_Lean_Parser_Level_paren___closed__3;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
@@ -655,7 +572,7 @@ lean_object* _init_l_Lean_Parser_Level_paren___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_paren___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_paren___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -682,75 +599,75 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_paren(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_4 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_3 = l_Lean_Parser_Level_paren___elambda__1___closed__3;
+x_4 = 1;
 x_5 = l_Lean_Parser_Level_paren;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-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; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-x_8 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_9 = l_Lean_Parser_appPrec;
+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; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-x_10 = l_Lean_Parser_categoryParserFn(x_8, x_9, x_3, x_4);
-x_11 = lean_ctor_get(x_10, 3);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+x_6 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_7 = l_Lean_Parser_appPrec;
+lean_inc(x_1);
+x_8 = l_Lean_Parser_categoryParser___elambda__1(x_6, x_7, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_object* x_12; uint8_t x_13; 
-lean_dec(x_6);
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_7, x_12);
-lean_dec(x_12);
-lean_dec(x_7);
-if (x_13 == 0)
+lean_object* x_10; uint8_t x_11; 
+lean_dec(x_4);
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+x_11 = lean_nat_dec_eq(x_5, x_10);
+lean_dec(x_10);
+lean_dec(x_5);
+if (x_11 == 0)
 {
-x_4 = x_10;
+x_2 = x_8;
 goto _start;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; 
-lean_dec(x_3);
-x_15 = l_Lean_Parser_manyAux___main___closed__1;
-x_16 = l_Lean_Parser_ParserState_mkUnexpectedError(x_10, x_15);
-return x_16;
+lean_object* x_13; lean_object* x_14; 
+lean_dec(x_1);
+x_13 = l_Lean_Parser_manyAux___main___closed__1;
+x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
+return x_14;
 }
 }
 else
 {
-lean_object* x_17; uint8_t x_18; 
-lean_dec(x_11);
-lean_dec(x_3);
-x_17 = lean_ctor_get(x_10, 1);
-lean_inc(x_17);
-x_18 = lean_nat_dec_eq(x_7, x_17);
-lean_dec(x_17);
-if (x_18 == 0)
+lean_object* x_15; uint8_t x_16; 
+lean_dec(x_9);
+lean_dec(x_1);
+x_15 = lean_ctor_get(x_8, 1);
+lean_inc(x_15);
+x_16 = lean_nat_dec_eq(x_5, x_15);
+lean_dec(x_15);
+if (x_16 == 0)
 {
-lean_dec(x_7);
-lean_dec(x_6);
-return x_10;
+lean_dec(x_5);
+lean_dec(x_4);
+return x_8;
 }
 else
 {
-lean_object* x_19; 
-x_19 = l_Lean_Parser_ParserState_restore(x_10, x_6, x_7);
-lean_dec(x_6);
-return x_19;
+lean_object* x_17; 
+x_17 = l_Lean_Parser_ParserState_restore(x_8, x_4, x_5);
+lean_dec(x_4);
+return x_17;
 }
 }
 }
@@ -778,13 +695,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Level_max___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Level_LevelToFormat_Result_format___main___closed__3;
-x_3 = l_Lean_Parser_Level_max___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Level_LevelToFormat_Result_format___main___closed__3;
+x_2 = l_Lean_Parser_Level_max___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Level_max___elambda__1___closed__4() {
@@ -824,120 +740,113 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Level_max___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Level_max___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Level_max___elambda__1___closed__3;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Level_max___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Level_max___elambda__1___closed__5;
-x_18 = l_Lean_Parser_Level_max___elambda__1___closed__7;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = lean_ctor_get(x_19, 3);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Level_max___elambda__1___closed__5;
+x_17 = l_Lean_Parser_Level_max___elambda__1___closed__7;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_20 = lean_ctor_get(x_18, 0);
 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_24; lean_object* x_25; lean_object* x_26; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_24 = l_Lean_Parser_appPrec;
-lean_inc(x_2);
-x_25 = l_Lean_Parser_categoryParserFn(x_23, x_24, x_2, x_19);
-x_26 = lean_ctor_get(x_25, 3);
-lean_inc(x_26);
-if (lean_obj_tag(x_26) == 0)
-{
-uint8_t 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; 
-x_27 = 0;
-x_28 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_27, x_1, x_2, x_25);
-lean_dec(x_1);
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_22);
-x_31 = l_Lean_Parser_Level_max___elambda__1___closed__1;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_16);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_11, x_8);
-lean_dec(x_8);
-return x_33;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_26);
-lean_dec(x_2);
-lean_dec(x_1);
-x_34 = l_Lean_nullKind;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_25, x_34, x_22);
-x_36 = l_Lean_Parser_Level_max___elambda__1___closed__1;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_16);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_8);
-lean_dec(x_8);
-return x_38;
-}
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_21 = lean_array_get_size(x_20);
 lean_dec(x_20);
-lean_dec(x_2);
+x_22 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_23 = l_Lean_Parser_appPrec;
+lean_inc(x_1);
+x_24 = l_Lean_Parser_categoryParser___elambda__1(x_22, x_23, x_1, x_18);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+x_26 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_1, x_24);
+x_27 = l_Lean_nullKind;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_21);
+x_29 = l_Lean_Parser_Level_max___elambda__1___closed__1;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
+}
+else
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_25);
 lean_dec(x_1);
-x_39 = l_Lean_Parser_Level_max___elambda__1___closed__1;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_19, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+x_32 = l_Lean_nullKind;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_24, x_32, x_21);
+x_34 = l_Lean_Parser_Level_max___elambda__1___closed__1;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_37 = l_Lean_Parser_Level_max___elambda__1___closed__1;
+x_38 = l_Lean_Parser_ParserState_mkNode(x_18, x_37, x_15);
+x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_10, x_7);
+lean_dec(x_7);
+return x_39;
 }
 }
 }
@@ -956,12 +865,11 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Level_max___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_3 = l_Lean_Parser_appPrec;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_2 = l_Lean_Parser_appPrec;
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Level_max___closed__3() {
@@ -1002,7 +910,7 @@ lean_object* _init_l_Lean_Parser_Level_max___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_max___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_max___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1026,24 +934,13 @@ x_1 = l_Lean_Parser_Level_max___closed__7;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_6;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Level_max(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_4 = l_Lean_Parser_Level_max___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_3 = l_Lean_Parser_Level_max___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Level_max;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -1072,13 +969,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Level_imax___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Level_LevelToFormat_Result_format___main___closed__5;
-x_3 = l_Lean_Parser_Level_imax___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Level_LevelToFormat_Result_format___main___closed__5;
+x_2 = l_Lean_Parser_Level_imax___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Level_imax___elambda__1___closed__4() {
@@ -1122,175 +1018,168 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Level_imax___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Level_imax___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Level_imax___elambda__1___closed__3;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Level_imax___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_41; lean_object* x_42; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_41 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_42 = lean_ctor_get(x_41, 3);
-lean_inc(x_42);
-if (lean_obj_tag(x_42) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_39; lean_object* x_40; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_39 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_40 = lean_ctor_get(x_39, 3);
+lean_inc(x_40);
+if (lean_obj_tag(x_40) == 0)
 {
-lean_object* x_43; lean_object* x_44; 
-x_43 = lean_ctor_get(x_41, 0);
+lean_object* x_41; lean_object* x_42; 
+x_41 = lean_ctor_get(x_39, 0);
+lean_inc(x_41);
+x_42 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_41);
+lean_dec(x_41);
+if (lean_obj_tag(x_42) == 2)
+{
+lean_object* x_43; lean_object* x_44; uint8_t x_45; 
+x_43 = lean_ctor_get(x_42, 1);
 lean_inc(x_43);
-x_44 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_43);
+lean_dec(x_42);
+x_44 = l_Lean_Parser_Level_imax___elambda__1___closed__4;
+x_45 = lean_string_dec_eq(x_43, x_44);
 lean_dec(x_43);
-if (lean_obj_tag(x_44) == 2)
+if (x_45 == 0)
 {
-lean_object* x_45; lean_object* x_46; uint8_t x_47; 
-x_45 = lean_ctor_get(x_44, 1);
-lean_inc(x_45);
-lean_dec(x_44);
-x_46 = l_Lean_Parser_Level_imax___elambda__1___closed__4;
-x_47 = lean_string_dec_eq(x_45, x_46);
-lean_dec(x_45);
-if (x_47 == 0)
+lean_object* x_46; lean_object* x_47; 
+x_46 = l_Lean_Parser_Level_imax___elambda__1___closed__7;
+lean_inc(x_7);
+x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_46, x_7);
+x_16 = x_47;
+goto block_38;
+}
+else
+{
+x_16 = x_39;
+goto block_38;
+}
+}
+else
 {
 lean_object* x_48; lean_object* x_49; 
+lean_dec(x_42);
 x_48 = l_Lean_Parser_Level_imax___elambda__1___closed__7;
-lean_inc(x_8);
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_8);
-x_17 = x_49;
-goto block_40;
-}
-else
-{
-x_17 = x_41;
-goto block_40;
+lean_inc(x_7);
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_48, x_7);
+x_16 = x_49;
+goto block_38;
 }
 }
 else
 {
 lean_object* x_50; lean_object* x_51; 
-lean_dec(x_44);
+lean_dec(x_40);
 x_50 = l_Lean_Parser_Level_imax___elambda__1___closed__7;
-lean_inc(x_8);
-x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_8);
-x_17 = x_51;
-goto block_40;
+lean_inc(x_7);
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_50, x_7);
+x_16 = x_51;
+goto block_38;
 }
-}
-else
+block_38:
 {
-lean_object* x_52; lean_object* x_53; 
-lean_dec(x_42);
-x_52 = l_Lean_Parser_Level_imax___elambda__1___closed__7;
-lean_inc(x_8);
-x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_8);
-x_17 = x_53;
-goto block_40;
-}
-block_40:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-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 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_22 = l_Lean_Parser_appPrec;
-lean_inc(x_2);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_17);
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-uint8_t 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; 
-x_25 = 0;
-x_26 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_25, x_1, x_2, x_23);
-lean_dec(x_1);
-x_27 = l_Lean_nullKind;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_20);
-x_29 = l_Lean_Parser_Level_imax___elambda__1___closed__1;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_24);
-lean_dec(x_2);
-lean_dec(x_1);
-x_32 = l_Lean_nullKind;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_23, x_32, x_20);
-x_34 = l_Lean_Parser_Level_imax___elambda__1___closed__1;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_19 = lean_array_get_size(x_18);
 lean_dec(x_18);
-lean_dec(x_2);
+x_20 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_21 = l_Lean_Parser_appPrec;
+lean_inc(x_1);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_16);
+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_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_24 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_1, x_22);
+x_25 = l_Lean_nullKind;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_19);
+x_27 = l_Lean_Parser_Level_imax___elambda__1___closed__1;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
+}
+else
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_23);
 lean_dec(x_1);
-x_37 = l_Lean_Parser_Level_imax___elambda__1___closed__1;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_17, x_37, x_16);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_8);
-lean_dec(x_8);
-return x_39;
+x_30 = l_Lean_nullKind;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_19);
+x_32 = l_Lean_Parser_Level_imax___elambda__1___closed__1;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_35 = l_Lean_Parser_Level_imax___elambda__1___closed__1;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_16, x_35, x_15);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_10, x_7);
+lean_dec(x_7);
+return x_37;
 }
 }
 }
@@ -1345,7 +1234,7 @@ lean_object* _init_l_Lean_Parser_Level_imax___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_imax___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_imax___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1372,10 +1261,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_imax(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_4 = l_Lean_Parser_Level_imax___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_3 = l_Lean_Parser_Level_imax___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Level_imax;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -1404,13 +1293,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Level_hole___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_mkHole___closed__1;
-x_3 = l_Lean_Parser_Level_hole___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_mkHole___closed__1;
+x_2 = l_Lean_Parser_Level_hole___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Level_hole___elambda__1___closed__4() {
@@ -1454,125 +1342,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Level_hole___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Level_hole___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Level_hole___elambda__1___closed__3;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Level_hole___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Level_hole___elambda__1___closed__4;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Level_hole___elambda__1___closed__4;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -1614,7 +1502,7 @@ lean_object* _init_l_Lean_Parser_Level_hole___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_hole___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_hole___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1641,10 +1529,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_hole(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_4 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_3 = l_Lean_Parser_Level_hole___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Level_hole;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -1681,90 +1569,72 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Level_num___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Level_num___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Level_num___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Level_num___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Level_num___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Level_num___elambda__1___closed__5() {
+lean_object* l_Lean_Parser_Level_num___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_numLit(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Level_num___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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_num___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Level_num___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Level_num___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-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_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = l_Lean_Parser_Level_num___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_18);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_13, x_10);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
 lean_dec(x_10);
-return x_22;
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_numLit___elambda__1(x_1, x_13);
+x_17 = l_Lean_Parser_Level_num___elambda__1___closed__2;
+x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_15);
+x_19 = l_Lean_Parser_mergeOrElseErrors(x_18, x_10, x_7);
+lean_dec(x_7);
+return x_19;
 }
 }
 }
@@ -1773,7 +1643,7 @@ lean_object* _init_l_Lean_Parser_Level_num___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_num___elambda__1___closed__5;
+x_1 = l_Lean_Parser_numLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Level_num___elambda__1___closed__2;
@@ -1797,7 +1667,7 @@ lean_object* _init_l_Lean_Parser_Level_num___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_num___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_num___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1824,10 +1694,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_num(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_4 = l_Lean_Parser_Level_num___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_3 = l_Lean_Parser_Level_num___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Level_num;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -1856,90 +1726,72 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Level_ident___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_identKind___closed__1;
-x_3 = l_Lean_Parser_Level_ident___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_identKind___closed__1;
+x_2 = l_Lean_Parser_Level_ident___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Level_ident___elambda__1___closed__4() {
+lean_object* l_Lean_Parser_Level_ident___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_ident(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Level_ident___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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Level_ident___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Level_ident___elambda__1___closed__3;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-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_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = l_Lean_Parser_Level_ident___elambda__1___closed__1;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_18);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_13, x_10);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
 lean_dec(x_10);
-return x_22;
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_17 = l_Lean_Parser_Level_ident___elambda__1___closed__1;
+x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_15);
+x_19 = l_Lean_Parser_mergeOrElseErrors(x_18, x_10, x_7);
+lean_dec(x_7);
+return x_19;
 }
 }
 }
@@ -1948,7 +1800,7 @@ lean_object* _init_l_Lean_Parser_Level_ident___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Level_ident___elambda__1___closed__1;
@@ -1972,7 +1824,7 @@ lean_object* _init_l_Lean_Parser_Level_ident___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_ident___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_ident___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1999,10 +1851,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_ident(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_3 = l_Lean_Parser_Level_ident___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Level_ident;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2038,18 +1890,19 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Level_addLit___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 1;
-x_2 = l_Lean_Parser_numLit(x_1);
-return x_2;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Char_HasRepr___closed__1;
+x_2 = l_Lean_Parser_Level_addLit___elambda__1___closed__3;
+x_3 = lean_string_append(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Level_addLit___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_Level_addLit___elambda__1___closed__3;
+x_1 = l_Lean_Parser_Level_addLit___elambda__1___closed__4;
+x_2 = l_Char_HasRepr___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
@@ -2058,116 +1911,101 @@ lean_object* _init_l_Lean_Parser_Level_addLit___elambda__1___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Level_addLit___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_Level_addLit___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_Level_addLit___elambda__1___closed__6;
+x_2 = l_Lean_Parser_Level_addLit___elambda__1___closed__5;
 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* l_Lean_Parser_Level_addLit___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Level_addLit___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_4 = l_Lean_Parser_Level_addLit___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_16 = lean_ctor_get(x_3, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+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_13 = lean_ctor_get(x_2, 1);
+lean_inc(x_13);
+lean_inc(x_1);
+x_14 = l_Lean_Parser_tokenFn(x_1, x_2);
+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; 
+x_16 = lean_ctor_get(x_14, 0);
 lean_inc(x_16);
-lean_inc(x_2);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_3);
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Level_addLit___elambda__1___closed__3;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = l_Lean_Parser_Level_addLit___elambda__1___closed__7;
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16);
-x_8 = x_25;
-goto block_15;
-}
-else
-{
+x_17 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_16);
 lean_dec(x_16);
-x_8 = x_17;
-goto block_15;
-}
-}
-else
+if (lean_obj_tag(x_17) == 2)
 {
-lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-x_26 = l_Lean_Parser_Level_addLit___elambda__1___closed__7;
-x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_26, x_16);
-x_8 = x_27;
-goto block_15;
-}
-}
-else
-{
-lean_object* x_28; lean_object* x_29; 
+lean_object* x_18; lean_object* x_19; uint8_t x_20; 
+x_18 = lean_ctor_get(x_17, 1);
+lean_inc(x_18);
+lean_dec(x_17);
+x_19 = l_Lean_Parser_Level_addLit___elambda__1___closed__3;
+x_20 = lean_string_dec_eq(x_18, x_19);
 lean_dec(x_18);
-x_28 = l_Lean_Parser_Level_addLit___elambda__1___closed__7;
-x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_28, x_16);
-x_8 = x_29;
-goto block_15;
-}
-block_15:
+if (x_20 == 0)
 {
-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; 
-x_10 = lean_apply_3(x_5, x_1, x_2, x_8);
-x_11 = l_Lean_Parser_Level_addLit___elambda__1___closed__2;
-x_12 = l_Lean_Parser_ParserState_mkTrailingNode(x_10, x_11, x_7);
-lean_dec(x_7);
-return x_12;
+lean_object* x_21; lean_object* x_22; 
+x_21 = l_Lean_Parser_Level_addLit___elambda__1___closed__6;
+x_22 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_21, x_13);
+x_5 = x_22;
+goto block_12;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_13);
+x_5 = x_14;
+goto block_12;
+}
+}
+else
+{
+lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
+x_23 = l_Lean_Parser_Level_addLit___elambda__1___closed__6;
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_23, x_13);
+x_5 = x_24;
+goto block_12;
+}
+}
+else
+{
+lean_object* x_25; lean_object* x_26; 
+lean_dec(x_15);
+x_25 = l_Lean_Parser_Level_addLit___elambda__1___closed__6;
+x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_25, x_13);
+x_5 = x_26;
+goto block_12;
+}
+block_12:
+{
+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; 
+x_7 = l_Lean_Parser_numLit___elambda__1(x_1, x_5);
+x_8 = l_Lean_Parser_Level_addLit___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_4);
+lean_dec(x_4);
+return x_9;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; 
+lean_dec(x_6);
 lean_dec(x_1);
-x_13 = l_Lean_Parser_Level_addLit___elambda__1___closed__2;
-x_14 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_13, x_7);
-lean_dec(x_7);
-return x_14;
+x_10 = l_Lean_Parser_Level_addLit___elambda__1___closed__2;
+x_11 = l_Lean_Parser_ParserState_mkTrailingNode(x_5, x_10, x_4);
+lean_dec(x_4);
+return x_11;
 }
 }
 }
@@ -2196,7 +2034,7 @@ lean_object* _init_l_Lean_Parser_Level_addLit___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_addLit___elambda__1___closed__4;
+x_1 = l_Lean_Parser_numLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Level_addLit___closed__2;
@@ -2218,7 +2056,7 @@ lean_object* _init_l_Lean_Parser_Level_addLit___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_addLit___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_addLit___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2245,10 +2083,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Level_addLit(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_4 = l_Lean_Parser_Level_addLit___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_3 = l_Lean_Parser_Level_addLit___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Level_addLit;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2284,18 +2122,6 @@ l_Lean_Parser_Level_paren___elambda__1___closed__4 = _init_l_Lean_Parser_Level_p
 lean_mark_persistent(l_Lean_Parser_Level_paren___elambda__1___closed__4);
 l_Lean_Parser_Level_paren___elambda__1___closed__5 = _init_l_Lean_Parser_Level_paren___elambda__1___closed__5();
 lean_mark_persistent(l_Lean_Parser_Level_paren___elambda__1___closed__5);
-l_Lean_Parser_Level_paren___elambda__1___closed__6 = _init_l_Lean_Parser_Level_paren___elambda__1___closed__6();
-lean_mark_persistent(l_Lean_Parser_Level_paren___elambda__1___closed__6);
-l_Lean_Parser_Level_paren___elambda__1___closed__7 = _init_l_Lean_Parser_Level_paren___elambda__1___closed__7();
-lean_mark_persistent(l_Lean_Parser_Level_paren___elambda__1___closed__7);
-l_Lean_Parser_Level_paren___elambda__1___closed__8 = _init_l_Lean_Parser_Level_paren___elambda__1___closed__8();
-lean_mark_persistent(l_Lean_Parser_Level_paren___elambda__1___closed__8);
-l_Lean_Parser_Level_paren___elambda__1___closed__9 = _init_l_Lean_Parser_Level_paren___elambda__1___closed__9();
-lean_mark_persistent(l_Lean_Parser_Level_paren___elambda__1___closed__9);
-l_Lean_Parser_Level_paren___elambda__1___closed__10 = _init_l_Lean_Parser_Level_paren___elambda__1___closed__10();
-lean_mark_persistent(l_Lean_Parser_Level_paren___elambda__1___closed__10);
-l_Lean_Parser_Level_paren___elambda__1___closed__11 = _init_l_Lean_Parser_Level_paren___elambda__1___closed__11();
-lean_mark_persistent(l_Lean_Parser_Level_paren___elambda__1___closed__11);
 l_Lean_Parser_Level_paren___closed__1 = _init_l_Lean_Parser_Level_paren___closed__1();
 lean_mark_persistent(l_Lean_Parser_Level_paren___closed__1);
 l_Lean_Parser_Level_paren___closed__2 = _init_l_Lean_Parser_Level_paren___closed__2();
@@ -2420,8 +2246,6 @@ l_Lean_Parser_Level_num___elambda__1___closed__3 = _init_l_Lean_Parser_Level_num
 lean_mark_persistent(l_Lean_Parser_Level_num___elambda__1___closed__3);
 l_Lean_Parser_Level_num___elambda__1___closed__4 = _init_l_Lean_Parser_Level_num___elambda__1___closed__4();
 lean_mark_persistent(l_Lean_Parser_Level_num___elambda__1___closed__4);
-l_Lean_Parser_Level_num___elambda__1___closed__5 = _init_l_Lean_Parser_Level_num___elambda__1___closed__5();
-lean_mark_persistent(l_Lean_Parser_Level_num___elambda__1___closed__5);
 l_Lean_Parser_Level_num___closed__1 = _init_l_Lean_Parser_Level_num___closed__1();
 lean_mark_persistent(l_Lean_Parser_Level_num___closed__1);
 l_Lean_Parser_Level_num___closed__2 = _init_l_Lean_Parser_Level_num___closed__2();
@@ -2441,8 +2265,6 @@ l_Lean_Parser_Level_ident___elambda__1___closed__2 = _init_l_Lean_Parser_Level_i
 lean_mark_persistent(l_Lean_Parser_Level_ident___elambda__1___closed__2);
 l_Lean_Parser_Level_ident___elambda__1___closed__3 = _init_l_Lean_Parser_Level_ident___elambda__1___closed__3();
 lean_mark_persistent(l_Lean_Parser_Level_ident___elambda__1___closed__3);
-l_Lean_Parser_Level_ident___elambda__1___closed__4 = _init_l_Lean_Parser_Level_ident___elambda__1___closed__4();
-lean_mark_persistent(l_Lean_Parser_Level_ident___elambda__1___closed__4);
 l_Lean_Parser_Level_ident___closed__1 = _init_l_Lean_Parser_Level_ident___closed__1();
 lean_mark_persistent(l_Lean_Parser_Level_ident___closed__1);
 l_Lean_Parser_Level_ident___closed__2 = _init_l_Lean_Parser_Level_ident___closed__2();
@@ -2468,8 +2290,6 @@ l_Lean_Parser_Level_addLit___elambda__1___closed__5 = _init_l_Lean_Parser_Level_
 lean_mark_persistent(l_Lean_Parser_Level_addLit___elambda__1___closed__5);
 l_Lean_Parser_Level_addLit___elambda__1___closed__6 = _init_l_Lean_Parser_Level_addLit___elambda__1___closed__6();
 lean_mark_persistent(l_Lean_Parser_Level_addLit___elambda__1___closed__6);
-l_Lean_Parser_Level_addLit___elambda__1___closed__7 = _init_l_Lean_Parser_Level_addLit___elambda__1___closed__7();
-lean_mark_persistent(l_Lean_Parser_Level_addLit___elambda__1___closed__7);
 l_Lean_Parser_Level_addLit___closed__1 = _init_l_Lean_Parser_Level_addLit___closed__1();
 lean_mark_persistent(l_Lean_Parser_Level_addLit___closed__1);
 l_Lean_Parser_Level_addLit___closed__2 = _init_l_Lean_Parser_Level_addLit___closed__2();
diff --git a/stage0/stdlib/Init/Lean/Parser/Module.c b/stage0/stdlib/Init/Lean/Parser/Module.c
index 353a22f03c..27d14fd8f0 100644
--- a/stage0/stdlib/Init/Lean/Parser/Module.c
+++ b/stage0/stdlib/Init/Lean/Parser/Module.c
@@ -36,6 +36,7 @@ lean_object* l___private_Init_Lean_Parser_Module_2__mkEOI___closed__1;
 lean_object* l_Lean_Parser_Module_prelude;
 lean_object* l_Lean_Parser_Module_import___elambda__1___closed__12;
 extern lean_object* l_Array_empty___closed__1;
+extern lean_object* l_Lean_Parser_ident;
 lean_object* l_Lean_Parser_ParserState_mkNode(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserState(lean_object*);
 lean_object* l_Lean_Parser_Module_prelude___elambda__1___closed__2;
@@ -54,6 +55,7 @@ lean_object* l_Lean_Parser_Module_updateTokens___closed__1;
 lean_object* l_Lean_Parser_Module_import___closed__9;
 lean_object* l_Lean_Parser_isExitCommand___boxed(lean_object*);
 lean_object* l_PersistentArray_push___rarg(lean_object*, lean_object*);
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_Module_import___elambda__1___closed__1;
 extern lean_object* l_String_splitAux___main___closed__1;
 lean_object* l___private_Init_Lean_Parser_Module_4__testModuleParserAux___main(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
@@ -62,7 +64,6 @@ lean_object* l_Lean_Parser_parseFile(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkAppStx___closed__4;
 lean_object* l_Lean_Parser_ParserState_mkErrorsAt(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_testModuleParser___lambda__1(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_header___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Module_import___elambda__1___closed__13;
 lean_object* lean_nat_add(lean_object*, lean_object*);
@@ -115,7 +116,6 @@ uint8_t l_PersistentArray_isEmpty___rarg(lean_object*);
 lean_object* l_Lean_FileMap_toPosition(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_parseFileAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Trie_Inhabited(lean_object*);
-extern lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__4;
 lean_object* l_PersistentArray_forMAux___main___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__7(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_restore(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__9(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -123,12 +123,12 @@ lean_object* l_Lean_MessageLog_forM___at___private_Init_Lean_Parser_Module_4__te
 lean_object* l_Lean_Parser_Module_header;
 lean_object* l_Lean_Parser_Module_import___closed__6;
 lean_object* l_Lean_Parser_Module_header___closed__5;
-lean_object* l_Lean_Parser_categoryParserFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_prelude___closed__5;
 lean_object* l_Lean_Parser_Module_import___closed__2;
 lean_object* l_Lean_Parser_ModuleParserState_inhabited;
 lean_object* l_Lean_Parser_Module_prelude___elambda__1___closed__5;
 lean_object* l_IO_println___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_ident___elambda__1(lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Substring_drop___closed__2;
 lean_object* l_Lean_Parser_Error_toString(lean_object*);
@@ -145,8 +145,9 @@ lean_object* l___private_Init_Lean_Parser_Module_4__testModuleParserAux(lean_obj
 lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_prelude___elambda__1___closed__6;
+lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_prelude___closed__2;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_import___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Module_header___closed__3;
 lean_object* l_String_trim(lean_object*);
@@ -154,9 +155,9 @@ lean_object* l___private_Init_Lean_Parser_Module_3__consumeInput(lean_object*, l
 lean_object* lean_io_prim_read_text_file(lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_import___closed__5;
-lean_object* l_Lean_Parser_Module_prelude___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Module_prelude___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_import___elambda__1___closed__14;
-lean_object* l_Lean_Parser_mkAntiquot(uint8_t, lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_Parser_mkAntiquot(lean_object*, lean_object*, uint8_t);
 lean_object* l_IO_println___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__3(lean_object*, lean_object*);
 uint8_t l_Lean_Parser_isEOI(lean_object*);
 extern lean_object* l_Lean_mkOptionalNode___closed__2;
@@ -177,11 +178,10 @@ uint8_t lean_string_utf8_at_end(lean_object*, lean_object*);
 lean_object* lean_test_module_parser(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Parser_Module_prelude___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Module_import___elambda__1___closed__6;
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_parseCommand(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Module_import___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Module_import___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_isEOI___boxed(lean_object*);
-lean_object* l_Lean_Parser_Module_header___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Module_header___elambda__1(lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_prelude___elambda__1___closed__9;
@@ -234,13 +234,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Module_prelude___elambda__1___closed__6() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Module_prelude___elambda__1___closed__3;
-x_3 = l_Lean_Parser_Module_prelude___elambda__1___closed__5;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Module_prelude___elambda__1___closed__3;
+x_2 = l_Lean_Parser_Module_prelude___elambda__1___closed__5;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Module_prelude___elambda__1___closed__7() {
@@ -284,125 +283,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Module_prelude___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Module_prelude___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Module_prelude___elambda__1___closed__6;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Module_prelude___elambda__1___closed__6;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Module_prelude___elambda__1___closed__7;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Module_prelude___elambda__1___closed__10;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Module_prelude___elambda__1___closed__4;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Module_prelude___elambda__1___closed__4;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Module_prelude___elambda__1___closed__10;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Module_prelude___elambda__1___closed__4;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Module_prelude___elambda__1___closed__10;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Module_prelude___elambda__1___closed__4;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Module_prelude___elambda__1___closed__7;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Module_prelude___elambda__1___closed__10;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Module_prelude___elambda__1___closed__4;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Module_prelude___elambda__1___closed__4;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Module_prelude___elambda__1___closed__10;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Module_prelude___elambda__1___closed__4;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Module_prelude___elambda__1___closed__10;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Module_prelude___elambda__1___closed__4;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -444,7 +443,7 @@ lean_object* _init_l_Lean_Parser_Module_prelude___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Module_prelude___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Module_prelude___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -499,13 +498,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Module_import___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Module_import___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Module_import___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Module_import___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Module_import___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Module_import___elambda__1___closed__5() {
@@ -606,316 +604,300 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Module_import___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Module_import___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Module_import___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Module_import___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_74; lean_object* x_75; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_74 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_75 = lean_ctor_get(x_74, 3);
+lean_inc(x_75);
+if (lean_obj_tag(x_75) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_76; lean_object* x_77; 
+x_76 = lean_ctor_get(x_74, 0);
+lean_inc(x_76);
+x_77 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_76);
+lean_dec(x_76);
+if (lean_obj_tag(x_77) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_77; lean_object* x_78; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_77 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_78 = lean_ctor_get(x_77, 3);
+lean_object* x_78; lean_object* x_79; uint8_t x_80; 
+x_78 = lean_ctor_get(x_77, 1);
 lean_inc(x_78);
-if (lean_obj_tag(x_78) == 0)
-{
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_ctor_get(x_77, 0);
-lean_inc(x_79);
-x_80 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_79);
-lean_dec(x_79);
-if (lean_obj_tag(x_80) == 2)
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; 
-x_81 = lean_ctor_get(x_80, 1);
-lean_inc(x_81);
-lean_dec(x_80);
-x_82 = l_Lean_Parser_Module_import___elambda__1___closed__6;
-x_83 = lean_string_dec_eq(x_81, x_82);
-lean_dec(x_81);
-if (x_83 == 0)
-{
-lean_object* x_84; lean_object* x_85; 
-x_84 = l_Lean_Parser_Module_import___elambda__1___closed__14;
-lean_inc(x_10);
-x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_84, x_10);
-x_19 = x_85;
-goto block_76;
-}
-else
-{
-x_19 = x_77;
-goto block_76;
-}
-}
-else
-{
-lean_object* x_86; lean_object* x_87; 
-lean_dec(x_80);
-x_86 = l_Lean_Parser_Module_import___elambda__1___closed__14;
-lean_inc(x_10);
-x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_86, x_10);
-x_19 = x_87;
-goto block_76;
-}
-}
-else
-{
-lean_object* x_88; lean_object* x_89; 
+lean_dec(x_77);
+x_79 = l_Lean_Parser_Module_import___elambda__1___closed__6;
+x_80 = lean_string_dec_eq(x_78, x_79);
 lean_dec(x_78);
-x_88 = l_Lean_Parser_Module_import___elambda__1___closed__14;
-lean_inc(x_10);
-x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_88, x_10);
-x_19 = x_89;
-goto block_76;
-}
-block_76:
+if (x_80 == 0)
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_81; lean_object* x_82; 
+x_81 = l_Lean_Parser_Module_import___elambda__1___closed__14;
+lean_inc(x_7);
+x_82 = l_Lean_Parser_ParserState_mkErrorsAt(x_74, x_81, x_7);
+x_16 = x_82;
+goto block_73;
+}
+else
+{
+x_16 = x_74;
+goto block_73;
+}
+}
+else
+{
+lean_object* x_83; lean_object* x_84; 
+lean_dec(x_77);
+x_83 = l_Lean_Parser_Module_import___elambda__1___closed__14;
+lean_inc(x_7);
+x_84 = l_Lean_Parser_ParserState_mkErrorsAt(x_74, x_83, x_7);
+x_16 = x_84;
+goto block_73;
+}
+}
+else
+{
+lean_object* x_85; lean_object* x_86; 
+lean_dec(x_75);
+x_85 = l_Lean_Parser_Module_import___elambda__1___closed__14;
+lean_inc(x_7);
+x_86 = l_Lean_Parser_ParserState_mkErrorsAt(x_74, x_85, x_7);
+x_16 = x_86;
+goto block_73;
+}
+block_73:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_57; lean_object* x_58; 
+x_18 = lean_ctor_get(x_16, 0);
+lean_inc(x_18);
+x_19 = lean_array_get_size(x_18);
+lean_dec(x_18);
+x_20 = lean_ctor_get(x_16, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+lean_inc(x_1);
+x_57 = l_Lean_Parser_tokenFn(x_1, x_16);
+x_58 = lean_ctor_get(x_57, 3);
+lean_inc(x_58);
+if (lean_obj_tag(x_58) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_60; lean_object* x_61; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = lean_ctor_get(x_19, 1);
-lean_inc(x_23);
-lean_inc(x_2);
-x_60 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_61 = lean_ctor_get(x_60, 3);
+lean_object* x_59; lean_object* x_60; 
+x_59 = lean_ctor_get(x_57, 0);
+lean_inc(x_59);
+x_60 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_59);
+lean_dec(x_59);
+if (lean_obj_tag(x_60) == 2)
+{
+lean_object* x_61; lean_object* x_62; uint8_t x_63; 
+x_61 = lean_ctor_get(x_60, 1);
 lean_inc(x_61);
-if (lean_obj_tag(x_61) == 0)
-{
-lean_object* x_62; lean_object* x_63; 
-x_62 = lean_ctor_get(x_60, 0);
-lean_inc(x_62);
-x_63 = l_Array_back___at_Lean_Parser_checkLeadingFn___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_Module_import___elambda__1___closed__8;
-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_Module_import___elambda__1___closed__11;
-lean_inc(x_23);
-x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_67, x_23);
-x_24 = x_68;
-goto block_59;
-}
-else
-{
-x_24 = x_60;
-goto block_59;
-}
-}
-else
-{
-lean_object* x_69; lean_object* x_70; 
-lean_dec(x_63);
-x_69 = l_Lean_Parser_Module_import___elambda__1___closed__11;
-lean_inc(x_23);
-x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_69, x_23);
-x_24 = x_70;
-goto block_59;
-}
-}
-else
-{
-lean_object* x_71; lean_object* x_72; 
+lean_dec(x_60);
+x_62 = l_Lean_Parser_Module_import___elambda__1___closed__8;
+x_63 = lean_string_dec_eq(x_61, x_62);
 lean_dec(x_61);
-x_71 = l_Lean_Parser_Module_import___elambda__1___closed__11;
-lean_inc(x_23);
-x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_71, x_23);
-x_24 = x_72;
-goto block_59;
-}
-block_59:
+if (x_63 == 0)
 {
-lean_object* x_25; 
+lean_object* x_64; lean_object* x_65; 
+x_64 = l_Lean_Parser_Module_import___elambda__1___closed__11;
+lean_inc(x_20);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_64, x_20);
+x_21 = x_65;
+goto block_56;
+}
+else
+{
+x_21 = x_57;
+goto block_56;
+}
+}
+else
+{
+lean_object* x_66; lean_object* x_67; 
+lean_dec(x_60);
+x_66 = l_Lean_Parser_Module_import___elambda__1___closed__11;
+lean_inc(x_20);
+x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_66, x_20);
+x_21 = x_67;
+goto block_56;
+}
+}
+else
+{
+lean_object* x_68; lean_object* x_69; 
+lean_dec(x_58);
+x_68 = l_Lean_Parser_Module_import___elambda__1___closed__11;
+lean_inc(x_20);
+x_69 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_68, x_20);
+x_21 = x_69;
+goto block_56;
+}
+block_56:
+{
+lean_object* x_22; 
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_20);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_19);
 x_25 = lean_ctor_get(x_24, 3);
 lean_inc(x_25);
 if (lean_obj_tag(x_25) == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-lean_dec(x_23);
-x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_22);
-x_28 = lean_ctor_get(x_27, 3);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_26 = l_Lean_Parser_ident___elambda__1(x_1, x_24);
+x_27 = l_Lean_Parser_Module_import___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
+}
+else
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_29 = lean_apply_3(x_5, x_1, x_2, x_27);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+lean_dec(x_25);
+lean_dec(x_1);
 x_30 = l_Lean_Parser_Module_import___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_18);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_13, x_10);
-lean_dec(x_10);
+x_31 = l_Lean_Parser_ParserState_mkNode(x_24, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
 return x_32;
 }
+}
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_28);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_33; uint8_t x_34; 
+lean_dec(x_22);
+x_33 = lean_ctor_get(x_21, 1);
+lean_inc(x_33);
+x_34 = lean_nat_dec_eq(x_33, x_20);
+lean_dec(x_33);
+if (x_34 == 0)
+{
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_20);
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_21, x_35, x_19);
+x_37 = lean_ctor_get(x_36, 3);
+lean_inc(x_37);
+if (lean_obj_tag(x_37) == 0)
+{
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_38 = l_Lean_Parser_ident___elambda__1(x_1, x_36);
+x_39 = l_Lean_Parser_Module_import___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
+}
+else
+{
+lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+lean_dec(x_37);
 lean_dec(x_1);
-x_33 = l_Lean_Parser_Module_import___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_18);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_13, x_10);
-lean_dec(x_10);
-return x_35;
-}
-}
-else
-{
-lean_object* x_36; uint8_t x_37; 
-lean_dec(x_25);
-x_36 = lean_ctor_get(x_24, 1);
-lean_inc(x_36);
-x_37 = lean_nat_dec_eq(x_36, x_23);
-lean_dec(x_36);
-if (x_37 == 0)
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-lean_dec(x_23);
-x_38 = l_Lean_nullKind;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_24, x_38, x_22);
-x_40 = lean_ctor_get(x_39, 3);
-lean_inc(x_40);
-if (lean_obj_tag(x_40) == 0)
-{
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_41 = lean_apply_3(x_5, x_1, x_2, x_39);
 x_42 = l_Lean_Parser_Module_import___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_18);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_13, x_10);
-lean_dec(x_10);
+x_43 = l_Lean_Parser_ParserState_mkNode(x_36, x_42, x_15);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_10, x_7);
+lean_dec(x_7);
 return x_44;
 }
+}
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+x_45 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+x_46 = l_Lean_nullKind;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_19);
+x_48 = lean_ctor_get(x_47, 3);
+lean_inc(x_48);
+if (lean_obj_tag(x_48) == 0)
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+x_49 = l_Lean_Parser_ident___elambda__1(x_1, x_47);
+x_50 = l_Lean_Parser_Module_import___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_15);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_10, x_7);
+lean_dec(x_7);
+return x_52;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+lean_dec(x_48);
 lean_dec(x_1);
-x_45 = l_Lean_Parser_Module_import___elambda__1___closed__2;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_39, x_45, x_18);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_13, x_10);
-lean_dec(x_10);
-return x_47;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-x_48 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
-x_49 = l_Lean_nullKind;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_48, x_49, x_22);
-x_51 = lean_ctor_get(x_50, 3);
-lean_inc(x_51);
-if (lean_obj_tag(x_51) == 0)
-{
-lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_52 = lean_apply_3(x_5, x_1, x_2, x_50);
 x_53 = l_Lean_Parser_Module_import___elambda__1___closed__2;
-x_54 = l_Lean_Parser_ParserState_mkNode(x_52, x_53, x_18);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_13, x_10);
-lean_dec(x_10);
+x_54 = l_Lean_Parser_ParserState_mkNode(x_47, x_53, x_15);
+x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_10, x_7);
+lean_dec(x_7);
 return x_55;
 }
-else
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-lean_dec(x_51);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_56 = l_Lean_Parser_Module_import___elambda__1___closed__2;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_50, x_56, x_18);
-x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_13, x_10);
-lean_dec(x_10);
-return x_58;
-}
 }
 }
 }
 }
 else
 {
-lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_73 = l_Lean_Parser_Module_import___elambda__1___closed__2;
-x_74 = l_Lean_Parser_ParserState_mkNode(x_19, x_73, x_18);
-x_75 = l_Lean_Parser_mergeOrElseErrors(x_74, x_13, x_10);
-lean_dec(x_10);
-return x_75;
+x_70 = l_Lean_Parser_Module_import___elambda__1___closed__2;
+x_71 = l_Lean_Parser_ParserState_mkNode(x_16, x_70, x_15);
+x_72 = l_Lean_Parser_mergeOrElseErrors(x_71, x_10, x_7);
+lean_dec(x_7);
+return x_72;
 }
 }
 }
@@ -955,7 +937,7 @@ lean_object* _init_l_Lean_Parser_Module_import___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Module_import___closed__3;
@@ -999,7 +981,7 @@ lean_object* _init_l_Lean_Parser_Module_import___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Module_import___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Module_import___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1023,67 +1005,64 @@ x_1 = l_Lean_Parser_Module_import___closed__9;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-lean_inc(x_2);
-x_8 = l_Lean_Parser_Module_import___elambda__1(x_2, x_3, x_4);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Module_import___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_10; uint8_t x_11; 
-lean_dec(x_6);
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_7, x_10);
-lean_dec(x_10);
-lean_dec(x_7);
-if (x_11 == 0)
+lean_object* x_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
+lean_dec(x_5);
+if (x_9 == 0)
 {
-x_4 = x_8;
+x_2 = x_6;
 goto _start;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_13 = l_Lean_Parser_manyAux___main___closed__1;
-x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
-return x_14;
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_15; uint8_t x_16; 
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_15 = lean_ctor_get(x_8, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_7, x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+lean_object* x_13; uint8_t x_14; 
 lean_dec(x_7);
-lean_dec(x_6);
-return x_8;
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_17;
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+return x_15;
 }
 }
 }
@@ -1119,194 +1098,183 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Module_header___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Module_header___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Module_header___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Module_header___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Module_header___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Module_header___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Module_header___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Module_header___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Module_header___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
 lean_inc(x_1);
-x_17 = l_Lean_Parser_Module_prelude___elambda__1(x_1, x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = l_Lean_Parser_Module_prelude___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = l_Lean_nullKind;
-lean_inc(x_16);
-x_20 = l_Lean_Parser_ParserState_mkNode(x_17, x_19, x_16);
-x_21 = lean_ctor_get(x_20, 3);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = l_Lean_nullKind;
+lean_inc(x_15);
+x_19 = l_Lean_Parser_ParserState_mkNode(x_16, x_18, x_15);
+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_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_22 = lean_ctor_get(x_20, 0);
-lean_inc(x_22);
-x_23 = lean_array_get_size(x_22);
-lean_dec(x_22);
-x_24 = 0;
-x_25 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(x_24, x_1, x_2, x_20);
-x_26 = l_Lean_Parser_ParserState_mkNode(x_25, x_19, x_23);
-x_27 = l_Lean_Parser_Module_header___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
-}
-else
-{
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_22 = lean_array_get_size(x_21);
 lean_dec(x_21);
-lean_dec(x_2);
+x_23 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(x_1, x_19);
+x_24 = l_Lean_Parser_ParserState_mkNode(x_23, x_18, x_22);
+x_25 = l_Lean_Parser_Module_header___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_20);
 lean_dec(x_1);
-x_30 = l_Lean_Parser_Module_header___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_20, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
+x_28 = l_Lean_Parser_Module_header___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_19, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
 }
 }
 else
 {
-lean_object* x_33; uint8_t x_34; 
-lean_dec(x_18);
-x_33 = lean_ctor_get(x_17, 1);
-lean_inc(x_33);
-x_34 = lean_nat_dec_eq(x_33, x_8);
-lean_dec(x_33);
-if (x_34 == 0)
+lean_object* x_31; uint8_t x_32; 
+lean_dec(x_17);
+x_31 = lean_ctor_get(x_16, 1);
+lean_inc(x_31);
+x_32 = lean_nat_dec_eq(x_31, x_7);
+lean_dec(x_31);
+if (x_32 == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_35 = l_Lean_nullKind;
-lean_inc(x_16);
-x_36 = l_Lean_Parser_ParserState_mkNode(x_17, x_35, x_16);
-x_37 = lean_ctor_get(x_36, 3);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_33 = l_Lean_nullKind;
+lean_inc(x_15);
+x_34 = l_Lean_Parser_ParserState_mkNode(x_16, x_33, x_15);
+x_35 = lean_ctor_get(x_34, 3);
+lean_inc(x_35);
+if (lean_obj_tag(x_35) == 0)
 {
-lean_object* x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_38 = lean_ctor_get(x_36, 0);
-lean_inc(x_38);
-x_39 = lean_array_get_size(x_38);
-lean_dec(x_38);
-x_40 = 0;
-x_41 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(x_40, x_1, x_2, x_36);
-x_42 = l_Lean_Parser_ParserState_mkNode(x_41, x_35, x_39);
+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; 
+x_36 = lean_ctor_get(x_34, 0);
+lean_inc(x_36);
+x_37 = lean_array_get_size(x_36);
+lean_dec(x_36);
+x_38 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(x_1, x_34);
+x_39 = l_Lean_Parser_ParserState_mkNode(x_38, x_33, x_37);
+x_40 = l_Lean_Parser_Module_header___elambda__1___closed__2;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_15);
+x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_10, x_7);
+lean_dec(x_7);
+return x_42;
+}
+else
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_35);
+lean_dec(x_1);
 x_43 = l_Lean_Parser_Module_header___elambda__1___closed__2;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_16);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_11, x_8);
-lean_dec(x_8);
+x_44 = l_Lean_Parser_ParserState_mkNode(x_34, x_43, x_15);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_10, x_7);
+lean_dec(x_7);
 return x_45;
 }
+}
 else
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_37);
-lean_dec(x_2);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_inc(x_7);
+x_46 = l_Lean_Parser_ParserState_restore(x_16, x_15, x_7);
+x_47 = l_Lean_nullKind;
+lean_inc(x_15);
+x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_15);
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+x_50 = lean_ctor_get(x_48, 0);
+lean_inc(x_50);
+x_51 = lean_array_get_size(x_50);
+lean_dec(x_50);
+x_52 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(x_1, x_48);
+x_53 = l_Lean_Parser_ParserState_mkNode(x_52, x_47, x_51);
+x_54 = l_Lean_Parser_Module_header___elambda__1___closed__2;
+x_55 = l_Lean_Parser_ParserState_mkNode(x_53, x_54, x_15);
+x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_10, x_7);
+lean_dec(x_7);
+return x_56;
+}
+else
+{
+lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+lean_dec(x_49);
 lean_dec(x_1);
-x_46 = l_Lean_Parser_Module_header___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_36, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
-}
-}
-else
-{
-lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_inc(x_8);
-x_49 = l_Lean_Parser_ParserState_restore(x_17, x_16, x_8);
-x_50 = l_Lean_nullKind;
-lean_inc(x_16);
-x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_16);
-x_52 = lean_ctor_get(x_51, 3);
-lean_inc(x_52);
-if (lean_obj_tag(x_52) == 0)
-{
-lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_53 = lean_ctor_get(x_51, 0);
-lean_inc(x_53);
-x_54 = lean_array_get_size(x_53);
-lean_dec(x_53);
-x_55 = 0;
-x_56 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(x_55, x_1, x_2, x_51);
-x_57 = l_Lean_Parser_ParserState_mkNode(x_56, x_50, x_54);
-x_58 = l_Lean_Parser_Module_header___elambda__1___closed__2;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_16);
-x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_11, x_8);
-lean_dec(x_8);
-return x_60;
-}
-else
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-lean_dec(x_52);
-lean_dec(x_2);
-lean_dec(x_1);
-x_61 = l_Lean_Parser_Module_header___elambda__1___closed__2;
-x_62 = l_Lean_Parser_ParserState_mkNode(x_51, x_61, x_16);
-x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_11, x_8);
-lean_dec(x_8);
-return x_63;
+x_57 = l_Lean_Parser_Module_header___elambda__1___closed__2;
+x_58 = l_Lean_Parser_ParserState_mkNode(x_48, x_57, x_15);
+x_59 = l_Lean_Parser_mergeOrElseErrors(x_58, x_10, x_7);
+lean_dec(x_7);
+return x_59;
 }
 }
 }
@@ -1372,7 +1340,7 @@ lean_object* _init_l_Lean_Parser_Module_header___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Module_header___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Module_header___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1396,16 +1364,6 @@ x_1 = l_Lean_Parser_Module_header___closed__7;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Module_header___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-return x_6;
-}
-}
 lean_object* _init_l_Lean_Parser_Module_updateTokens___closed__1() {
 _start:
 {
@@ -1422,7 +1380,7 @@ x_2 = !lean_is_exclusive(x_1);
 if (x_2 == 0)
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_3 = lean_ctor_get(x_1, 2);
+x_3 = lean_ctor_get(x_1, 3);
 x_4 = l_Lean_Parser_Module_header;
 x_5 = lean_ctor_get(x_4, 0);
 lean_inc(x_5);
@@ -1433,7 +1391,7 @@ lean_object* x_7; lean_object* x_8;
 lean_dec(x_6);
 x_7 = l_Lean_Parser_Module_updateTokens___closed__1;
 x_8 = l_unreachable_x21___rarg(x_7);
-lean_ctor_set(x_1, 2, x_8);
+lean_ctor_set(x_1, 3, x_8);
 return x_1;
 }
 else
@@ -1442,47 +1400,51 @@ lean_object* x_9;
 x_9 = lean_ctor_get(x_6, 0);
 lean_inc(x_9);
 lean_dec(x_6);
-lean_ctor_set(x_1, 2, x_9);
+lean_ctor_set(x_1, 3, x_9);
 return x_1;
 }
 }
 else
 {
-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_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; 
 x_10 = lean_ctor_get(x_1, 0);
 x_11 = lean_ctor_get(x_1, 1);
 x_12 = lean_ctor_get(x_1, 2);
+x_13 = lean_ctor_get(x_1, 3);
+lean_inc(x_13);
 lean_inc(x_12);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_dec(x_1);
-x_13 = l_Lean_Parser_Module_header;
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-x_15 = l_Lean_Parser_addParserTokens(x_12, x_14);
-if (lean_obj_tag(x_15) == 0)
+x_14 = l_Lean_Parser_Module_header;
+x_15 = lean_ctor_get(x_14, 0);
+lean_inc(x_15);
+x_16 = l_Lean_Parser_addParserTokens(x_13, x_15);
+if (lean_obj_tag(x_16) == 0)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_dec(x_15);
-x_16 = l_Lean_Parser_Module_updateTokens___closed__1;
-x_17 = l_unreachable_x21___rarg(x_16);
-x_18 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_18, 0, x_10);
-lean_ctor_set(x_18, 1, x_11);
-lean_ctor_set(x_18, 2, x_17);
-return x_18;
+lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_16);
+x_17 = l_Lean_Parser_Module_updateTokens___closed__1;
+x_18 = l_unreachable_x21___rarg(x_17);
+x_19 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_19, 0, x_10);
+lean_ctor_set(x_19, 1, x_11);
+lean_ctor_set(x_19, 2, x_12);
+lean_ctor_set(x_19, 3, x_18);
+return x_19;
 }
 else
 {
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_15, 0);
-lean_inc(x_19);
-lean_dec(x_15);
-x_20 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_20, 0, x_10);
-lean_ctor_set(x_20, 1, x_11);
-lean_ctor_set(x_20, 2, x_19);
-return x_20;
+lean_object* x_20; lean_object* x_21; 
+x_20 = lean_ctor_get(x_16, 0);
+lean_inc(x_20);
+lean_dec(x_16);
+x_21 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_21, 0, x_10);
+lean_ctor_set(x_21, 1, x_11);
+lean_ctor_set(x_21, 2, x_12);
+lean_ctor_set(x_21, 3, x_20);
+return x_21;
 }
 }
 }
@@ -1546,7 +1508,7 @@ return x_4;
 lean_object* l_Lean_Parser_parseHeader(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-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_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; 
 x_3 = l_Lean_Parser_mkParserContext(x_1, x_2);
 x_4 = l_Lean_Parser_Module_updateTokens(x_3);
 x_5 = lean_ctor_get(x_4, 0);
@@ -1557,60 +1519,59 @@ lean_dec(x_5);
 x_7 = l_Lean_Parser_mkParserState(x_6);
 lean_dec(x_6);
 x_8 = l_Lean_Parser_whitespace___main(x_4, x_7);
-x_9 = lean_unsigned_to_nat(0u);
 lean_inc(x_4);
-x_10 = l_Lean_Parser_Module_header___elambda__1(x_9, x_4, x_8);
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-x_12 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_11);
-lean_dec(x_11);
-x_13 = lean_ctor_get(x_10, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
-{
-lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-lean_dec(x_4);
-x_14 = lean_ctor_get(x_10, 1);
-lean_inc(x_14);
+x_9 = l_Lean_Parser_Module_header___elambda__1(x_4, x_8);
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+x_11 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_10);
 lean_dec(x_10);
-x_15 = 0;
-x_16 = lean_alloc_ctor(0, 1, 1);
-lean_ctor_set(x_16, 0, x_14);
-lean_ctor_set_uint8(x_16, sizeof(void*)*1, x_15);
-x_17 = l_PersistentArray_empty___closed__3;
+x_12 = lean_ctor_get(x_9, 3);
+lean_inc(x_12);
+if (lean_obj_tag(x_12) == 0)
+{
+lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+lean_dec(x_4);
+x_13 = lean_ctor_get(x_9, 1);
+lean_inc(x_13);
+lean_dec(x_9);
+x_14 = 0;
+x_15 = lean_alloc_ctor(0, 1, 1);
+lean_ctor_set(x_15, 0, x_13);
+lean_ctor_set_uint8(x_15, sizeof(void*)*1, x_14);
+x_16 = l_PersistentArray_empty___closed__3;
+x_17 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_17, 0, x_15);
+lean_ctor_set(x_17, 1, x_16);
 x_18 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_18, 0, x_16);
+lean_ctor_set(x_18, 0, x_11);
 lean_ctor_set(x_18, 1, x_17);
-x_19 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_19, 0, x_12);
-lean_ctor_set(x_19, 1, x_18);
-return x_19;
+return x_18;
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_20 = lean_ctor_get(x_13, 0);
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+x_19 = lean_ctor_get(x_12, 0);
+lean_inc(x_19);
+lean_dec(x_12);
+x_20 = lean_ctor_get(x_9, 1);
 lean_inc(x_20);
-lean_dec(x_13);
-x_21 = lean_ctor_get(x_10, 1);
-lean_inc(x_21);
-lean_dec(x_10);
-x_22 = l_Lean_Parser_Error_toString(x_20);
-x_23 = l___private_Init_Lean_Parser_Module_1__mkErrorMessage(x_4, x_21, x_22);
+lean_dec(x_9);
+x_21 = l_Lean_Parser_Error_toString(x_19);
+x_22 = l___private_Init_Lean_Parser_Module_1__mkErrorMessage(x_4, x_20, x_21);
 lean_dec(x_4);
-x_24 = 1;
-x_25 = lean_alloc_ctor(0, 1, 1);
-lean_ctor_set(x_25, 0, x_21);
-lean_ctor_set_uint8(x_25, sizeof(void*)*1, x_24);
-x_26 = l_PersistentArray_empty___closed__3;
-x_27 = l_PersistentArray_push___rarg(x_26, x_23);
+x_23 = 1;
+x_24 = lean_alloc_ctor(0, 1, 1);
+lean_ctor_set(x_24, 0, x_20);
+lean_ctor_set_uint8(x_24, sizeof(void*)*1, x_23);
+x_25 = l_PersistentArray_empty___closed__3;
+x_26 = l_PersistentArray_push___rarg(x_25, x_22);
+x_27 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_27, 0, x_24);
+lean_ctor_set(x_27, 1, x_26);
 x_28 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_28, 0, x_25);
+lean_ctor_set(x_28, 0, x_11);
 lean_ctor_set(x_28, 1, x_27);
-x_29 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_29, 0, x_12);
-lean_ctor_set(x_29, 1, x_28);
-return x_29;
+return x_28;
 }
 }
 }
@@ -1770,7 +1731,7 @@ x_16 = l_Lean_Parser_whitespace___main(x_11, x_15);
 x_17 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
 x_18 = lean_unsigned_to_nat(0u);
 lean_inc(x_11);
-x_19 = l_Lean_Parser_categoryParserFn(x_17, x_18, x_11, x_16);
+x_19 = l_Lean_Parser_categoryParser___elambda__1(x_17, x_18, x_11, x_16);
 x_20 = lean_ctor_get(x_19, 3);
 lean_inc(x_20);
 if (lean_obj_tag(x_20) == 0)
@@ -1781,7 +1742,7 @@ lean_dec(x_2);
 lean_dec(x_1);
 x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-x_22 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_21);
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
 lean_dec(x_21);
 x_23 = lean_ctor_get(x_19, 1);
 lean_inc(x_23);
@@ -1853,7 +1814,7 @@ x_44 = l_Lean_Parser_whitespace___main(x_39, x_43);
 x_45 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
 x_46 = lean_unsigned_to_nat(0u);
 lean_inc(x_39);
-x_47 = l_Lean_Parser_categoryParserFn(x_45, x_46, x_39, x_44);
+x_47 = l_Lean_Parser_categoryParser___elambda__1(x_45, x_46, x_39, x_44);
 x_48 = lean_ctor_get(x_47, 3);
 lean_inc(x_48);
 if (lean_obj_tag(x_48) == 0)
@@ -1864,7 +1825,7 @@ lean_dec(x_2);
 lean_dec(x_1);
 x_49 = lean_ctor_get(x_47, 0);
 lean_inc(x_49);
-x_50 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_49);
+x_50 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_49);
 lean_dec(x_49);
 x_51 = lean_ctor_get(x_47, 1);
 lean_inc(x_51);
diff --git a/stage0/stdlib/Init/Lean/Parser/Parser.c b/stage0/stdlib/Init/Lean/Parser/Parser.c
index 96363ec90f..493579e64e 100644
--- a/stage0/stdlib/Init/Lean/Parser/Parser.c
+++ b/stage0/stdlib/Init/Lean/Parser/Parser.c
@@ -14,31 +14,28 @@
 extern "C" {
 #endif
 lean_object* l_Lean_Parser_declareBuiltinParser___closed__9;
-lean_object* l_Lean_Parser_nonReservedSymbol___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nonReservedSymbol___boxed(lean_object*, lean_object*);
 lean_object* l_List_reverse___rarg(lean_object*);
-lean_object* l_Lean_Parser_optionalFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_identEq(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_identEq(lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_decimalNumberFn___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldArgs___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_19__ParserExtension_mkInitial(lean_object*);
-lean_object* l_Lean_Parser_charLit___boxed(lean_object*);
 lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__1(lean_object*);
-lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_declareLeadingBuiltinParser___closed__2;
 lean_object* l_Lean_Parser_builtinTokenTable;
-lean_object* l_Lean_Parser_mkAntiquotAux(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Parser_finishCommentBlock(lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_push(lean_object*, uint32_t);
 extern lean_object* l_Lean_Name_toString___closed__1;
 lean_object* l_Lean_Parser_charLit___closed__1;
 lean_object* l_Lean_Parser_andthenInfo___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__26;
-lean_object* l_Lean_Parser_symbolAux___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_hashOrelse(uint8_t);
+lean_object* l_Lean_Parser_symbolAux___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_hashOrelse;
+lean_object* l_Lean_Parser_hashAndthen___closed__1;
 lean_object* l_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(lean_object*, lean_object*, lean_object*);
 size_t l_USize_add(size_t, size_t);
 lean_object* l_Lean_Parser_manyAux___main___closed__1;
+lean_object* l_Lean_Parser_numLit___elambda__1___closed__2;
 extern lean_object* l_Lean_fieldIdxKind;
 lean_object* l_PersistentHashMap_foldlM___at_Lean_Parser_getSyntaxNodeKinds___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_forArgsM___rarg(lean_object*, lean_object*, lean_object*);
@@ -46,17 +43,16 @@ lean_object* l___private_Init_Lean_Parser_Parser_20__mergePrecendences___boxed(l
 lean_object* l_Lean_Parser_unicodeSymbolCheckPrec___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_declareLeadingBuiltinParser___closed__1;
 uint8_t l_RBNode_isRed___rarg(lean_object*);
-lean_object* l_Lean_Parser_andthenFn___boxed(lean_object*);
 uint8_t l_Lean_Parser_checkTailWs(lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_foldArgsM___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserExtension___closed__1;
 lean_object* l___private_Init_Lean_Parser_Parser_20__mergePrecendences___closed__1;
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_hexNumberFn___spec__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_try(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_nodeWithAntiquot___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_identFn___closed__1;
+lean_object* l_Lean_Parser_try(lean_object*);
+lean_object* l_Lean_Parser_nodeWithAntiquot___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_unicodeSymbolInfo___elambda__1___boxed(lean_object*);
-lean_object* l_Lean_Parser_prattParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawFn___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_prattParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_andthenInfo(lean_object*, lean_object*);
 uint8_t l_PersistentHashMap_contains___at_Lean_Parser_isValidSyntaxNodeKind___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_leadingIdentAsSymbol___boxed(lean_object*, lean_object*);
@@ -66,22 +62,19 @@ extern lean_object* l___private_Init_Lean_Environment_8__persistentEnvExtensions
 lean_object* l_Lean_Parser_ParserState_mkError(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_20__mergePrecendences(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__7;
+lean_object* l_Lean_Parser_strLitNoAntiquot___closed__2;
 lean_object* l___private_Init_Lean_Parser_Parser_27__BuiltinParserAttribute_add___closed__2;
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_octalNumberFn___spec__3(lean_object*, lean_object*);
 lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__3___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserContext(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_hashAndthen___boxed(lean_object*);
 lean_object* l_Lean_Parser_declareBuiltinParser___closed__8;
-lean_object* l_Lean_Parser_optional___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_TokenConfig_toStr___closed__1;
-lean_object* l_Lean_Parser_manyFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_InputContext_inhabited___closed__1;
 lean_object* l_PersistentHashMap_findAux___main___at_Lean_Parser_addLeadingParser___spec__2(lean_object*, size_t, lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_Parser_sepByInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_shrinkStack___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_orelseFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_decimalNumberFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldSepRevArgsM(lean_object*, lean_object*);
@@ -91,21 +84,17 @@ lean_object* l_Lean_Parser_mkParserExtension___closed__2;
 lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__3___rarg(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_20__mergePrecendences___closed__2;
 lean_object* l___private_Init_Lean_Parser_Parser_27__BuiltinParserAttribute_add___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_andthenAux(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_strLitNoAntiquot(uint8_t);
+lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_strLitNoAntiquot;
 lean_object* l_Lean_Parser_octalNumberFn___closed__1;
-lean_object* l_Lean_Parser_many1___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_many(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_many1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_many(lean_object*);
 extern lean_object* l_Lean_identKind___closed__1;
 lean_object* l_Lean_Parser_FirstTokens_toStr(lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepBy___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_checkLeadingFn(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_fieldIdxKind___closed__2;
 lean_object* l_Lean_Parser_strAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nodeWithAntiquot___elambda__1___rarg(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* 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;
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_28__ParserAttribute_add___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_identFnAux___main___spec__2___boxed(lean_object*, lean_object*);
@@ -117,33 +106,33 @@ lean_object* l_Lean_Syntax_foldSepRevArgs(lean_object*);
 lean_object* l_Lean_Parser_binNumberFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldlM___main___at_Lean_Parser_addParserTokens___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgsM___spec__1___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_many___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_numberFnAux(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
+lean_object* l_Lean_Parser_identEqFn___closed__1;
 lean_object* l_Lean_Parser_TokenConfig_HasToString___closed__1;
-lean_object* l_Lean_Parser_lookahead(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_lookahead(lean_object*);
 lean_object* l_Lean_Parser_unicodeSymbolInfo___elambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldSepArgs___rarg___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_charLit(uint8_t);
+lean_object* l_Lean_Parser_charLit;
 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* l_Lean_Parser_trailingLoop___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_foldlM___at_Lean_Parser_getSyntaxNodeKinds___spec__1(lean_object*, lean_object*);
 extern size_t l_PersistentHashMap_insertAux___main___rarg___closed__2;
-lean_object* l_Lean_Parser_strLit___elambda__1___rarg(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_Lean_Parser_numLit___elambda__1___closed__1;
 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_longestMatchFn(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_fieldIdx___closed__6;
 lean_object* l_Lean_Parser_registerBuiltinParserAttribute___closed__1;
-lean_object* l_Lean_Parser_nameLitNoAntiquot(uint8_t);
+lean_object* l_Lean_Parser_nameLitNoAntiquot;
 lean_object* l_Lean_Parser_parserExtension___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Syntax_foldSepArgs___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nameLitNoAntiquot___closed__2;
 lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__3;
 lean_object* l_Lean_Parser_mkParserExtension___closed__4;
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_decimalNumberFn___spec__2(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchFn_u2081___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__12;
 lean_object* l_Lean_Parser_Trie_matchPrefix___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_octalNumberFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_stackSize___boxed(lean_object*);
@@ -158,15 +147,14 @@ lean_object* l_Array_iterateMAux___main___at_Lean_Parser_SyntaxNodeKindSet_inser
 lean_object* l_Lean_Parser_ParserState_next(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Prod_HasRepr___rarg___closed__1;
 lean_object* l_Array_extract___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_setExpected___elambda__1___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_addParser(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_setExpected___elambda__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_addParser(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Parser_PrattParsingTables_inhabited;
 lean_object* l_Lean_Parser_categoryParserFnRef;
-lean_object* l_Lean_Parser_pushNone(uint8_t);
-lean_object* l_Lean_Parser_optionalFn___boxed(lean_object*);
-lean_object* l_Lean_Parser_longestMatchStep___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_pushNone;
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
 lean_object* l_Lean_Parser_InputContext_inhabited;
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1(uint8_t, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_parserExtension___elambda__3___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_HasToString___closed__1;
 lean_object* l_Lean_Parser_ParserExtensionState_inhabited___closed__1;
@@ -177,31 +165,27 @@ lean_object* l_Lean_Parser_regTermParserAttribute(lean_object*);
 lean_object* l_PersistentHashMap_containsAux___main___at_Lean_Parser_isValidSyntaxNodeKind___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_findAtAux___main___at_Lean_Parser_addLeadingParser___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_pushSyntax(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__17;
 lean_object* l_Lean_Syntax_foldSepArgsM(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_builtinParserCategoriesRef;
 lean_object* lean_environment_find(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawCh___elambda__1___rarg(uint32_t, uint8_t, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_parserExtension;
+lean_object* l_Lean_Parser_unquotedSymbolFn___closed__1;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_forSepArgsM___spec__1___boxed(lean_object*);
-lean_object* l_Lean_Parser_group(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_charLit___elambda__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_group(lean_object*);
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___closed__2;
 lean_object* l_Lean_Parser_dollarSymbol___closed__1;
-lean_object* l_Lean_Parser_ident(uint8_t);
+lean_object* l_Lean_Parser_ident;
 lean_object* l_Lean_Parser_parserExtension___closed__2;
 uint8_t l_Lean_Parser_isLitKind(lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_whitespace___main___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_binNumberFn___spec__1(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_fieldIdxKind___closed__1;
-lean_object* l_Lean_Parser_unquotedSymbolFn___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__3;
 lean_object* l_Lean_Parser_TokenConfig_HasBeq___closed__1;
 lean_object* l_Lean_Parser_categoryParserOfStackFn___closed__2;
 lean_object* lean_io_mk_ref(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_21__addTokenConfig___closed__3;
-lean_object* l_Lean_Parser_checkColGe(uint8_t, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__18;
-lean_object* l_Lean_Parser_dollarSymbol___boxed(lean_object*);
+lean_object* l_Lean_Parser_checkColGe(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nonReservedSymbolFn(lean_object*, lean_object*, lean_object*);
 uint8_t l_Char_isDigit(uint32_t);
 lean_object* l_Lean_Parser_ParserState_mkNode(lean_object*, lean_object*, lean_object*);
@@ -210,74 +194,74 @@ lean_object* l_List_append___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserExtension___lambda__2(lean_object*);
 lean_object* l_Lean_Parser_categoryParserFnExtension___closed__2;
 lean_object* l_Lean_Parser_nameLitNoAntiquot___closed__1;
-lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_foldArgsM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepByM___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_8__updateCache(lean_object*, lean_object*);
 lean_object* l_IO_ofExcept___at___private_Init_Lean_Parser_Parser_18__addBuiltinParserCategory___spec__1(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_many1Indent___lambda__1(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_many1Indent___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_ref_get(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nameLitNoAntiquot___boxed(lean_object*);
 lean_object* l_Lean_Parser_declareBuiltinParser___closed__5;
-lean_object* l_Lean_Parser_strLit___boxed(lean_object*);
-lean_object* l_Lean_Parser_identEqFn___boxed(lean_object*);
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1___boxed(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__10;
+lean_object* l_Lean_Parser_mkAntiquot___closed__9;
 lean_object* l_RBNode_insert___at_Lean_Parser_TokenMap_insert___spec__5(lean_object*);
-lean_object* l_Lean_Parser_pushNone___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_pushNone___elambda__1___boxed(lean_object*);
 lean_object* l_List_map___main___at_Lean_Parser_addLeadingParser___spec__4(lean_object*);
 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_Parser_orelseFn(uint8_t);
+lean_object* l_Lean_Parser_orelseFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_registerBuiltinDynamicParserAttribute(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Position_Inhabited___closed__1;
-lean_object* l_Lean_Parser_symbolNoWsFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_symbolNoWsFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkTrailingNode(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unquotedSymbolFn___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unquotedSymbol___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_18__addBuiltinParserCategory___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_finishCommentBlock___main___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_try___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_quotedSymbol___closed__2;
+lean_object* l_Lean_Parser_mkAntiquot___closed__4;
 lean_object* l_Lean_Parser_mkInputContext(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_addBuiltinParser___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__10;
-lean_object* l_Lean_Parser_addBuiltinParser(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_addBuiltinParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawCh___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_rawCh___elambda__1(uint32_t, uint8_t, lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_IO_ofExcept___at___private_Init_Lean_Parser_Parser_25__ParserExtension_addImported___spec__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_charLitKind___closed__1;
 lean_object* lean_string_append(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_symbolNoWsFn(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_symbolNoWsFn(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Syntax_termIdToAntiquot___closed__3;
 lean_object* l_Lean_Parser_tokenFn(lean_object*, lean_object*);
 lean_object* l_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7(lean_object*);
+lean_object* l_Lean_Parser_dollarSymbol___closed__4;
 lean_object* l_Lean_Parser_mkAtomicInfo(lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_binNumberFn___spec__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_charLit___elambda__1___closed__1;
 lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_parserExtension___elambda__4___rarg(lean_object*);
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
+lean_object* l_Lean_Parser_numLit___closed__3;
 lean_object* l_Lean_Parser_declareBuiltinParser___closed__1;
+lean_object* l_Lean_Parser_charLit___elambda__1___closed__2;
 uint8_t l_Char_isWhitespace(uint32_t);
 extern lean_object* l_String_splitAux___main___closed__1;
-lean_object* l_Lean_Parser_categoryParserFnImpl(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_withPosition(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_categoryParserFnImpl(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_withPosition(lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__11;
+lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___closed__1;
 lean_object* l_Lean_Parser_charLitFnAux(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Syntax_termIdToAntiquot___closed__1;
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__14;
 extern lean_object* l_List_repr___rarg___closed__3;
-lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_quotedSymbol___closed__1;
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepByM___spec__1___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_identFnAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkNodeToken(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___boxed(lean_object*, lean_object*);
 size_t l_USize_shiftRight(size_t, size_t);
 lean_object* l_Lean_Parser_identFnAux___main___closed__1;
 lean_object* l_Lean_Parser_symbolInfo___elambda__1(lean_object*);
-lean_object* l_Lean_Parser_nonReservedSymbol(uint8_t, lean_object*, uint8_t);
+lean_object* l_Lean_Parser_nonReservedSymbol(lean_object*, uint8_t);
 lean_object* l_Lean_Parser_symbolFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkNodeToken___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_initCacheForInput___boxed(lean_object*);
@@ -285,206 +269,189 @@ lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_forArgsM___spec__1(lean
 lean_object* l_Lean_Parser_symbolNoWs___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_isParserCategory___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_declareBuiltinParser___closed__2;
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__15;
 lean_object* l_Lean_Syntax_foldSepArgsM___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_identEqFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* l_Lean_Syntax_forSepArgsM(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId(uint8_t);
+lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId;
 extern lean_object* l_Lean_mkAppStx___closed__4;
 lean_object* l_Lean_Parser_ParserState_mkErrorsAt(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___closed__1;
+lean_object* l_Lean_Parser_checkStackTopFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldSepRevArgs___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_leadingParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_leadingParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolNoWsInfo___elambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findRevMAux___main___at___private_Init_Lean_Parser_Parser_9__pickNonNone___spec__1(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkAttributeImplOfConstantUnsafe___closed__3;
-lean_object* l_Lean_Parser_strLitFn___rarg___closed__1;
 lean_object* l_Lean_Parser_parserExtension___closed__1;
 lean_object* l_Lean_Parser_checkColGeFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_declareBuiltinParser___closed__4;
-lean_object* l_Lean_Parser_nameLitFn(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_quotedSymbolFn(uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_setExpected___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nameLitFn(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_quotedSymbolFn(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_setExpected___elambda__1___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Nat_HasOfNat___closed__1;
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__5;
 lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1___rarg(lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_strLitFnAux___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_nameLitKind;
 lean_object* l_Lean_Parser_categoryParserFnExtension___closed__1;
 lean_object* l_Lean_Parser_strLit___closed__1;
+lean_object* l_Lean_Parser_unquotedSymbol___closed__2;
 extern lean_object* l_Lean_LocalContext_Inhabited___closed__1;
-lean_object* l_Lean_Parser_symbolFn___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_binNumberFn___spec__3___boxed(lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Parser_mkParserExtension___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_charLitFn___rarg___closed__1;
+lean_object* l_Lean_Parser_fieldIdx___closed__4;
 lean_object* l_PersistentHashMap_foldlMAux___main___at_Lean_Parser_getSyntaxNodeKinds___spec__2(lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_forSepArgsM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ident___closed__1;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgsM___spec__1___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_finishCommentBlock___main(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__3;
 lean_object* lean_nat_add(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_ident___boxed(lean_object*);
 lean_object* l_Lean_Parser_indexed___rarg(lean_object*, lean_object*, lean_object*, uint8_t);
 uint8_t l_Lean_Parser_takeWhileFn___lambda__1(lean_object*, uint32_t);
 uint32_t l_Lean_Parser_getNext(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawIdentNoAntiquot___boxed(lean_object*);
 lean_object* l_Lean_Parser_andthenInfo___elambda__2(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__3;
 lean_object* l_IO_ofExcept___at___private_Init_Lean_Parser_Parser_25__ParserExtension_addImported___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_addParserCategory(lean_object*, lean_object*, uint8_t);
-lean_object* l_Lean_Parser_many1Fn(uint8_t, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___boxed(lean_object*);
+lean_object* l_Lean_Parser_many1Fn(lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_rawIdent___closed__3;
 lean_object* l_Lean_Parser_symbolNoWsInfo___elambda__1(lean_object*);
 lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__2;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_forSepArgsM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Lean_Parser_addLeadingParser___spec__8(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepRevArgsM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_identEqFn(uint8_t);
-lean_object* l_Lean_Parser_optional(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_identEqFn(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_optional(lean_object*);
 lean_object* l_Lean_Parser_parserExtension___closed__3;
 lean_object* l_Lean_Parser_parserExtension___elambda__2___boxed(lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Syntax_foldSepRevArgs___spec__1(lean_object*);
-lean_object* l_Lean_Parser_numLit___boxed(lean_object*);
-lean_object* l_Lean_Parser_numLitNoAntiquot___boxed(lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__17;
-lean_object* l_Lean_Parser_identFn___boxed(lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__1;
 lean_object* l_Lean_Parser_declareTrailingBuiltinParser___closed__1;
 lean_object* l_Lean_Parser_mkParserExtension___lambda__1(lean_object*);
 lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__2;
-lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr(uint8_t);
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr;
 lean_object* l_Lean_Parser_parserExtension___closed__5;
 lean_object* l_Array_iterateMAux___main___at_Lean_Parser_getSyntaxNodeKinds___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_numLit___closed__1;
 lean_object* l_Lean_Parser_rawIdentFn(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_29__registerParserAttributeImplBuilder(lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_stringToParserCoe(lean_object*);
 uint8_t l_Lean_Parser_leadingIdentAsSymbol(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_indexed(lean_object*);
-lean_object* l_Lean_Parser_setExpectedFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_strLit___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_setExpectedFn___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_strLit___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_checkStackTopFn___closed__1;
 extern lean_object* l_Lean_mkTermIdFromIdent___closed__2;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgs___spec__1(lean_object*);
-lean_object* l_Lean_Parser_unicodeSymbolFn___rarg___closed__1;
 lean_object* lean_string_utf8_next(lean_object*, lean_object*);
 extern lean_object* l_Lean_mkAttributeImplOfConstant___closed__1;
+lean_object* l_Lean_Parser_mkAntiquot___closed__5;
 lean_object* l_Lean_Parser_TokenConfig_HasToString;
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_binNumberFn___spec__3(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_fieldIdx___boxed(lean_object*);
 lean_object* l_Lean_Parser_setCategoryParserFnRef(lean_object*);
 lean_object* l_Lean_Syntax_forArgsM(lean_object*);
 extern lean_object* l_Lean_registerTagAttribute___lambda__4___closed__3;
-lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_throwUnknownParserCategory(lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__15;
 lean_object* l_Lean_Parser_decimalNumberFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_PrattParsingTables_inhabited___closed__1;
+lean_object* l_Lean_Parser_compileParserDescr___main___closed__3;
 lean_object* l_Lean_Parser_throwUnknownParserCategory___rarg___closed__1;
-lean_object* l_Lean_Parser_unquotedSymbol___boxed(lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__2;
 lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__1;
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_quotedSymbolFn___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_numLit___closed__2;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgsM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_declareTrailingBuiltinParser___closed__2;
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___elambda__2(lean_object*);
-lean_object* l_Lean_Parser_unicodeSymbolFn___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_tryFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_initCacheForInput(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_9__pickNonNone___boxed(lean_object*);
 lean_object* l_Lean_Parser_symbolNoWsAux(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_identFnAux___main___spec__4(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__18;
 lean_object* l_Lean_Parser_addSyntaxNodeKind(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_termParser___closed__1;
 extern lean_object* l_Lean_Parser_Trie_HasEmptyc___closed__1;
 lean_object* l_Lean_Parser_mkIdResult___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_fieldIdx___closed__1;
+lean_object* l_Lean_Parser_unquotedSymbol___closed__1;
 lean_object* l_Lean_Parser_TokenMap_insert(lean_object*);
-lean_object* l_Lean_Parser_setExpected___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unicodeSymbol(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_setExpected___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_unicodeSymbol(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_25__ParserExtension_addImported(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_longestMatchFn___closed__1;
-lean_object* l_Lean_Parser_termParser___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_checkStackTopFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_unicodeSymbolInfo___elambda__1(lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Parser_getSyntaxNodeKinds___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_identNoAntiquot___closed__1;
 lean_object* l_Lean_Parser_ParserState_setPos(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_quotedSymbol___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkTokenAndFixPos___closed__1;
 lean_object* l___private_Init_Lean_Parser_Parser_16__throwParserCategoryAlreadyDefined___rarg(lean_object*);
-lean_object* l_Lean_Parser_strLitFn___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserAttributeImpl___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Parser_whitespace___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserExtension___closed__6;
 lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
 lean_object* l_Lean_Parser_mkTokenAndFixPos___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_find_x3f___at_Lean_Parser_addLeadingParser___spec__1(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_checkColGe___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_forSepArgsM___spec__1___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_quotedCharFn(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_checkNoWsBeforeFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAtomicInfo___elambda__2(lean_object*);
-lean_object* l_Lean_Parser_manyAux___main(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(uint8_t, lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_fieldIdx___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_strLitFn___closed__1;
+lean_object* l_Lean_Parser_manyAux___main(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_rawCh___elambda__1___spec__1(uint32_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_ident___closed__2;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_HasBeq___closed__1;
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__2;
 lean_object* l_Lean_Parser_nonReservedSymbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_charLit___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldSepArgsM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Parser_inhabited(uint8_t);
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Parser_inhabited;
 lean_object* l_Lean_Parser_mkBuiltinParserCategories(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_10__mkResult(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_quotedSymbolFn___spec__2(uint32_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_identFnAux___main___spec__3(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchFnAux(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_lookaheadFn(uint8_t);
+lean_object* l_Lean_Parser_longestMatchFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_lookaheadFn(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_EnvExtension_Inhabited___rarg___closed__1;
+lean_object* l_Lean_Parser_dollarSymbol___elambda__1___closed__2;
 lean_object* l_Lean_Parser_rawIdentNoAntiquot___closed__1;
-lean_object* l_Lean_Parser_symbolNoWsFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_symbolNoWsFnAux(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nodeInfo(lean_object*, lean_object*);
 lean_object* l_RBNode_insert___at_Lean_Parser_TokenMap_insert___spec__2___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__4;
-lean_object* l_Lean_Parser_dollarSymbol(uint8_t);
-lean_object* l_Lean_Parser_symbolFn___boxed(lean_object*);
+lean_object* l_Lean_Parser_dollarSymbol;
+lean_object* l_Lean_Parser_symbolFn___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_numLitKind;
 lean_object* l_EStateM_bind___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldArgsM___boxed(lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_findAux___main___at_Lean_Parser_addLeadingParser___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolNoWsInfo___elambda__1___boxed(lean_object*);
-lean_object* l_Lean_Parser_quotedSymbol(uint8_t);
+lean_object* l_Lean_Parser_quotedSymbol;
 lean_object* l_Lean_Parser_numLitNoAntiquot___closed__1;
 lean_object* lean_nat_sub(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_setExpected(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_setExpected(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_keepLatest(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__27;
-lean_object* l_Lean_Parser_checkLeadingFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_dollarSymbol___elambda__1___closed__1;
 lean_object* l_Lean_Parser_declareBuiltinParser(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldSepRevArgsM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_TokenMap_HasEmptyc(lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Syntax_foldSepRevArgs___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_checkNoWsBefore(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_checkWsBefore___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_checkNoWsBefore(lean_object*);
 lean_object* l_Lean_Parser_noFirstTokenInfo(lean_object*);
 lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__1;
-lean_object* l_Lean_Parser_checkLeadingFn___closed__1;
 extern lean_object* l_Lean_strLitKind;
 lean_object* l_Lean_Parser_nonReservedSymbolInfo(lean_object*, uint8_t);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__9;
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_forArgsM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_finishCommentBlock___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unquotedSymbol___elambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_parserExtension___closed__6;
-lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldArgs(lean_object*);
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___elambda__1(lean_object*);
 lean_object* l_Lean_Parser_nodeInfo___elambda__1(lean_object*, lean_object*, lean_object*);
@@ -494,27 +461,23 @@ lean_object* l_Lean_Parser_checkWsBeforeFn(lean_object*, lean_object*, lean_obje
 lean_object* l_Lean_registerAttributeOfBuilder(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_append___main(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_keepLatest___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_quotedSymbol___elambda__1(uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_checkColGe___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_node___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy(uint8_t, lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_Parser_sepBy(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_numLitNoAntiquot___closed__2;
 lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_fieldIdx___closed__3;
-lean_object* l_Lean_Parser_trailingLoop___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Parser_Error_beq(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_keepNewError(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_categoryParserOfStack___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_regTermParserAttribute___closed__1;
-lean_object* l_Lean_Parser_symbol(uint8_t, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_anyOfFn___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_symbol(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserExtension___closed__8;
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_octalNumberFn___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolInfo___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_whitespace___main(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nameLit___closed__3;
 lean_object* l_Lean_Syntax_foldArgsM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_numLitFn(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_numLitFn(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_parserExtension___closed__4;
 lean_object* l_Lean_Parser_identFnAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
@@ -525,17 +488,19 @@ lean_object* l_Lean_Parser_FirstTokens_seq(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_peekToken(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_toString___closed__4;
 lean_object* l_Lean_Parser_anyOfFn___main___closed__1;
+lean_object* l_Lean_Parser_strLit___elambda__1___closed__2;
 lean_object* l_Lean_Parser_SyntaxNodeKindSet_insert(lean_object*, lean_object*);
 extern lean_object* l_Lean_strLitKind___closed__1;
-lean_object* l_Lean_Parser_nodeWithAntiquot___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nodeWithAntiquot___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nameLit(uint8_t);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux(uint8_t, lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nameLit;
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_1__expectedToString___main___closed__1;
 lean_object* l_Lean_Parser_binNumberFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_lengthAux___main___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserOfConstant___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_strLit___elambda__1___boxed(lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__5;
+lean_object* l_Lean_Parser_charLitNoAntiquot___closed__3;
 lean_object* l_Lean_Parser_Error_HasBeq;
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___closed__3;
 extern lean_object* l___private_Init_Lean_Compiler_InitAttr_1__getIOTypeArg___closed__1;
@@ -545,158 +510,150 @@ lean_object* l_Lean_Parser_throwUnknownParserCategory___rarg(lean_object*);
 lean_object* l_Lean_Parser_ParserState_shrinkStack(lean_object*, lean_object*);
 uint8_t l_Lean_Parser_checkTailNoWs(lean_object*);
 lean_object* l_Lean_Parser_checkTailWs___boxed(lean_object*);
-lean_object* l_Lean_Parser_charLitFn(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_trailingLoopStep(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_charLitFn(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_trailingLoopStep(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldlM___main___at___private_Init_Lean_Parser_Parser_28__ParserAttribute_add___spec__1___closed__1;
+lean_object* l_Lean_Parser_charLitNoAntiquot___closed__2;
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_foldArgsM___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_andthenFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchStep(uint8_t);
+lean_object* l_Lean_Parser_longestMatchStep(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_addLeadingParser___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_charLitNoAntiquot___boxed(lean_object*);
-lean_object* l_Lean_Parser_setExpectedFn(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_strLitFn(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_setExpectedFn(lean_object*);
+lean_object* l_Lean_Parser_strLitFn(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_16__throwParserCategoryAlreadyDefined___rarg___closed__1;
 lean_object* l_Lean_Parser_mkParserExtension___lambda__2___boxed(lean_object*);
-lean_object* l_Lean_Parser_nodeFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unquotedSymbolFn___rarg___closed__1;
 lean_object* l_PersistentHashMap_foldlMAux___main___at_Lean_Parser_getSyntaxNodeKinds___spec__2___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__12;
+lean_object* l_Lean_Parser_charLit___closed__3;
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
 lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__4;
 lean_object* l_List_foldlM___main___at___private_Init_Lean_Parser_Parser_28__ParserAttribute_add___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 size_t l_Lean_Name_hash(lean_object*);
-lean_object* l_Lean_Parser_nonReservedSymbol___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_addToken(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchFnAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nameLit___closed__1;
 lean_object* l_Nat_repr(lean_object*);
-lean_object* l_Lean_Parser_categoryParserOfStack(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParserOfStack(lean_object*, lean_object*);
 extern lean_object* l_Char_HasRepr___closed__1;
+lean_object* l_Lean_Parser_mkAntiquot___closed__20;
 lean_object* l___private_Init_Lean_Parser_Parser_18__addBuiltinParserCategory(lean_object*, uint8_t, lean_object*);
-lean_object* l_Lean_Parser_toTrailing___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkBuiltinSyntaxNodeKindSetRef(lean_object*);
 lean_object* l_Lean_Parser_registerBuiltinParserAttribute___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_checkWsBefore(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_checkWsBefore(lean_object*);
 lean_object* l_Lean_Parser_checkNoWsBeforeFn(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_4__isToken___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t l_PersistentHashMap_containsAux___main___at_Lean_Parser_isValidSyntaxNodeKind___spec__2(lean_object*, size_t, lean_object*);
 lean_object* l_Lean_Parser_ParserState_setCache(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_strAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__10;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgsM___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_chFn___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkIdResult(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_decimalNumberFn___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_octalNumberFn___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_orelseInfo(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nameLit___closed__2;
 lean_object* l_Lean_Parser_strLitNoAntiquot___closed__1;
-lean_object* l_Lean_Parser_sepByFn(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepByFn(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_fieldIdx___closed__2;
 lean_object* l_IO_ofExcept___at___private_Init_Lean_Parser_Parser_18__addBuiltinParserCategory___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_chFn___spec__1(uint32_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nodeWithAntiquot___elambda__1___boxed(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_PersistentHashMap_insertAux___main___rarg___closed__3;
-lean_object* l_Lean_Parser_rawCh___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_rawCh___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_getNext___boxed(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_17__addParserCategoryCore___spec__6(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_ofExcept___at_Lean_Parser_declareBuiltinParser___spec__1(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_strLitNoAntiquot___boxed(lean_object*);
 lean_object* l_Lean_Parser_mkParserAttributeImpl___closed__1;
 lean_object* l_Lean_Parser_termParser___closed__2;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 extern lean_object* l_Lean_choiceKind;
-lean_object* l_Lean_Parser_rawCh___elambda__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nameLit___boxed(lean_object*);
 extern lean_object* l_List_repr___rarg___closed__2;
 extern lean_object* l_Lean_charLitKind;
-lean_object* l_Lean_Parser_identFn___rarg___closed__1;
-lean_object* l_Lean_Parser_checkLeading(lean_object*);
 extern lean_object* l_List_reprAux___main___rarg___closed__1;
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_hexNumberFn___spec__3___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nameLitFn___rarg___closed__1;
 lean_object* l_Lean_Parser_TokenMap_Inhabited(lean_object*);
 lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1___rarg___boxed(lean_object*);
 lean_object* l_Lean_Parser_regTermParserAttribute___closed__2;
-lean_object* l_Lean_Parser_rawIdent(uint8_t);
+lean_object* l_Lean_Parser_rawIdent;
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepByM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_25__ParserExtension_addImported___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_FirstTokens_merge(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_manyAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_strLit___elambda__1___closed__1;
 lean_object* l_Lean_Parser_pushNone___elambda__1___rarg(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1(uint8_t);
+lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1(lean_object*, lean_object*);
 lean_object* lean_eval_const(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserAttributeImpl(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nameLitFn___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_fieldIdx___closed__5;
 lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Init_Lean_Parser_Parser_28__ParserAttribute_add___spec__3___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolInfo___elambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_hexNumberFn___spec__2(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_ParserFn_inhabited(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_charLit___closed__2;
+lean_object* l_Lean_Parser_ParserFn_inhabited(lean_object*);
 lean_object* l_Lean_Parser_ParserExtensionState_inhabited;
 lean_object* l_Lean_Parser_ParserState_mkEOIError___closed__1;
 uint8_t l_Lean_Parser_isIdCont(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mergeOrElseErrors___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_compileParserDescr(lean_object*, uint8_t, lean_object*);
+lean_object* l_Lean_Parser_compileParserDescr(lean_object*, lean_object*);
 uint8_t l_List_elem___main___at_Lean_Parser_addLeadingParser___spec__7(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_quotedSymbolFn___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_declareTrailingBuiltinParser(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_hashAndthen(uint8_t);
+lean_object* l_Lean_Parser_hashAndthen;
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_setCategoryParserFnRef___closed__1;
 lean_object* l_PersistentHashMap_insertAux___main___at_Lean_Parser_SyntaxNodeKindSet_insert___spec__2(lean_object*, size_t, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_octalNumberFn___spec__3___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_identEqFn___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Parser_mkParserExtension___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_foldArgs___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgs___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_addParserTokens(lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux___boxed(lean_object*);
-lean_object* l_Lean_Parser_identEqFn___rarg___closed__1;
+lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_declareBuiltinParser___closed__7;
+lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__3;
 lean_object* l_Lean_Parser_parserExtension___elambda__2(lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__13;
 extern lean_object* l_Lean_mkAppStx___closed__6;
 extern lean_object* l_Lean_Options_empty;
 extern lean_object* l_IO_Error_Inhabited___closed__1;
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_octalNumberFn___spec__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_symbolFn(uint8_t);
+lean_object* l_Lean_Parser_symbolFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_28__ParserAttribute_add___spec__5(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_hasError___boxed(lean_object*);
-lean_object* l_Lean_Parser_unicodeSymbol___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_unicodeSymbol___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_empty___at_Lean_Parser_mkBuiltinSyntaxNodeKindSetRef___spec__1;
 lean_object* l_Lean_Parser_nodeInfo___elambda__2(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_24__ParserExtension_addEntry(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_compileParserDescr___main___closed__1;
 lean_object* l_Lean_Parser_identFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_identFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_contains___at___private_Init_Lean_Parser_Parser_17__addParserCategoryCore___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_strLitNoAntiquot___closed__3;
 lean_object* l_Lean_Parser_addParserCategory___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_registerBuiltinParserAttribute(lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Parser_charLitNoAntiquot___closed__1;
-lean_object* l_Lean_Parser_compileParserDescr___main___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_categoryParserFnExtension___closed__3;
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__8;
 extern lean_object* l___private_Init_Lean_Environment_5__envExtensionsRef;
-lean_object* l_Lean_Parser_anyOfFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Parser_inhabited___lambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Parser_inhabited___lambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_checkTailNoWs___boxed(lean_object*);
 lean_object* l_Lean_Parser_symbolNoWsAux___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolNoWsInfo(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_categoryParserFnImplAux(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParserFnImplAux(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_epsilonInfo___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_registerBuiltinAttribute(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawIdent___elambda__1___boxed(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_23__updateBuiltinTokens___closed__1;
 lean_object* l_Lean_FileMap_toPosition(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAtomicInfo___elambda__1(lean_object*);
-lean_object* l_Lean_Parser_anyOfFn(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_lookaheadFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_anyOfFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkEmptySubstringAt(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_binNumberFn___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_strLitFnAux___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_toString___closed__2;
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__9;
 lean_object* l___private_Init_Lean_Data_Trie_3__findAux___main___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nameLitNoAntiquot___closed__3;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgs___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__6;
 lean_object* l___private_Init_Lean_Parser_Parser_16__throwParserCategoryAlreadyDefined___rarg___closed__2;
 lean_object* l_IO_Prim_Ref_get___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_longestMatchMkResult(lean_object*, lean_object*);
@@ -706,60 +663,57 @@ lean_object* l_Lean_FileMap_ofString(lean_object*);
 lean_object* l_Lean_Parser_whitespace(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_quotedSymbolFn___closed__4;
 lean_object* l_List_redLength___main___rarg(lean_object*);
-lean_object* l_Lean_Parser_rawCh(uint8_t, uint32_t, uint8_t);
+lean_object* l_Lean_Parser_rawCh(uint32_t, uint8_t);
 lean_object* l_Lean_Parser_getTokenTable(lean_object*);
-lean_object* l_Lean_Parser_many1Indent___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_sepByInfo___elambda__1(lean_object*, lean_object*, lean_object*);
 uint8_t l_PersistentHashMap_containsAtAux___main___at_Lean_Environment_contains___spec__5(lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_empty___at_Lean_Parser_mkBuiltinParserCategories___spec__1;
 lean_object* l_Lean_Parser_ParserState_restore___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_elem___main___at_Lean_Parser_addLeadingParser___spec__7___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__21;
 lean_object* l_Lean_Parser_ParserState_restore(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_symbolAux(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_symbolAux(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_isValidSyntaxNodeKind___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_strLit___closed__3;
 lean_object* l_Lean_Parser_mkParserExtension(lean_object*);
 lean_object* l_Lean_Parser_ParserState_popSyntax(lean_object*);
-lean_object* l_Lean_Parser_checkWsBefore___elambda__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nameLit___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__6;
-lean_object* l_Lean_Parser_termParser(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_sepByFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_termParser(lean_object*);
+lean_object* l_Lean_Parser_sepByFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkBuiltinTokenTable(lean_object*);
 lean_object* l_Lean_Parser_FirstTokens_toStr___closed__3;
-lean_object* l_Lean_Parser_manyAux(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux(lean_object*, lean_object*, lean_object*);
 lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__3(lean_object*);
-lean_object* l_Lean_Parser_ident___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_addTrailingParser(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawIdentNoAntiquot___lambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_chFn(uint8_t);
+lean_object* l_Lean_Parser_mkAntiquot___closed__7;
+lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__1;
+lean_object* l_Lean_Parser_pushNone___closed__1;
+lean_object* l_Lean_Parser_chFn(uint32_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAtomicInfo___elambda__2___boxed(lean_object*);
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
 lean_object* l_Lean_Parser_declareBuiltinParser___closed__6;
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_quotedSymbolFn___spec__1(uint32_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawIdent___boxed(lean_object*);
-lean_object* l_Lean_Parser_mkAntiquot___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_21__addTokenConfig___closed__1;
+lean_object* l_Lean_Parser_trailingNodeFn(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_isIdEndEscape(uint32_t);
+lean_object* l_Lean_Parser_rawIdent___closed__2;
 lean_object* l_Lean_Parser_addBuiltinLeadingParser(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__2;
 lean_object* l_Lean_Syntax_foldSepArgsM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserExtension___closed__7;
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Parser_regBuiltinTermParserAttr___closed__1;
 lean_object* l___private_Init_Lean_Parser_Parser_6__nameLitAux(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__22;
+lean_object* l_Lean_Parser_rawIdentNoAntiquot___closed__2;
 lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
 size_t l_USize_land(size_t, size_t);
 lean_object* l_Lean_Parser_parserExtension___elambda__4___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__4;
+lean_object* l_Lean_Parser_nameLit___elambda__1___closed__1;
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Syntax_foldSepRevArgsM___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_insertAux___main___at___private_Init_Lean_Parser_Parser_17__addParserCategoryCore___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkParserExtension___spec__3___closed__1;
+lean_object* l_Lean_Parser_mkAntiquot___elambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_registerTagAttribute___lambda__4___closed__2;
-lean_object* l_Lean_Parser_toTrailing(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__25;
-lean_object* l_Lean_Parser_categoryParserFn(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParserFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ParametricAttribute_setParam___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepByM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkCategoryParserFnExtension___closed__1;
@@ -772,26 +726,23 @@ lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambd
 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___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldSepBy(lean_object*);
-lean_object* l_Lean_Parser_ident___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__2(lean_object*);
 lean_object* l_Lean_Parser_trailingNode(lean_object*, lean_object*);
 lean_object* l_Lean_mkAtomFrom(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_orelseInfo___elambda__2(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_pushNone___closed__2;
 lean_object* l_Lean_Parser_quotedCharFn___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1(uint8_t, lean_object*, lean_object*, uint8_t, uint8_t);
-lean_object* l_Lean_Parser_sepBy1Fn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1(lean_object*, lean_object*, uint8_t, uint8_t);
+lean_object* l_Lean_Parser_sepBy1Fn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkAppStx___closed__3;
 uint8_t l_Array_anyRangeMAux___main___at_Lean_Parser_mkParserExtension___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_categoryParser___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_TokenConfig_beq___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__3;
 lean_object* l_Lean_Parser_noFirstTokenInfo___elambda__1(lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___boxed(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_29__registerParserAttributeImplBuilder___closed__2;
-lean_object* l_Lean_Parser_pushNone___boxed(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_ident___elambda__1___closed__1;
+lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__2;
 lean_object* l_Lean_Parser_unicodeSymbolCheckPrec(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_declareLeadingBuiltinParser(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_appPrec;
@@ -799,178 +750,163 @@ lean_object* l_Lean_Parser_checkColGeFn(lean_object*, lean_object*, lean_object*
 lean_object* l_Lean_Parser_registerParserCategory(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Parser_charLitFnAux___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Option_HasRepr___rarg___closed__3;
-lean_object* l_Lean_Parser_prattParser___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_tryFn___boxed(lean_object*);
+lean_object* l_Lean_Parser_prattParser___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_Lean_Parser_nonReservedSymbol___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nodeWithAntiquot(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nodeWithAntiquot(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserExtension___closed__3;
 extern lean_object* l_Lean_identKind;
 lean_object* l_Lean_Parser_ParserState_mkErrorAt(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_fieldIdxFn___closed__1;
-lean_object* l_Lean_Parser_ident___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_ident___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_HasToString;
-lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_trailingLoop(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_trailingLoop(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Syntax_foldSepRevArgsM___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_symbol___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_symbol___boxed(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_foldArgs___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_checkNoWsBefore___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_charLit___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_charLit___elambda__1(lean_object*, lean_object*);
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
 extern lean_object* l_Lean_Syntax_inhabited;
-lean_object* l_Lean_Parser_unquotedSymbolFn(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_unquotedSymbolFn(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldSepRevArgsM___boxed(lean_object*, lean_object*);
 lean_object* l_String_intercalate(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__1;
-lean_object* l_Lean_Parser_numLit(uint8_t);
-lean_object* l_Lean_Parser_leadingParser___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_numLit;
+lean_object* l_Lean_Parser_leadingParser___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_hexDigitFn(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkCategoryParserFnRef___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__19;
+lean_object* l_Lean_Parser_mkCategoryParserFnRef___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__16;
 lean_object* l___private_Init_Lean_Parser_Parser_27__BuiltinParserAttribute_add___closed__1;
+lean_object* l_Lean_Parser_compileParserDescr___main___closed__2;
 lean_object* l_Lean_Parser_FirstTokens_HasToString___closed__1;
 lean_object* l_Lean_Parser_FirstTokens_HasToString;
-lean_object* l_Lean_Parser_numLit___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_numLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1(lean_object*);
 lean_object* l_Lean_Parser_Error_toString(lean_object*);
-lean_object* l_Lean_Parser_categoryParserOfStackFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_symbolNoWsFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___boxed(lean_object*);
+lean_object* l_Lean_Parser_categoryParserOfStackFn___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_symbolNoWsFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findRevMAux___main___at___private_Init_Lean_Parser_Parser_9__pickNonNone___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkTrailingNode___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchStep___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__4;
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepBy___spec__1(lean_object*);
-lean_object* l_Lean_Parser_string2basic___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_keepNewError___boxed(lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_foldlM___at___private_Init_Lean_Parser_Parser_28__ParserAttribute_add___spec__2___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawIdent___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__4___closed__2;
 lean_object* l_Lean_Parser_ParserState_mkUnexpectedErrorAt(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_hasArgs(lean_object*);
 lean_object* l_PersistentHashMap_contains___at_Lean_Parser_isValidSyntaxNodeKind___spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_mkInitAttr___lambda__1___closed__1;
 lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_identNoAntiquot___boxed(lean_object*);
-lean_object* l_Lean_Parser_tryFn(uint8_t);
+lean_object* l_Lean_Parser_tryFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_whitespace___main___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchFn_u2081___boxed(lean_object*);
 uint8_t l_Lean_Parser_isParserCategory(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_withPosition___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_withPosition___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 uint8_t l_USize_decLe(size_t, size_t);
 extern lean_object* l_Lean_registerTagAttribute___lambda__4___closed__5;
 lean_object* l_Lean_Parser_takeWhileFn___lambda__1___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_compileParserDescr___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_numLitNoAntiquot___closed__3;
 lean_object* l_Lean_mkApp(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_Inhabited;
 lean_object* l_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_categoryParser(uint8_t, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__1;
+lean_object* l_Lean_Parser_categoryParser(lean_object*, lean_object*);
 lean_object* l_Lean_nameToExprAux___main(lean_object*);
 lean_object* l_Lean_Parser_quotedSymbolFn___closed__2;
-lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_categoryParser___elambda__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_28__ParserAttribute_add(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, 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__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getKind(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__4;
-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*);
-lean_object* l_Lean_Parser_chFn___boxed(lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_chFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Parser_isValidSyntaxNodeKind(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_numLitNoAntiquot(uint8_t);
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__2;
+lean_object* l_Lean_Parser_numLitNoAntiquot;
 lean_object* l_Lean_Parser_Error_beq___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_orelseInfo___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr(uint8_t);
+lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr;
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__8;
+lean_object* l_Lean_Parser_mkAntiquot___closed__14;
 lean_object* l_Lean_Parser_FirstTokens_toStr___closed__1;
 lean_object* l_Lean_Parser_runParserCategory(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Parser_getSyntaxNodeKinds___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_addLeadingParser(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_containsAux___main___at___private_Init_Lean_Parser_Parser_17__addParserCategoryCore___spec__2___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_setExpectedFn___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_quotedSymbolFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__11;
+lean_object* l_Lean_Parser_setExpectedFn___boxed(lean_object*);
+lean_object* l_Lean_Parser_quotedSymbolFn___boxed(lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
 lean_object* l___private_Init_Lean_Parser_Parser_29__registerParserAttributeImplBuilder___closed__1;
 uint8_t l_PersistentHashMap_containsAtAux___main___at_Lean_Parser_isValidSyntaxNodeKind___spec__3(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserExtension___closed__5;
-lean_object* l_Lean_Parser_categoryParser___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_trailingLoopStep___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_dollarSymbol___closed__3;
 lean_object* l_Lean_Parser_satisfySymbolFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_binNumberFn___spec__2(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__4;
 lean_object* l_Lean_Parser_TokenConfig_toStr(lean_object*);
 lean_object* l_Lean_Parser_quotedSymbolFn___closed__1;
-lean_object* l_Lean_Parser_numLitFn___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_fieldIdx___lambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1Fn(uint8_t, uint8_t, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_checkStackTop(lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn(uint8_t, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_octalNumberFn___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Init_Util_1__mkPanicMessage___closed__2;
 lean_object* l_Lean_Parser_epsilonInfo;
-lean_object* l_Lean_Parser_lookaheadFn___boxed(lean_object*);
 lean_object* l_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_25__ParserExtension_addImported___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_anyOfFn___main(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_anyOfFn___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_toString___at_Lean_Parser_FirstTokens_toStr___spec__1(lean_object*);
 lean_object* l_Lean_Parser_epsilonInfo___closed__3;
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___boxed(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_29__registerParserAttributeImplBuilder___closed__3;
-lean_object* l_Lean_Parser_unquotedSymbol(uint8_t);
+lean_object* l_Lean_Parser_unquotedSymbol;
 lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
+lean_object* l_Lean_Parser_hashOrelse___closed__1;
+lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__1;
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___elambda__2___boxed(lean_object*);
-lean_object* l_Lean_Parser_many1Indent(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_many1Indent(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_whitespace___main___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_builtinSyntaxNodeKindSetRef;
 uint8_t l___private_Init_Lean_Parser_Parser_4__isToken(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserState___boxed(lean_object*);
-lean_object* l_Lean_Parser_categoryParser___elambda__1(uint8_t);
-lean_object* l_Lean_Parser_symbolFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchFn_u2081(uint8_t);
+lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_longestMatchFn_u2081(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolNoWsInfo___closed__1;
-lean_object* l_Lean_Parser_pushNone___elambda__1(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_pushNone___elambda__1(lean_object*);
 lean_object* lean_io_ref_reset(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_FirstTokens_toStr___closed__2;
-lean_object* l_Lean_Parser_hashOrelse___boxed(lean_object*);
 lean_object* lean_io_ref_swap(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawIdentNoAntiquot(uint8_t);
+lean_object* l_Lean_Parser_rawIdentNoAntiquot;
 lean_object* l___private_Init_Lean_Parser_Parser_5__isIdFirstOrBeginEscape___boxed(lean_object*);
 uint8_t l_PersistentHashMap_contains___at___private_Init_Lean_Parser_Parser_17__addParserCategoryCore___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_replaceLongest(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Parser_TokenConfig_beq(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_strLitFn___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerEnvExtensionUnsafe___rarg___closed__2;
+lean_object* l_Lean_Parser_ident___elambda__1___closed__2;
 lean_object* l_Lean_Parser_fieldIdxFn___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_29__registerParserAttributeImplBuilder___lambda__1___closed__1;
-lean_object* l_Lean_Parser_orelse___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserCategory_inhabited;
-lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_toTrailing___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__19;
+lean_object* l_Lean_Parser_dollarSymbol___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_unicodeSymbolFn___closed__1;
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_hexNumberFn___spec__2___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_RBNode_setBlack___rarg(lean_object*);
 lean_object* l_Lean_Parser_noFirstTokenInfo___elambda__2(lean_object*, lean_object*);
 lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkCategoryParserFnRef___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_chFn___rarg(uint32_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkCategoryParserFnRef___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_epsilonInfo___closed__2;
 lean_object* l_Lean_Parser_Parser_inhabited___closed__2;
 lean_object* l_Lean_Parser_mkCategoryParserFnExtension(lean_object*);
 lean_object* l_Lean_Parser_dollarSymbol___closed__2;
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Syntax_foldSepRevArgsM___spec__2(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawCh___elambda__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_rawCh___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_numberFnAux___closed__1;
-lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___closed__1;
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_foldArgsM___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_forSepArgsM___boxed(lean_object*);
@@ -981,13 +917,13 @@ uint8_t l_Lean_Syntax_isNone(lean_object*);
 lean_object* l_PersistentHashMap_insertAux___main___at_Lean_Parser_SyntaxNodeKindSet_insert___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, 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_mkParserOfConstantUnsafe___closed__7;
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__9;
+lean_object* l_Lean_Parser_identNoAntiquot___closed__3;
 lean_object* l_Lean_Parser_epsilonInfo___closed__1;
 lean_object* lean_io_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_find_x3f___at_Lean_Parser_addLeadingParser___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_6__nameLitAux___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
-lean_object* l_Lean_Parser_andthen___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_FileMap_Inhabited___closed__1;
 lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_mkOptionalNode___closed__1;
@@ -998,32 +934,32 @@ lean_object* l___private_Init_Lean_Parser_Parser_6__nameLitAux___closed__1;
 lean_object* l_String_trim(lean_object*);
 lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_forSepArgsM___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawFn(uint8_t);
-lean_object* l_Lean_Parser_charLitFn___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_compileParserDescr___main(lean_object*, uint8_t, lean_object*);
+lean_object* l_Lean_Parser_rawFn(lean_object*, uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_charLitFn___closed__1;
+lean_object* l_Lean_Parser_dollarSymbol___elambda__1___closed__4;
+lean_object* l_Lean_Parser_compileParserDescr___main(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_regBuiltinTermParserAttr(lean_object*);
-lean_object* l_Lean_Parser_nodeFn(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nodeFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_checkWsBeforeFn___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_optionalFn(uint8_t);
+lean_object* l_Lean_Parser_optionalFn(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nameLitFn___closed__1;
 uint8_t l_PersistentHashMap_containsAux___main___at___private_Init_Lean_Parser_Parser_17__addParserCategoryCore___spec__2(lean_object*, size_t, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
 lean_object* lean_array_pop(lean_object*);
 lean_object* l_Lean_Parser_TokenMap_insert___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon(uint8_t);
+lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon;
 lean_object* l_PersistentHashMap_containsAtAux___main___at_Lean_Parser_isValidSyntaxNodeKind___spec__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___closed__4;
 uint8_t l_Lean_isIdFirst(uint32_t);
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1___boxed(lean_object*);
 extern lean_object* l_Lean_registerEnvExtensionUnsafe___rarg___closed__3;
 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_Parser_ParserState_mkLongestNodeAlt(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_28__ParserAttribute_add___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_currLbp(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__7;
 lean_object* l_Lean_Parser_mkParserOfConstant(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___elambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhile1Fn(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__20;
 lean_object* lean_io_initializing(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*);
@@ -1033,97 +969,89 @@ lean_object* l_Lean_Syntax_forSepArgsM___rarg(lean_object*, lean_object*, lean_o
 lean_object* l_Lean_EnvExtension_getStateUnsafe___rarg(lean_object*, lean_object*);
 lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__2(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_9__pickNonNone(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux(uint8_t);
-lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nameLit___elambda__1(uint8_t);
+lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux(lean_object*, uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nameLit___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__6;
+lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__3;
+lean_object* l_Lean_Parser_rawIdent___closed__1;
 lean_object* l_Lean_Parser_parserExtension___elambda__1(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg___closed__1;
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg___boxed(lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_numLit___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkParserExtension___spec__3(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_getSyntaxNodeKinds(lean_object*);
 lean_object* l_Lean_Parser_addBuiltinTrailingParser(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_nameLitFn___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_string2basic(uint8_t, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquot(uint8_t, lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_fieldIdx___closed__7;
+lean_object* l_Lean_Parser_mkAntiquot(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Parser_optionaInfo___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_addParser___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_leadingNode(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_toErrorMsg(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Parser_SyntaxNodeKindSet_insert___spec__4(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__16;
 lean_object* l_Lean_mkStxLit(lean_object*, lean_object*, lean_object*);
 lean_object* l_RBNode_insert___at_Lean_Parser_TokenMap_insert___spec__2(lean_object*);
 lean_object* l_Lean_Parser_mkAtomicInfo___closed__1;
 lean_object* l_Lean_Parser_Error_toString___closed__3;
 lean_object* l_Lean_Parser_ParserState_stackSize(lean_object*);
-lean_object* l_Lean_Parser_fieldIdx(uint8_t);
+lean_object* l_Lean_Parser_fieldIdx;
+lean_object* l_Lean_Parser_Parser_inhabited___closed__3;
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_hexNumberFn___spec__3(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_identFn___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unicodeSymbolFn___boxed(lean_object*);
+lean_object* l_Lean_Parser_unicodeSymbolFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_forSepArgsM___spec__1(lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_25__ParserExtension_addImported___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAntiquot___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_categoryParserOfStackFn___closed__1;
-lean_object* l_Lean_Parser_manyFn(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_next___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkOptionalNode___closed__2;
-lean_object* l_Lean_Parser_Parser_inhabited___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Parser_inhabited___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgsM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_chFn___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_foldlM___at___private_Init_Lean_Parser_Parser_28__ParserAttribute_add___spec__2(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__24;
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Syntax_foldSepRevArgsM___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_sepBy1Info___elambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_epsilonInfo___elambda__2(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_1__expectedToString(lean_object*);
-lean_object* l_Lean_Parser_orelse(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_orelse(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_foldArgs___spec__1(lean_object*);
 uint8_t l_List_beq___main___at_Lean_Parser_Error_toString___spec__1(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unicodeSymbolFn(uint8_t);
+lean_object* l_Lean_Parser_unicodeSymbolFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_epsilonInfo___elambda__1(lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_hexNumberFn___spec__1___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unquotedSymbol___elambda__1(uint8_t, lean_object*);
 lean_object* l_Lean_Parser_categoryParserFnExtension;
 lean_object* l_Array_iterateMAux___main___at_Lean_Parser_getSyntaxNodeKinds___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_epsilonInfo___elambda__2___boxed(lean_object*);
 lean_object* l_List_eraseDupsAux___main___at_Lean_Parser_addLeadingParser___spec__6(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__8;
 lean_object* l_Lean_Syntax_forArgsM___boxed(lean_object*);
 lean_object* l_List_toStringAux___main___at_Lean_Parser_FirstTokens_toStr___spec__2(uint8_t, lean_object*);
 lean_object* l_List_toArrayAux___main___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_andthen(uint8_t, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_node(uint8_t, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_lookahead___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_dollarSymbol___elambda__1___closed__3;
+lean_object* l_Lean_Parser_andthen(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_node(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_forArgsM___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_16__throwParserCategoryAlreadyDefined(lean_object*);
+lean_object* l_Lean_Parser_stringToParserCoe___boxed(lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__13;
+lean_object* l_Lean_Parser_mkAntiquot___closed__8;
 uint8_t l_List_isEmpty___rarg(lean_object*);
 lean_object* l_Lean_Parser_quotedSymbolFn___closed__5;
 lean_object* l_Lean_Parser_unicodeSymbolInfo(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_identNoAntiquot(uint8_t);
+lean_object* l_Lean_Parser_identNoAntiquot;
 lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Init_Lean_Parser_Parser_28__ParserAttribute_add___spec__3(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkCategoryParserFnRef(lean_object*);
 lean_object* l_Lean_Parser_ParserState_keepPrevError___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_strAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_many1Fn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__23;
+lean_object* l_Lean_Parser_many1Fn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_beq___main___at_Lean_Parser_Error_toString___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkCategoryParserFnRef___closed__1;
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_identFnAux___main___spec__2(lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_insertAtCollisionNodeAux___main___at___private_Init_Lean_Parser_Parser_17__addParserCategoryCore___spec__5(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_usize_to_nat(size_t);
-lean_object* l_Lean_Parser_mkAntiquotAux___closed__21;
 lean_object* l___private_Init_Lean_Parser_Parser_29__registerParserAttributeImplBuilder___lambda__1(lean_object*);
 lean_object* l_Lean_Parser_mkTokenAndFixPos(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAtomicInfo___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_FirstTokens_toOptional(lean_object*);
-lean_object* l_Lean_Parser_checkWsBefore___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_checkWsBefore___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerAttributeImplBuilder(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkUnexpectedError(lean_object*, lean_object*);
 uint8_t l_UInt32_decLe(uint32_t, uint32_t);
@@ -1138,98 +1066,87 @@ lean_object* l___private_Init_Lean_Parser_Parser_29__registerParserAttributeImpl
 lean_object* l_Lean_Parser_currLbp___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkEOIError(lean_object*);
 lean_object* l_Lean_Parser_unicodeSymbolFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_ident___closed__3;
 lean_object* l_Lean_Parser_indexed___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawFn___boxed(lean_object*);
-lean_object* l_Lean_Parser_categoryParserOfStackFn(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_rawFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParserOfStackFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_insertAux___main___at___private_Init_Lean_Parser_Parser_17__addParserCategoryCore___spec__4(lean_object*, size_t, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_identFnAux___main___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldSepArgs(lean_object*);
 lean_object* l_Lean_Parser_ParserState_keepPrevError(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_checkWsBefore___elambda__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_checkWsBefore___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserFn_inhabited___rarg___boxed(lean_object*);
 lean_object* l_List_eraseDups___at_Lean_Parser_addLeadingParser___spec__5(lean_object*);
-lean_object* l_Lean_Parser_orelseFn___boxed(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_27__BuiltinParserAttribute_add(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 uint8_t l___private_Init_Lean_Parser_Parser_5__isIdFirstOrBeginEscape(uint32_t);
 lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__3;
 lean_object* l_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4(lean_object*);
 lean_object* l_List_toStringAux___main___at_Lean_Parser_FirstTokens_toStr___spec__2___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_setExpected___elambda__1(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_setExpected___elambda__1(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_17__addParserCategoryCore(lean_object*, lean_object*, lean_object*);
 lean_object* l_RBNode_insert___at_Lean_Parser_TokenMap_insert___spec__5___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at___private_Init_Lean_Parser_Parser_22__addTrailingParserAux___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_unicodeSymbolInfo___closed__1;
-lean_object* l_Lean_Parser_checkColGe___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_categoryParser___elambda__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_numLitFn___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unicodeSymbolFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__5;
 lean_object* l___private_Init_Lean_Data_Trie_2__insertAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_quotedSymbolFn___closed__3;
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_identFnAux___main___spec__1___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_charLitFn___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_foldArgs___rarg___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t lean_string_utf8_at_end(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_replaceLongest___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchStep___boxed(lean_object*);
+lean_object* l_Lean_Parser_longestMatchStep___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepRevArgsM___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_toString___closed__1;
 lean_object* l_Lean_Parser_regBuiltinTermParserAttr___closed__2;
 lean_object* l_PersistentHashMap_findAtAux___main___at_Lean_Parser_addLeadingParser___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___closed__2;
+lean_object* l_Lean_Parser_compileParserDescr___main___closed__4;
 lean_object* l___private_Init_Lean_Parser_Parser_7__tokenFnAux(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Parser_inhabited___closed__1;
-lean_object* l_Lean_Parser_checkWsBefore___elambda__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getTailInfo___main(lean_object*);
-lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_insertAtCollisionNodeAux___main___at_Lean_Parser_SyntaxNodeKindSet_insert___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_21__addTokenConfig___closed__2;
 extern lean_object* l_Lean_registerTagAttribute___lambda__4___closed__1;
 extern lean_object* l_Lean_initAttr;
-lean_object* l_Lean_Parser_identFn(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_identFn(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_decimalNumberFn___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3(lean_object*);
 lean_object* l_Lean_Parser_TokenConfig_HasBeq;
-lean_object* l_Lean_Parser_Parser_inhabited___boxed(lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Syntax_foldSepRevArgs___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_charLitNoAntiquot(uint8_t);
+lean_object* l_Lean_Parser_charLitNoAntiquot;
 lean_object* l_Lean_Parser_strLitFnAux___main___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkErrorStringWithPos(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_PersistentHashMap_insert___at_Lean_Parser_SyntaxNodeKindSet_insert___spec__1(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkAppStx___closed__1;
+lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__6;
 lean_object* l_Lean_Parser_unicodeSymbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_identEq___boxed(lean_object*, lean_object*);
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nameLit___elambda__1___closed__2;
 lean_object* l_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_manyAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_group___boxed(lean_object*, lean_object*);
 lean_object* l_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_many1Indent___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_sepBy1Info___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_rawIdent___elambda__1(uint8_t);
+lean_object* l_Lean_Parser_rawIdent___elambda__1(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_17__addParserCategoryCore___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_strLit(uint8_t);
-lean_object* l_Lean_Parser_rawIdentNoAntiquot___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_many1(uint8_t, lean_object*, uint8_t);
+lean_object* l_Lean_Parser_strLit;
+lean_object* l_Lean_Parser_many1(lean_object*, uint8_t);
 lean_object* l___private_Init_Lean_Parser_Parser_20__mergePrecendences___closed__3;
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_25__ParserExtension_addImported___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAtomicInfo___closed__2;
-lean_object* l_Lean_Parser_sepBy___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_trailingLoop___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_quotedSymbol___boxed(lean_object*);
+lean_object* l_Lean_Parser_sepBy___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_identNoAntiquot___closed__2;
+lean_object* l_Lean_Parser_strLit___closed__2;
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mergeErrors(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_isIdRest(uint32_t);
 lean_object* l_Lean_Parser_numberFnAux___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_numLit___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_parserExtension___elambda__3(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_fieldIdxFn(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_forArgsM___spec__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_compileParserDescr___main___closed__5;
 lean_object* l_Lean_Parser_mkIdent(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_nameLitKind___closed__1;
-lean_object* l_Lean_Parser_nameLit___elambda__1___boxed(lean_object*);
-lean_object* l_Lean_Parser_withPosition___boxed(lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_25__ParserExtension_addImported___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_isLitKind___boxed(lean_object*);
@@ -1237,12 +1154,13 @@ lean_object* l_IO_ofExcept___at_Lean_Parser_declareBuiltinParser___spec__1___box
 lean_object* l_Lean_Parser_registerParserCategory___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_22__addTrailingParserAux(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquot___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_mkAntiquot___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepByM___spec__1___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_longestMatchFnAux___main(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_longestMatchFnAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isIdent(lean_object*);
-lean_object* l_Lean_Parser_ParserFn_inhabited___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_andthenFn(uint8_t);
+lean_object* l_Lean_Parser_mkAntiquot___closed__1;
+lean_object* l_Lean_Parser_ParserFn_inhabited___boxed(lean_object*);
+lean_object* l_Lean_Parser_andthenFn(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Parser_isLitKind(lean_object* x_1) {
 _start:
 {
@@ -3361,12 +3279,12 @@ lean_inc(x_1);
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_ParserFn_inhabited(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_ParserFn_inhabited(lean_object* x_1) {
 _start:
 {
-lean_object* x_4; 
-x_4 = lean_alloc_closure((void*)(l_Lean_Parser_ParserFn_inhabited___rarg___boxed), 1, 0);
-return x_4;
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_ParserFn_inhabited___rarg___boxed), 1, 0);
+return x_2;
 }
 }
 lean_object* l_Lean_Parser_ParserFn_inhabited___rarg___boxed(lean_object* x_1) {
@@ -3378,16 +3296,13 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_ParserFn_inhabited___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_ParserFn_inhabited___boxed(lean_object* x_1) {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
+lean_object* x_2; 
+x_2 = l_Lean_Parser_ParserFn_inhabited(x_1);
 lean_dec(x_1);
-x_5 = l_Lean_Parser_ParserFn_inhabited(x_4, x_2, x_3);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_5;
+return x_2;
 }
 }
 lean_object* l_Lean_Parser_FirstTokens_seq(lean_object* x_1, lean_object* x_2) {
@@ -3841,11 +3756,11 @@ x_1 = l_Lean_Parser_FirstTokens_HasToString___closed__1;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Parser_inhabited___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Parser_inhabited___lambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_inc(x_3);
-return x_3;
+lean_inc(x_2);
+return x_2;
 }
 }
 lean_object* _init_l_Lean_Parser_Parser_inhabited___closed__1() {
@@ -3865,40 +3780,37 @@ lean_object* _init_l_Lean_Parser_Parser_inhabited___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Parser_inhabited___lambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Parser_inhabited___lambda__1___boxed), 2, 0);
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Parser_inhabited(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_Parser_inhabited___closed__3() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_3 = l_Lean_Parser_Parser_inhabited___closed__2;
-x_4 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_2 = l_Lean_Parser_Parser_inhabited___closed__2;
+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* l_Lean_Parser_Parser_inhabited___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* _init_l_Lean_Parser_Parser_inhabited() {
 _start:
 {
-lean_object* x_4; 
-x_4 = l_Lean_Parser_Parser_inhabited___lambda__1(x_1, x_2, x_3);
-lean_dec(x_3);
+lean_object* x_1; 
+x_1 = l_Lean_Parser_Parser_inhabited___closed__3;
+return x_1;
+}
+}
+lean_object* l_Lean_Parser_Parser_inhabited___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_Lean_Parser_Parser_inhabited___lambda__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_Parser_inhabited___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_Parser_inhabited(x_2);
 return x_3;
 }
 }
@@ -3972,59 +3884,7 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_toTrailing___lambda__1(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; lean_object* x_7; 
-x_6 = lean_ctor_get(x_1, 1);
-lean_inc(x_6);
-lean_dec(x_1);
-x_7 = lean_apply_3(x_6, x_2, x_4, x_5);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_toTrailing(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; lean_object* x_4; uint8_t x_5; 
-x_3 = lean_ctor_get(x_1, 0);
-lean_inc(x_3);
-lean_inc(x_1);
-x_4 = lean_alloc_closure((void*)(l_Lean_Parser_toTrailing___lambda__1___boxed), 5, 2);
-lean_closure_set(x_4, 0, x_1);
-lean_closure_set(x_4, 1, x_2);
-x_5 = !lean_is_exclusive(x_1);
-if (x_5 == 0)
-{
-lean_object* x_6; lean_object* x_7; 
-x_6 = lean_ctor_get(x_1, 1);
-lean_dec(x_6);
-x_7 = lean_ctor_get(x_1, 0);
-lean_dec(x_7);
-lean_ctor_set(x_1, 1, x_4);
-return x_1;
-}
-else
-{
-lean_object* x_8; 
-lean_dec(x_1);
-x_8 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_8, 0, x_3);
-lean_ctor_set(x_8, 1, x_4);
-return x_8;
-}
-}
-}
-lean_object* l_Lean_Parser_toTrailing___lambda__1___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_Parser_toTrailing___lambda__1(x_1, x_2, x_3, x_4, x_5);
-lean_dec(x_3);
-return x_6;
-}
-}
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object* x_1) {
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
@@ -4038,7 +3898,7 @@ lean_dec(x_4);
 return x_6;
 }
 }
-lean_object* _init_l_Lean_Parser_checkLeadingFn___closed__1() {
+lean_object* _init_l_Lean_Parser_checkStackTopFn___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -4046,54 +3906,53 @@ x_1 = lean_mk_string("invalid leading token");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_checkLeadingFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_checkStackTopFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_5);
-lean_dec(x_5);
-x_7 = lean_apply_1(x_1, x_6);
-x_8 = lean_unbox(x_7);
-lean_dec(x_7);
-if (x_8 == 0)
+lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_4);
+lean_dec(x_4);
+x_6 = lean_apply_1(x_1, x_5);
+x_7 = lean_unbox(x_6);
+lean_dec(x_6);
+if (x_7 == 0)
 {
-lean_object* x_9; lean_object* x_10; 
-x_9 = l_Lean_Parser_checkLeadingFn___closed__1;
-x_10 = l_Lean_Parser_ParserState_mkUnexpectedError(x_4, x_9);
-return x_10;
+lean_object* x_8; lean_object* x_9; 
+x_8 = l_Lean_Parser_checkStackTopFn___closed__1;
+x_9 = l_Lean_Parser_ParserState_mkUnexpectedError(x_3, x_8);
+return x_9;
 }
 else
 {
-return x_4;
+return x_3;
 }
 }
 }
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1___boxed(lean_object* x_1) {
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1___boxed(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_1);
+x_2 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_1);
 lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_checkLeadingFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_checkStackTopFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l_Lean_Parser_checkLeadingFn(x_1, x_2, x_3, x_4);
-lean_dec(x_3);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_checkStackTopFn(x_1, x_2, x_3);
 lean_dec(x_2);
-return x_5;
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_checkLeading(lean_object* x_1) {
+lean_object* l_Lean_Parser_checkStackTop(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkLeadingFn___boxed), 4, 1);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkStackTopFn___boxed), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 x_3 = l_Lean_Parser_epsilonInfo;
 x_4 = lean_alloc_ctor(0, 2, 0);
@@ -4102,7 +3961,7 @@ lean_ctor_set(x_4, 1, x_2);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_andthenAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_andthenFn(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; 
@@ -4125,49 +3984,6 @@ return x_5;
 }
 }
 }
-lean_object* l_Lean_Parser_andthenFn___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; lean_object* x_7; 
-lean_inc(x_4);
-lean_inc(x_3);
-x_6 = lean_apply_3(x_1, x_3, x_4, x_5);
-x_7 = lean_ctor_get(x_6, 3);
-lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
-{
-lean_object* x_8; 
-x_8 = lean_apply_3(x_2, x_3, x_4, x_6);
-return x_8;
-}
-else
-{
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_6;
-}
-}
-}
-lean_object* l_Lean_Parser_andthenFn(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_andthenFn___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_andthenFn(x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_Parser_andthenInfo___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -4218,91 +4034,70 @@ lean_ctor_set(x_12, 2, x_11);
 return x_12;
 }
 }
-lean_object* l_Lean_Parser_andthen(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_andthen(lean_object* x_1, lean_object* x_2) {
 _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; 
+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; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
 x_4 = lean_ctor_get(x_2, 0);
 lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 0);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_andthenInfo(x_4, x_5);
+x_5 = l_Lean_Parser_andthenInfo(x_3, x_4);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+lean_dec(x_1);
 x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
 lean_dec(x_2);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_dec(x_3);
-x_9 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_9, 0, x_7);
-lean_closure_set(x_9, 1, x_8);
-x_10 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_10, 0, x_6);
-lean_ctor_set(x_10, 1, x_9);
-return x_10;
+x_8 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_8, 0, x_6);
+lean_closure_set(x_8, 1, x_7);
+x_9 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_9, 0, x_5);
+lean_ctor_set(x_9, 1, x_8);
+return x_9;
 }
 }
-lean_object* l_Lean_Parser_andthen___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* _init_l_Lean_Parser_hashAndthen___closed__1() {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_Parser_andthen(x_4, x_2, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_andthen), 2, 0);
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_hashAndthen(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_hashAndthen() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthen___boxed), 3, 1);
-lean_closure_set(x_3, 0, x_2);
-return x_3;
+lean_object* x_1; 
+x_1 = l_Lean_Parser_hashAndthen___closed__1;
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_hashAndthen___boxed(lean_object* x_1) {
+lean_object* l_Lean_Parser_nodeFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_hashAndthen(x_2);
-return x_3;
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_2, x_3, x_4);
+x_8 = l_Lean_Parser_ParserState_mkNode(x_7, x_1, x_6);
+return x_8;
 }
 }
-lean_object* l_Lean_Parser_nodeFn(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_trailingNodeFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = lean_apply_3(x_3, x_4, x_5, x_6);
-if (x_1 == 0)
-{
-lean_object* x_10; 
-x_10 = l_Lean_Parser_ParserState_mkNode(x_9, x_2, x_8);
-return x_10;
-}
-else
-{
-lean_object* x_11; 
-x_11 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_2, x_8);
-lean_dec(x_8);
-return x_11;
-}
-}
-}
-lean_object* l_Lean_Parser_nodeFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
-_start:
-{
-uint8_t x_7; lean_object* x_8; 
-x_7 = lean_unbox(x_1);
-lean_dec(x_1);
-x_8 = l_Lean_Parser_nodeFn(x_7, x_2, x_3, x_4, x_5, x_6);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_2, x_3, x_4);
+x_8 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_1, x_6);
+lean_dec(x_6);
 return x_8;
 }
 }
@@ -4367,74 +4162,30 @@ return x_9;
 }
 }
 }
-lean_object* l_Lean_Parser_node(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_node(lean_object* x_1, lean_object* x_2) {
 _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; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-lean_inc(x_2);
-x_5 = l_Lean_Parser_nodeInfo(x_2, x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-lean_dec(x_3);
-x_7 = lean_box(x_1);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_8, 0, x_7);
-lean_closure_set(x_8, 1, x_2);
-lean_closure_set(x_8, 2, x_6);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_5);
-lean_ctor_set(x_9, 1, x_8);
-return x_9;
-}
-}
-lean_object* l_Lean_Parser_node___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_Parser_node(x_4, x_2, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_group(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-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_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-x_4 = l_Lean_nullKind;
-x_5 = l_Lean_Parser_nodeInfo(x_4, x_3);
-x_6 = lean_ctor_get(x_2, 1);
-lean_inc(x_6);
+lean_inc(x_1);
+x_4 = l_Lean_Parser_nodeInfo(x_1, x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
 lean_dec(x_2);
-x_7 = lean_box(x_1);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_8, 0, x_7);
-lean_closure_set(x_8, 1, x_4);
-lean_closure_set(x_8, 2, x_6);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_5);
-lean_ctor_set(x_9, 1, x_8);
-return x_9;
-}
-}
-lean_object* l_Lean_Parser_group___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_group(x_3, x_2);
-return x_4;
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+lean_closure_set(x_6, 0, x_1);
+lean_closure_set(x_6, 1, x_5);
+x_7 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_7, 0, x_4);
+lean_ctor_set(x_7, 1, x_6);
+return x_7;
 }
 }
 lean_object* l_Lean_Parser_leadingNode(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
 lean_inc(x_1);
@@ -4442,22 +4193,19 @@ x_4 = l_Lean_Parser_nodeInfo(x_1, x_3);
 x_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
 lean_dec(x_2);
-x_6 = 0;
-x_7 = lean_box(x_6);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_8, 0, x_7);
-lean_closure_set(x_8, 1, x_1);
-lean_closure_set(x_8, 2, x_5);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_4);
-lean_ctor_set(x_9, 1, x_8);
-return x_9;
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+lean_closure_set(x_6, 0, x_1);
+lean_closure_set(x_6, 1, x_5);
+x_7 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_7, 0, x_4);
+lean_ctor_set(x_7, 1, x_6);
+return x_7;
 }
 }
 lean_object* l_Lean_Parser_trailingNode(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
 lean_inc(x_1);
@@ -4465,16 +4213,33 @@ x_4 = l_Lean_Parser_nodeInfo(x_1, x_3);
 x_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
 lean_dec(x_2);
-x_6 = 1;
-x_7 = lean_box(x_6);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_8, 0, x_7);
-lean_closure_set(x_8, 1, x_1);
-lean_closure_set(x_8, 2, x_5);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_4);
-lean_ctor_set(x_9, 1, x_8);
-return x_9;
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_trailingNodeFn), 4, 2);
+lean_closure_set(x_6, 0, x_1);
+lean_closure_set(x_6, 1, x_5);
+x_7 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_7, 0, x_4);
+lean_ctor_set(x_7, 1, x_6);
+return x_7;
+}
+}
+lean_object* l_Lean_Parser_group(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_nullKind;
+x_4 = l_Lean_Parser_nodeInfo(x_3, x_2);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+lean_closure_set(x_6, 0, x_3);
+lean_closure_set(x_6, 1, x_5);
+x_7 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_7, 0, x_4);
+lean_ctor_set(x_7, 1, x_6);
+return x_7;
 }
 }
 lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
@@ -4603,82 +4368,61 @@ lean_dec(x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_orelseFn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_orelseFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
-lean_inc(x_4);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_4, 1);
+lean_inc(x_7);
 lean_inc(x_3);
-x_9 = lean_apply_3(x_1, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_1, x_3, x_4);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_4);
+lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_apply_2(x_2, x_3, x_13);
+x_15 = l_Lean_Parser_mergeOrElseErrors(x_14, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_apply_3(x_2, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
+return x_15;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_orelseFn(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_orelseFn___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_orelseFn(x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_Parser_orelseInfo___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -4729,58 +4473,44 @@ lean_ctor_set(x_12, 2, x_11);
 return x_12;
 }
 }
-lean_object* l_Lean_Parser_orelse(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_orelse(lean_object* x_1, lean_object* x_2) {
 _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; 
+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; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
 x_4 = lean_ctor_get(x_2, 0);
 lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 0);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_orelseInfo(x_4, x_5);
+x_5 = l_Lean_Parser_orelseInfo(x_3, x_4);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+lean_dec(x_1);
 x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
 lean_dec(x_2);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_dec(x_3);
-x_9 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 2);
-lean_closure_set(x_9, 0, x_7);
-lean_closure_set(x_9, 1, x_8);
-x_10 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_10, 0, x_6);
-lean_ctor_set(x_10, 1, x_9);
-return x_10;
+x_8 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn), 4, 2);
+lean_closure_set(x_8, 0, x_6);
+lean_closure_set(x_8, 1, x_7);
+x_9 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_9, 0, x_5);
+lean_ctor_set(x_9, 1, x_8);
+return x_9;
 }
 }
-lean_object* l_Lean_Parser_orelse___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* _init_l_Lean_Parser_hashOrelse___closed__1() {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_Parser_orelse(x_4, x_2, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_orelse), 2, 0);
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_hashOrelse(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_hashOrelse() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_orelse___boxed), 3, 1);
-lean_closure_set(x_3, 0, x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_hashOrelse___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_hashOrelse(x_2);
-return x_3;
+lean_object* x_1; 
+x_1 = l_Lean_Parser_hashOrelse___closed__1;
+return x_1;
 }
 }
 lean_object* l_Lean_Parser_noFirstTokenInfo___elambda__1(lean_object* x_1, lean_object* x_2) {
@@ -4822,186 +4552,140 @@ lean_ctor_set(x_5, 2, x_4);
 return x_5;
 }
 }
-lean_object* l_Lean_Parser_tryFn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_tryFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_4, 0);
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+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_4, 1);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_8 = lean_apply_3(x_1, x_2, x_3, x_4);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
+x_6 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_7 = lean_apply_2(x_1, x_2, x_3);
+x_8 = lean_ctor_get(x_7, 3);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
 {
-lean_dec(x_7);
 lean_dec(x_6);
-return x_8;
-}
-else
-{
-uint8_t x_10; 
-x_10 = !lean_is_exclusive(x_8);
-if (x_10 == 0)
-{
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-x_11 = lean_ctor_get(x_8, 0);
-x_12 = lean_ctor_get(x_8, 3);
-lean_dec(x_12);
-x_13 = lean_ctor_get(x_8, 1);
-lean_dec(x_13);
-x_14 = l_Array_shrink___main___rarg(x_11, x_7);
-lean_dec(x_7);
-lean_ctor_set(x_8, 1, x_6);
-lean_ctor_set(x_8, 0, x_14);
-return x_8;
-}
-else
-{
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_8, 0);
-x_16 = lean_ctor_get(x_8, 2);
-lean_inc(x_16);
-lean_inc(x_15);
-lean_dec(x_8);
-x_17 = l_Array_shrink___main___rarg(x_15, x_7);
-lean_dec(x_7);
-x_18 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_6);
-lean_ctor_set(x_18, 2, x_16);
-lean_ctor_set(x_18, 3, x_9);
-return x_18;
-}
-}
-}
-}
-lean_object* l_Lean_Parser_tryFn(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_tryFn___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_tryFn(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_try(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = !lean_is_exclusive(x_2);
-if (x_3 == 0)
-{
-lean_object* x_4; lean_object* x_5; 
-x_4 = lean_ctor_get(x_2, 1);
-x_5 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
-lean_closure_set(x_5, 0, x_4);
-lean_ctor_set(x_2, 1, x_5);
-return x_2;
-}
-else
-{
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_6 = lean_ctor_get(x_2, 0);
-x_7 = lean_ctor_get(x_2, 1);
-lean_inc(x_7);
-lean_inc(x_6);
-lean_dec(x_2);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
-lean_closure_set(x_8, 0, x_7);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_6);
-lean_ctor_set(x_9, 1, x_8);
-return x_9;
-}
-}
-}
-lean_object* l_Lean_Parser_try___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_try(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_optionalFn___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; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
 lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-x_8 = lean_apply_3(x_1, x_2, x_3, x_4);
-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_dec(x_7);
-x_10 = l_Lean_nullKind;
-x_11 = l_Lean_Parser_ParserState_mkNode(x_8, x_10, x_6);
-return x_11;
+return x_7;
 }
 else
 {
-lean_object* x_12; uint8_t x_13; 
-lean_dec(x_9);
-x_12 = lean_ctor_get(x_8, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_7);
+uint8_t x_9; 
+x_9 = !lean_is_exclusive(x_7);
+if (x_9 == 0)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_10 = lean_ctor_get(x_7, 0);
+x_11 = lean_ctor_get(x_7, 3);
+lean_dec(x_11);
+x_12 = lean_ctor_get(x_7, 1);
 lean_dec(x_12);
-if (x_13 == 0)
-{
-lean_object* x_14; lean_object* x_15; 
-lean_dec(x_7);
-x_14 = l_Lean_nullKind;
-x_15 = l_Lean_Parser_ParserState_mkNode(x_8, x_14, x_6);
-return x_15;
+x_13 = l_Array_shrink___main___rarg(x_10, x_6);
+lean_dec(x_6);
+lean_ctor_set(x_7, 1, x_5);
+lean_ctor_set(x_7, 0, x_13);
+return x_7;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_16 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-x_17 = l_Lean_nullKind;
-x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_6);
-return x_18;
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+x_14 = lean_ctor_get(x_7, 0);
+x_15 = lean_ctor_get(x_7, 2);
+lean_inc(x_15);
+lean_inc(x_14);
+lean_dec(x_7);
+x_16 = l_Array_shrink___main___rarg(x_14, x_6);
+lean_dec(x_6);
+x_17 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_17, 0, x_16);
+lean_ctor_set(x_17, 1, x_5);
+lean_ctor_set(x_17, 2, x_15);
+lean_ctor_set(x_17, 3, x_8);
+return x_17;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_optionalFn(uint8_t x_1) {
+lean_object* l_Lean_Parser_try(lean_object* x_1) {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn___rarg), 4, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_optionalFn___boxed(lean_object* x_1) {
-_start:
+uint8_t x_2; 
+x_2 = !lean_is_exclusive(x_1);
+if (x_2 == 0)
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
+lean_object* x_3; lean_object* x_4; 
+x_3 = lean_ctor_get(x_1, 1);
+x_4 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn), 3, 1);
+lean_closure_set(x_4, 0, x_3);
+lean_ctor_set(x_1, 1, x_4);
+return x_1;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_1, 0);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+lean_inc(x_5);
 lean_dec(x_1);
-x_3 = l_Lean_Parser_optionalFn(x_2);
-return x_3;
+x_7 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn), 3, 1);
+lean_closure_set(x_7, 0, x_6);
+x_8 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_8, 0, x_5);
+lean_ctor_set(x_8, 1, x_7);
+return x_8;
+}
+}
+}
+lean_object* l_Lean_Parser_optionalFn(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; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_6 = lean_ctor_get(x_3, 1);
+lean_inc(x_6);
+x_7 = lean_apply_2(x_1, x_2, x_3);
+x_8 = lean_ctor_get(x_7, 3);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_6);
+x_9 = l_Lean_nullKind;
+x_10 = l_Lean_Parser_ParserState_mkNode(x_7, x_9, x_5);
+return x_10;
+}
+else
+{
+lean_object* x_11; uint8_t x_12; 
+lean_dec(x_8);
+x_11 = lean_ctor_get(x_7, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_6);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_object* x_13; lean_object* x_14; 
+lean_dec(x_6);
+x_13 = l_Lean_nullKind;
+x_14 = l_Lean_Parser_ParserState_mkNode(x_7, x_13, x_5);
+return x_14;
+}
+else
+{
+lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+x_15 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
+x_16 = l_Lean_nullKind;
+x_17 = l_Lean_Parser_ParserState_mkNode(x_15, x_16, x_5);
+return x_17;
+}
+}
 }
 }
 lean_object* l_Lean_Parser_optionaInfo___elambda__1(lean_object* x_1, lean_object* x_2) {
@@ -5047,122 +4731,84 @@ lean_ctor_set(x_6, 2, x_5);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_optional(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_optional(lean_object* x_1) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_3 = lean_ctor_get(x_2, 0);
-lean_inc(x_3);
-x_4 = l_Lean_Parser_optionaInfo(x_3);
-x_5 = lean_ctor_get(x_2, 1);
-lean_inc(x_5);
-lean_dec(x_2);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn___rarg), 4, 1);
-lean_closure_set(x_6, 0, x_5);
-x_7 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_7, 0, x_4);
-lean_ctor_set(x_7, 1, x_6);
+lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_optionaInfo(x_2);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn), 3, 1);
+lean_closure_set(x_5, 0, x_4);
+x_6 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_6, 0, x_3);
+lean_ctor_set(x_6, 1, x_5);
+return x_6;
+}
+}
+lean_object* l_Lean_Parser_lookaheadFn(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; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_6 = lean_ctor_get(x_3, 1);
+lean_inc(x_6);
+x_7 = lean_apply_2(x_1, x_2, x_3);
+x_8 = lean_ctor_get(x_7, 3);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
+{
+lean_object* x_9; 
+x_9 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
+lean_dec(x_5);
+return x_9;
+}
+else
+{
+lean_dec(x_8);
+lean_dec(x_6);
+lean_dec(x_5);
 return x_7;
 }
 }
-lean_object* l_Lean_Parser_optional___boxed(lean_object* x_1, lean_object* x_2) {
+}
+lean_object* l_Lean_Parser_lookahead(lean_object* x_1) {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_optional(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_lookaheadFn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
+uint8_t x_2; 
+x_2 = !lean_is_exclusive(x_1);
+if (x_2 == 0)
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-x_8 = lean_apply_3(x_1, x_2, x_3, x_4);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
-{
-lean_object* x_10; 
-x_10 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_10;
+lean_object* x_3; lean_object* x_4; 
+x_3 = lean_ctor_get(x_1, 1);
+x_4 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn), 3, 1);
+lean_closure_set(x_4, 0, x_3);
+lean_ctor_set(x_1, 1, x_4);
+return x_1;
 }
 else
 {
-lean_dec(x_9);
-lean_dec(x_7);
-lean_dec(x_6);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_1, 0);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_dec(x_1);
+x_7 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn), 3, 1);
+lean_closure_set(x_7, 0, x_6);
+x_8 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_8, 0, x_5);
+lean_ctor_set(x_8, 1, x_7);
 return x_8;
 }
 }
 }
-lean_object* l_Lean_Parser_lookaheadFn(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn___rarg), 4, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_lookaheadFn___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_lookaheadFn(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_lookahead(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = !lean_is_exclusive(x_2);
-if (x_3 == 0)
-{
-lean_object* x_4; lean_object* x_5; 
-x_4 = lean_ctor_get(x_2, 1);
-x_5 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn___rarg), 4, 1);
-lean_closure_set(x_5, 0, x_4);
-lean_ctor_set(x_2, 1, x_5);
-return x_2;
-}
-else
-{
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_6 = lean_ctor_get(x_2, 0);
-x_7 = lean_ctor_get(x_2, 1);
-lean_inc(x_7);
-lean_inc(x_6);
-lean_dec(x_2);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn___rarg), 4, 1);
-lean_closure_set(x_8, 0, x_7);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_6);
-lean_ctor_set(x_9, 1, x_8);
-return x_9;
-}
-}
-}
-lean_object* l_Lean_Parser_lookahead___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_lookahead(x_3, x_2);
-return x_4;
-}
-}
 lean_object* _init_l_Lean_Parser_manyAux___main___closed__1() {
 _start:
 {
@@ -5171,218 +4817,312 @@ x_1 = lean_mk_string("invalid 'many' parser combinator application, parser did n
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_manyAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_4 = lean_ctor_get(x_3, 0);
 lean_inc(x_4);
-lean_inc(x_3);
-x_9 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
+x_5 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_6 = lean_ctor_get(x_3, 1);
+lean_inc(x_6);
+lean_inc(x_1);
+lean_inc(x_2);
+x_7 = lean_apply_2(x_1, x_2, x_3);
+x_8 = lean_ctor_get(x_7, 3);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
 {
-lean_object* x_11; uint8_t x_12; 
-lean_dec(x_7);
-x_11 = lean_ctor_get(x_9, 1);
-lean_inc(x_11);
-x_12 = lean_nat_dec_eq(x_8, x_11);
-lean_dec(x_11);
-lean_dec(x_8);
-if (x_12 == 0)
+lean_object* x_9; uint8_t x_10; 
+lean_dec(x_5);
+x_9 = lean_ctor_get(x_7, 1);
+lean_inc(x_9);
+x_10 = lean_nat_dec_eq(x_6, x_9);
+lean_dec(x_9);
+lean_dec(x_6);
+if (x_10 == 0)
 {
-x_5 = x_9;
+x_3 = x_7;
 goto _start;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; 
-lean_dec(x_4);
-lean_dec(x_3);
+lean_object* x_12; lean_object* x_13; 
 lean_dec(x_2);
-x_14 = l_Lean_Parser_manyAux___main___closed__1;
-x_15 = l_Lean_Parser_ParserState_mkUnexpectedError(x_9, x_14);
-return x_15;
+lean_dec(x_1);
+x_12 = l_Lean_Parser_manyAux___main___closed__1;
+x_13 = l_Lean_Parser_ParserState_mkUnexpectedError(x_7, x_12);
+return x_13;
 }
 }
 else
 {
-lean_object* x_16; uint8_t x_17; 
-lean_dec(x_10);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-x_16 = lean_ctor_get(x_9, 1);
-lean_inc(x_16);
-x_17 = lean_nat_dec_eq(x_8, x_16);
-lean_dec(x_16);
-if (x_17 == 0)
-{
+lean_object* x_14; uint8_t x_15; 
 lean_dec(x_8);
-lean_dec(x_7);
-return x_9;
+lean_dec(x_2);
+lean_dec(x_1);
+x_14 = lean_ctor_get(x_7, 1);
+lean_inc(x_14);
+x_15 = lean_nat_dec_eq(x_6, x_14);
+lean_dec(x_14);
+if (x_15 == 0)
+{
+lean_dec(x_6);
+lean_dec(x_5);
+return x_7;
 }
 else
 {
-lean_object* x_18; 
-x_18 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-return x_18;
+lean_object* x_16; 
+x_16 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
+lean_dec(x_5);
+return x_16;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_manyAux(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l_Lean_Parser_manyAux___main(x_6, x_2, x_3, x_4, x_5);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_manyAux(uint8_t 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_Parser_manyAux___main(x_1, x_2, x_3, x_4, x_5);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_manyAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l_Lean_Parser_manyAux(x_6, x_2, x_3, x_4, x_5);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_manyFn(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = l_Lean_Parser_manyAux___main(x_1, x_2, x_3, x_4, x_5);
-x_9 = l_Lean_nullKind;
-x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7);
-return x_10;
-}
-}
-lean_object* l_Lean_Parser_manyFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l_Lean_Parser_manyFn(x_6, x_2, x_3, x_4, x_5);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_many(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_3 = lean_ctor_get(x_2, 0);
-lean_inc(x_3);
-x_4 = l_Lean_Parser_noFirstTokenInfo(x_3);
-x_5 = lean_ctor_get(x_2, 1);
-lean_inc(x_5);
-lean_dec(x_2);
-x_6 = lean_box(x_1);
-x_7 = lean_alloc_closure((void*)(l_Lean_Parser_manyFn___boxed), 5, 2);
-lean_closure_set(x_7, 0, x_6);
-lean_closure_set(x_7, 1, x_5);
-x_8 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_8, 0, x_4);
-lean_ctor_set(x_8, 1, x_7);
-return x_8;
-}
-}
-lean_object* l_Lean_Parser_many___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_many(x_3, x_2);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_manyAux___main(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_many1Fn(uint8_t x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_manyFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-lean_inc(x_2);
-lean_inc(x_5);
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_4 = lean_ctor_get(x_3, 0);
 lean_inc(x_4);
-x_9 = lean_apply_3(x_2, x_4, x_5, x_6);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
+x_5 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_6 = l_Lean_Parser_manyAux___main(x_1, x_2, x_3);
+x_7 = l_Lean_nullKind;
+x_8 = l_Lean_Parser_ParserState_mkNode(x_6, x_7, x_5);
+return x_8;
+}
+}
+lean_object* l_Lean_Parser_many(lean_object* x_1) {
+_start:
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_11 = l_Lean_Parser_manyAux___main(x_1, x_2, x_4, x_5, x_9);
-x_12 = lean_ctor_get(x_11, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
+lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_noFirstTokenInfo(x_2);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_alloc_closure((void*)(l_Lean_Parser_manyFn), 3, 1);
+lean_closure_set(x_5, 0, x_4);
+x_6 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_6, 0, x_3);
+lean_ctor_set(x_6, 1, x_5);
+return x_6;
+}
+}
+lean_object* l_Lean_Parser_many1Fn(lean_object* x_1, uint8_t 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; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+lean_inc(x_1);
+lean_inc(x_3);
+x_7 = lean_apply_2(x_1, x_3, x_4);
+x_8 = lean_ctor_get(x_7, 3);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_9 = l_Lean_Parser_manyAux___main(x_1, x_3, x_7);
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+x_11 = lean_array_get_size(x_10);
+lean_dec(x_10);
+x_12 = lean_nat_sub(x_11, x_6);
+lean_dec(x_11);
+x_13 = lean_unsigned_to_nat(1u);
+x_14 = lean_nat_dec_eq(x_12, x_13);
 lean_dec(x_12);
-x_14 = lean_nat_sub(x_13, x_8);
-lean_dec(x_13);
-x_15 = lean_unsigned_to_nat(1u);
-x_16 = lean_nat_dec_eq(x_14, x_15);
-lean_dec(x_14);
-if (x_16 == 0)
+if (x_14 == 0)
+{
+lean_object* x_15; lean_object* x_16; 
+x_15 = l_Lean_nullKind;
+x_16 = l_Lean_Parser_ParserState_mkNode(x_9, x_15, x_6);
+return x_16;
+}
+else
+{
+if (x_2 == 0)
 {
 lean_object* x_17; lean_object* x_18; 
 x_17 = l_Lean_nullKind;
-x_18 = l_Lean_Parser_ParserState_mkNode(x_11, x_17, x_8);
+x_18 = l_Lean_Parser_ParserState_mkNode(x_9, x_17, x_6);
 return x_18;
 }
 else
 {
-if (x_3 == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = l_Lean_nullKind;
-x_20 = l_Lean_Parser_ParserState_mkNode(x_11, x_19, x_8);
-return x_20;
+lean_dec(x_6);
+return x_9;
+}
+}
 }
 else
 {
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; 
 lean_dec(x_8);
+lean_dec(x_3);
+lean_dec(x_1);
+x_19 = lean_ctor_get(x_7, 0);
+lean_inc(x_19);
+x_20 = lean_array_get_size(x_19);
+lean_dec(x_19);
+x_21 = lean_nat_sub(x_20, x_6);
+lean_dec(x_20);
+x_22 = lean_unsigned_to_nat(1u);
+x_23 = lean_nat_dec_eq(x_21, x_22);
+lean_dec(x_21);
+if (x_23 == 0)
+{
+lean_object* x_24; lean_object* x_25; 
+x_24 = l_Lean_nullKind;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_7, x_24, x_6);
+return x_25;
+}
+else
+{
+if (x_2 == 0)
+{
+lean_object* x_26; lean_object* x_27; 
+x_26 = l_Lean_nullKind;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_7, x_26, x_6);
+return x_27;
+}
+else
+{
+lean_dec(x_6);
+return x_7;
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_many1Fn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; lean_object* x_6; 
+x_5 = lean_unbox(x_2);
+lean_dec(x_2);
+x_6 = l_Lean_Parser_many1Fn(x_1, x_5, x_3, x_4);
+return x_6;
+}
+}
+lean_object* l_Lean_Parser_many1(lean_object* x_1, uint8_t x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = !lean_is_exclusive(x_1);
+if (x_3 == 0)
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = lean_ctor_get(x_1, 1);
+x_5 = lean_box(x_2);
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 4, 2);
+lean_closure_set(x_6, 0, x_4);
+lean_closure_set(x_6, 1, x_5);
+lean_ctor_set(x_1, 1, x_6);
+return x_1;
+}
+else
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_7 = lean_ctor_get(x_1, 0);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+lean_inc(x_7);
+lean_dec(x_1);
+x_9 = lean_box(x_2);
+x_10 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 4, 2);
+lean_closure_set(x_10, 0, x_8);
+lean_closure_set(x_10, 1, x_9);
+x_11 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_11, 0, x_7);
+lean_ctor_set(x_11, 1, x_10);
 return x_11;
 }
 }
 }
+lean_object* l_Lean_Parser_many1___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = lean_unbox(x_2);
+lean_dec(x_2);
+x_4 = l_Lean_Parser_many1(x_1, x_3);
+return x_4;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_8, 0);
+lean_inc(x_9);
+x_10 = lean_array_get_size(x_9);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+lean_inc(x_1);
+lean_inc(x_7);
+x_12 = lean_apply_2(x_1, x_7, x_8);
+x_13 = lean_ctor_get(x_12, 3);
+lean_inc(x_13);
+if (lean_obj_tag(x_13) == 0)
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+lean_dec(x_11);
+lean_dec(x_10);
+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 = lean_ctor_get(x_12, 1);
+lean_inc(x_16);
+lean_inc(x_2);
+lean_inc(x_7);
+x_17 = lean_apply_2(x_2, x_7, x_12);
+x_18 = lean_ctor_get(x_17, 3);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
+{
+lean_dec(x_16);
+lean_dec(x_15);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_17;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
+}
 else
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-lean_dec(x_10);
-lean_dec(x_5);
-lean_dec(x_4);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+lean_dec(x_18);
+lean_dec(x_7);
 lean_dec(x_2);
-x_21 = lean_ctor_get(x_9, 0);
+lean_dec(x_1);
+x_20 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
+lean_dec(x_15);
+x_21 = lean_ctor_get(x_20, 0);
 lean_inc(x_21);
 x_22 = lean_array_get_size(x_21);
 lean_dec(x_21);
-x_23 = lean_nat_sub(x_22, x_8);
+x_23 = lean_nat_sub(x_22, x_4);
 lean_dec(x_22);
 x_24 = lean_unsigned_to_nat(1u);
 x_25 = lean_nat_dec_eq(x_23, x_24);
@@ -5391,331 +5131,170 @@ if (x_25 == 0)
 {
 lean_object* x_26; lean_object* x_27; 
 x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_9, x_26, x_8);
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_4);
 return x_27;
 }
 else
 {
-if (x_3 == 0)
+if (x_5 == 0)
 {
 lean_object* x_28; lean_object* x_29; 
 x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_9, x_28, x_8);
+x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_4);
 return x_29;
 }
 else
 {
-lean_dec(x_8);
+lean_dec(x_4);
+return x_20;
+}
+}
+}
+}
+else
+{
+lean_dec(x_13);
+lean_dec(x_7);
+lean_dec(x_2);
+lean_dec(x_1);
+if (x_6 == 0)
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_dec(x_11);
+lean_dec(x_10);
+x_30 = lean_box(0);
+x_31 = l_Lean_Parser_ParserState_pushSyntax(x_12, x_30);
+x_32 = l_Lean_nullKind;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_4);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_34 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_11);
+lean_dec(x_10);
+x_35 = lean_ctor_get(x_34, 0);
+lean_inc(x_35);
+x_36 = lean_array_get_size(x_35);
+lean_dec(x_35);
+x_37 = lean_nat_sub(x_36, x_4);
+lean_dec(x_36);
+x_38 = lean_unsigned_to_nat(2u);
+x_39 = lean_nat_dec_eq(x_37, x_38);
+lean_dec(x_37);
+if (x_39 == 0)
+{
+lean_object* x_40; lean_object* x_41; 
+x_40 = l_Lean_nullKind;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_34, x_40, x_4);
+return x_41;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_42; lean_object* x_43; 
+x_42 = l_Lean_nullKind;
+x_43 = l_Lean_Parser_ParserState_mkNode(x_34, x_42, x_4);
+return x_43;
+}
+else
+{
+lean_object* x_44; 
+lean_dec(x_4);
+x_44 = l_Lean_Parser_ParserState_popSyntax(x_34);
+return x_44;
+}
+}
+}
+}
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
+x_9 = lean_unbox(x_3);
+lean_dec(x_3);
+x_10 = lean_unbox(x_5);
+lean_dec(x_5);
+x_11 = lean_unbox(x_6);
+lean_dec(x_6);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+return x_12;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+lean_object* x_9; 
+x_9 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
 return x_9;
 }
 }
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
+x_9 = lean_unbox(x_3);
+lean_dec(x_3);
+x_10 = lean_unbox(x_5);
+lean_dec(x_5);
+x_11 = lean_unbox(x_6);
+lean_dec(x_6);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+return x_12;
 }
 }
+lean_object* l_Lean_Parser_sepByFn(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; lean_object* x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+x_7 = lean_array_get_size(x_6);
+lean_dec(x_6);
+x_8 = 0;
+x_9 = 1;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(x_2, x_3, x_1, x_7, x_8, x_9, x_4, x_5);
+return x_10;
 }
-lean_object* l_Lean_Parser_many1Fn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+}
+lean_object* l_Lean_Parser_sepByFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+uint8_t x_6; lean_object* x_7; 
+x_6 = lean_unbox(x_1);
+lean_dec(x_1);
+x_7 = l_Lean_Parser_sepByFn(x_6, x_2, x_3, x_4, x_5);
+return x_7;
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn(uint8_t x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(x_2, x_3, x_1, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; uint8_t x_8; lean_object* x_9; 
 x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_8 = lean_unbox(x_3);
-lean_dec(x_3);
-x_9 = l_Lean_Parser_many1Fn(x_7, x_2, x_8, x_4, x_5, x_6);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn(x_7, x_2, x_3, x_8, x_5, x_6);
 return x_9;
 }
 }
-lean_object* l_Lean_Parser_many1(uint8_t x_1, lean_object* x_2, uint8_t x_3) {
-_start:
-{
-uint8_t x_4; 
-x_4 = !lean_is_exclusive(x_2);
-if (x_4 == 0)
-{
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_5 = lean_ctor_get(x_2, 1);
-x_6 = lean_box(x_1);
-x_7 = lean_box(x_3);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 6, 3);
-lean_closure_set(x_8, 0, x_6);
-lean_closure_set(x_8, 1, x_5);
-lean_closure_set(x_8, 2, x_7);
-lean_ctor_set(x_2, 1, x_8);
-return x_2;
-}
-else
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-x_9 = lean_ctor_get(x_2, 0);
-x_10 = lean_ctor_get(x_2, 1);
-lean_inc(x_10);
-lean_inc(x_9);
-lean_dec(x_2);
-x_11 = lean_box(x_1);
-x_12 = lean_box(x_3);
-x_13 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 6, 3);
-lean_closure_set(x_13, 0, x_11);
-lean_closure_set(x_13, 1, x_10);
-lean_closure_set(x_13, 2, x_12);
-x_14 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_14, 0, x_9);
-lean_ctor_set(x_14, 1, x_13);
-return x_14;
-}
-}
-}
-lean_object* l_Lean_Parser_many1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; uint8_t x_5; lean_object* x_6; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = lean_unbox(x_3);
-lean_dec(x_3);
-x_6 = l_Lean_Parser_many1(x_4, x_2, x_5);
-return x_6;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(uint8_t x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, uint8_t x_6, uint8_t x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
-_start:
-{
-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_10, 0);
-lean_inc(x_11);
-x_12 = lean_array_get_size(x_11);
-lean_dec(x_11);
-x_13 = lean_ctor_get(x_10, 1);
-lean_inc(x_13);
-lean_inc(x_2);
-lean_inc(x_9);
-lean_inc(x_8);
-x_14 = lean_apply_3(x_2, x_8, x_9, x_10);
-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_20; 
-lean_dec(x_13);
-lean_dec(x_12);
-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_inc(x_18);
-lean_inc(x_3);
-lean_inc(x_9);
-lean_inc(x_8);
-x_19 = lean_apply_3(x_3, x_8, x_9, x_14);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_dec(x_18);
-lean_dec(x_17);
-{
-uint8_t _tmp_6 = x_4;
-lean_object* _tmp_9 = x_19;
-x_7 = _tmp_6;
-x_10 = _tmp_9;
-}
-goto _start;
-}
-else
-{
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
-lean_dec(x_20);
-lean_dec(x_9);
-lean_dec(x_8);
-lean_dec(x_3);
-lean_dec(x_2);
-x_22 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
-lean_dec(x_17);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
-lean_dec(x_23);
-x_25 = lean_nat_sub(x_24, x_5);
-lean_dec(x_24);
-x_26 = lean_unsigned_to_nat(1u);
-x_27 = lean_nat_dec_eq(x_25, x_26);
-lean_dec(x_25);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_5);
-return x_29;
-}
-else
-{
-if (x_6 == 0)
-{
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Lean_nullKind;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_5);
-return x_31;
-}
-else
-{
-lean_dec(x_5);
-return x_22;
-}
-}
-}
-}
-else
-{
-lean_dec(x_15);
-lean_dec(x_9);
-lean_dec(x_8);
-lean_dec(x_3);
-lean_dec(x_2);
-if (x_7 == 0)
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_13);
-lean_dec(x_12);
-x_32 = lean_box(0);
-x_33 = l_Lean_Parser_ParserState_pushSyntax(x_14, x_32);
-x_34 = l_Lean_nullKind;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_5);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; 
-x_36 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13);
-lean_dec(x_12);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-x_38 = lean_array_get_size(x_37);
-lean_dec(x_37);
-x_39 = lean_nat_sub(x_38, x_5);
-lean_dec(x_38);
-x_40 = lean_unsigned_to_nat(2u);
-x_41 = lean_nat_dec_eq(x_39, x_40);
-lean_dec(x_39);
-if (x_41 == 0)
-{
-lean_object* x_42; lean_object* x_43; 
-x_42 = l_Lean_nullKind;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_36, x_42, x_5);
-return x_43;
-}
-else
-{
-if (x_6 == 0)
-{
-lean_object* x_44; lean_object* x_45; 
-x_44 = l_Lean_nullKind;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_36, x_44, x_5);
-return x_45;
-}
-else
-{
-lean_object* x_46; 
-lean_dec(x_5);
-x_46 = l_Lean_Parser_ParserState_popSyntax(x_36);
-return x_46;
-}
-}
-}
-}
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_11; uint8_t x_12; uint8_t x_13; uint8_t x_14; lean_object* x_15; 
-x_11 = lean_unbox(x_1);
-lean_dec(x_1);
-x_12 = lean_unbox(x_4);
-lean_dec(x_4);
-x_13 = lean_unbox(x_6);
-lean_dec(x_6);
-x_14 = lean_unbox(x_7);
-lean_dec(x_7);
-x_15 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(x_11, x_2, x_3, x_12, x_5, x_13, x_14, x_8, x_9, x_10);
-return x_15;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux(uint8_t x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, uint8_t x_6, uint8_t x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
-_start:
-{
-lean_object* x_11; 
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_11; uint8_t x_12; uint8_t x_13; uint8_t x_14; lean_object* x_15; 
-x_11 = lean_unbox(x_1);
-lean_dec(x_1);
-x_12 = lean_unbox(x_4);
-lean_dec(x_4);
-x_13 = lean_unbox(x_6);
-lean_dec(x_6);
-x_14 = lean_unbox(x_7);
-lean_dec(x_7);
-x_15 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux(x_11, x_2, x_3, x_12, x_5, x_13, x_14, x_8, x_9, x_10);
-return x_15;
-}
-}
-lean_object* l_Lean_Parser_sepByFn(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = 1;
-x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(x_1, x_3, x_4, x_2, x_9, x_10, x_11, x_5, x_6, x_7);
-return x_12;
-}
-}
-lean_object* l_Lean_Parser_sepByFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-uint8_t x_8; uint8_t x_9; lean_object* x_10; 
-x_8 = lean_unbox(x_1);
-lean_dec(x_1);
-x_9 = lean_unbox(x_2);
-lean_dec(x_2);
-x_10 = l_Lean_Parser_sepByFn(x_8, x_9, x_3, x_4, x_5, x_6, x_7);
-return x_10;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; 
-x_9 = lean_ctor_get(x_8, 0);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
-lean_dec(x_9);
-x_11 = 0;
-x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main(x_1, x_3, x_4, x_2, x_10, x_5, x_11, x_6, x_7, x_8);
-return x_12;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_5);
-lean_dec(x_5);
-x_12 = l_Lean_Parser_sepBy1Fn(x_9, x_10, x_3, x_4, x_11, x_6, x_7, x_8);
-return x_12;
-}
-}
 lean_object* l_Lean_Parser_sepByInfo___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -5834,90 +5413,82 @@ return x_17;
 }
 }
 }
-lean_object* l_Lean_Parser_sepBy(uint8_t x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4) {
+lean_object* l_Lean_Parser_sepBy(lean_object* x_1, lean_object* x_2, uint8_t x_3) {
 _start:
 {
-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_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; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
 x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = l_Lean_Parser_sepByInfo(x_5, x_6);
+x_6 = l_Lean_Parser_sepByInfo(x_4, x_5);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
 x_8 = lean_ctor_get(x_2, 1);
 lean_inc(x_8);
 lean_dec(x_2);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
+x_9 = lean_box(x_3);
+x_10 = lean_alloc_closure((void*)(l_Lean_Parser_sepByFn___boxed), 5, 3);
+lean_closure_set(x_10, 0, x_9);
+lean_closure_set(x_10, 1, x_7);
+lean_closure_set(x_10, 2, x_8);
+x_11 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_11, 0, x_6);
+lean_ctor_set(x_11, 1, x_10);
+return x_11;
+}
+}
+lean_object* l_Lean_Parser_sepBy___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; lean_object* x_5; 
+x_4 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_box(x_1);
+x_5 = l_Lean_Parser_sepBy(x_1, x_2, x_4);
+return x_5;
+}
+}
+lean_object* l_Lean_Parser_sepBy1(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4) {
+_start:
+{
+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; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_2, 0);
+lean_inc(x_6);
+x_7 = l_Lean_Parser_sepBy1Info(x_5, x_6);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+lean_dec(x_1);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
+lean_dec(x_2);
+x_10 = lean_box(x_3);
 x_11 = lean_box(x_4);
-x_12 = lean_alloc_closure((void*)(l_Lean_Parser_sepByFn___boxed), 7, 4);
+x_12 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___boxed), 6, 4);
 lean_closure_set(x_12, 0, x_10);
-lean_closure_set(x_12, 1, x_11);
-lean_closure_set(x_12, 2, x_8);
-lean_closure_set(x_12, 3, x_9);
+lean_closure_set(x_12, 1, x_8);
+lean_closure_set(x_12, 2, x_9);
+lean_closure_set(x_12, 3, x_11);
 x_13 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_13, 0, x_7);
 lean_ctor_set(x_13, 1, x_12);
 return x_13;
 }
 }
-lean_object* l_Lean_Parser_sepBy___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_sepBy1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; uint8_t x_6; lean_object* x_7; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
+x_5 = lean_unbox(x_3);
+lean_dec(x_3);
 x_6 = lean_unbox(x_4);
 lean_dec(x_4);
-x_7 = l_Lean_Parser_sepBy(x_5, x_2, x_3, x_6);
+x_7 = l_Lean_Parser_sepBy1(x_1, x_2, x_5, x_6);
 return x_7;
 }
 }
-lean_object* l_Lean_Parser_sepBy1(uint8_t x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5) {
-_start:
-{
-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; 
-x_6 = lean_ctor_get(x_2, 0);
-lean_inc(x_6);
-x_7 = lean_ctor_get(x_3, 0);
-lean_inc(x_7);
-x_8 = l_Lean_Parser_sepBy1Info(x_6, x_7);
-x_9 = lean_ctor_get(x_2, 1);
-lean_inc(x_9);
-lean_dec(x_2);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_dec(x_3);
-x_11 = lean_box(x_1);
-x_12 = lean_box(x_4);
-x_13 = lean_box(x_5);
-x_14 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___boxed), 8, 5);
-lean_closure_set(x_14, 0, x_11);
-lean_closure_set(x_14, 1, x_12);
-lean_closure_set(x_14, 2, x_9);
-lean_closure_set(x_14, 3, x_10);
-lean_closure_set(x_14, 4, x_13);
-x_15 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_15, 0, x_8);
-lean_ctor_set(x_15, 1, x_14);
-return x_15;
-}
-}
-lean_object* l_Lean_Parser_sepBy1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-uint8_t x_6; uint8_t x_7; uint8_t x_8; lean_object* x_9; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = lean_unbox(x_4);
-lean_dec(x_4);
-x_8 = lean_unbox(x_5);
-lean_dec(x_5);
-x_9 = l_Lean_Parser_sepBy1(x_6, x_2, x_3, x_7, x_8);
-return x_9;
-}
-}
 lean_object* l_Lean_Parser_satisfyFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -6542,152 +6113,112 @@ lean_ctor_set(x_3, 2, x_2);
 return x_3;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_4, 0);
-x_7 = lean_ctor_get(x_6, 0);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
-lean_inc_n(x_1, 2);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_5 = lean_ctor_get(x_3, 0);
+x_6 = lean_ctor_get(x_5, 0);
+x_7 = lean_ctor_get(x_4, 1);
 lean_inc(x_7);
-x_9 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_9, 0, x_7);
-lean_ctor_set(x_9, 1, x_1);
-lean_ctor_set(x_9, 2, x_1);
-x_10 = lean_string_utf8_extract(x_7, x_1, x_8);
+lean_inc_n(x_1, 2);
+lean_inc(x_6);
+x_8 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_8, 0, x_6);
+lean_ctor_set(x_8, 1, x_1);
+lean_ctor_set(x_8, 2, x_1);
+x_9 = lean_string_utf8_extract(x_6, x_1, x_7);
 if (x_2 == 0)
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
-lean_inc(x_8);
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
 lean_inc(x_7);
-x_11 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_11, 0, x_7);
-lean_ctor_set(x_11, 1, x_8);
-lean_ctor_set(x_11, 2, x_8);
-x_12 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_12, 0, x_9);
-lean_ctor_set(x_12, 1, x_1);
-lean_ctor_set(x_12, 2, x_11);
-x_13 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_13, 0, x_12);
-x_14 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_14, 0, x_13);
-lean_ctor_set(x_14, 1, x_10);
-x_15 = l_Lean_Parser_ParserState_pushSyntax(x_5, x_14);
-return x_15;
-}
-else
-{
-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; 
-x_16 = l_Lean_Parser_whitespace___main(x_4, x_5);
-x_17 = lean_ctor_get(x_16, 1);
-lean_inc(x_17);
-lean_inc(x_7);
-x_18 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_18, 0, x_7);
-lean_ctor_set(x_18, 1, x_8);
-lean_ctor_set(x_18, 2, x_17);
-x_19 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_19, 0, x_9);
-lean_ctor_set(x_19, 1, x_1);
-lean_ctor_set(x_19, 2, x_18);
-x_20 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_20, 0, x_19);
-x_21 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_21, 0, x_20);
-lean_ctor_set(x_21, 1, x_10);
-x_22 = l_Lean_Parser_ParserState_pushSyntax(x_16, x_21);
-return x_22;
-}
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_3__rawAux___rarg___boxed), 5, 0);
-return x_2;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_2);
-lean_dec(x_2);
-x_7 = l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(x_1, x_6, x_3, x_4, x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-return x_7;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l___private_Init_Lean_Parser_Parser_3__rawAux(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_rawFn___rarg(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_6 = lean_ctor_get(x_5, 1);
 lean_inc(x_6);
-lean_inc(x_4);
-lean_inc(x_3);
-x_7 = lean_apply_3(x_1, x_3, x_4, x_5);
-x_8 = lean_ctor_get(x_7, 3);
-lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; 
-x_9 = l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(x_6, x_2, x_3, x_4, x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-return x_9;
+x_10 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_10, 0, x_6);
+lean_ctor_set(x_10, 1, x_7);
+lean_ctor_set(x_10, 2, x_7);
+x_11 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_11, 0, x_8);
+lean_ctor_set(x_11, 1, x_1);
+lean_ctor_set(x_11, 2, x_10);
+x_12 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_12, 0, x_11);
+x_13 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_13, 0, x_12);
+lean_ctor_set(x_13, 1, x_9);
+x_14 = l_Lean_Parser_ParserState_pushSyntax(x_4, x_13);
+return x_14;
 }
 else
 {
-lean_dec(x_8);
-lean_dec(x_6);
-lean_dec(x_4);
-lean_dec(x_3);
-return x_7;
+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; 
+x_15 = l_Lean_Parser_whitespace___main(x_3, x_4);
+x_16 = lean_ctor_get(x_15, 1);
+lean_inc(x_16);
+lean_inc(x_6);
+x_17 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_17, 0, x_6);
+lean_ctor_set(x_17, 1, x_7);
+lean_ctor_set(x_17, 2, x_16);
+x_18 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_18, 0, x_8);
+lean_ctor_set(x_18, 1, x_1);
+lean_ctor_set(x_18, 2, x_17);
+x_19 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_19, 0, x_18);
+x_20 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_9);
+x_21 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_20);
+return x_21;
 }
 }
 }
-lean_object* l_Lean_Parser_rawFn(uint8_t x_1) {
+lean_object* l___private_Init_Lean_Parser_Parser_3__rawAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_rawFn___rarg___boxed), 5, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_rawFn___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_2);
+uint8_t x_5; lean_object* x_6; 
+x_5 = lean_unbox(x_2);
 lean_dec(x_2);
-x_7 = l_Lean_Parser_rawFn___rarg(x_1, x_6, x_3, x_4, x_5);
-return x_7;
+x_6 = l___private_Init_Lean_Parser_Parser_3__rawAux(x_1, x_5, x_3, x_4);
+lean_dec(x_3);
+return x_6;
 }
 }
-lean_object* l_Lean_Parser_rawFn___boxed(lean_object* x_1) {
+lean_object* l_Lean_Parser_rawFn(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_rawFn(x_2);
-return x_3;
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = lean_ctor_get(x_4, 1);
+lean_inc(x_5);
+lean_inc(x_3);
+x_6 = lean_apply_2(x_1, x_3, x_4);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; 
+x_8 = l___private_Init_Lean_Parser_Parser_3__rawAux(x_5, x_2, x_3, x_6);
+lean_dec(x_3);
+return x_8;
+}
+else
+{
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_3);
+return x_6;
+}
+}
+}
+lean_object* l_Lean_Parser_rawFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; lean_object* x_6; 
+x_5 = lean_unbox(x_2);
+lean_dec(x_2);
+x_6 = l_Lean_Parser_rawFn(x_1, x_5, x_3, x_4);
+return x_6;
 }
 }
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_chFn___spec__1(uint32_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
@@ -6731,43 +6262,35 @@ return x_14;
 }
 }
 }
-lean_object* l_Lean_Parser_chFn___rarg(uint32_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_chFn(uint32_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-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; 
-x_6 = lean_ctor_get(x_5, 1);
-lean_inc(x_6);
-x_7 = l_String_splitAux___main___closed__1;
-x_8 = lean_string_push(x_7, x_1);
-x_9 = l_Char_HasRepr___closed__1;
-x_10 = lean_string_append(x_9, x_8);
-lean_dec(x_8);
-x_11 = lean_string_append(x_10, x_9);
-x_12 = l_Lean_Parser_satisfyFn___at_Lean_Parser_chFn___spec__1(x_1, x_11, x_4, x_5);
-x_13 = lean_ctor_get(x_12, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+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; 
+x_5 = l_String_splitAux___main___closed__1;
+x_6 = lean_string_push(x_5, x_1);
+x_7 = l_Char_HasRepr___closed__1;
+x_8 = lean_string_append(x_7, x_6);
+lean_dec(x_6);
+x_9 = lean_string_append(x_8, x_7);
+x_10 = lean_ctor_get(x_4, 1);
+lean_inc(x_10);
+x_11 = l_Lean_Parser_satisfyFn___at_Lean_Parser_chFn___spec__1(x_1, x_9, x_3, x_4);
+x_12 = lean_ctor_get(x_11, 3);
+lean_inc(x_12);
+if (lean_obj_tag(x_12) == 0)
 {
-lean_object* x_14; 
-x_14 = l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(x_6, x_2, x_3, x_4, x_12);
-return x_14;
+lean_object* x_13; 
+x_13 = l___private_Init_Lean_Parser_Parser_3__rawAux(x_10, x_2, x_3, x_11);
+return x_13;
 }
 else
 {
-lean_dec(x_13);
-lean_dec(x_6);
-return x_12;
+lean_dec(x_12);
+lean_dec(x_10);
+return x_11;
 }
 }
 }
-lean_object* l_Lean_Parser_chFn(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_chFn___rarg___boxed), 5, 0);
-return x_2;
-}
-}
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_chFn___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -6779,28 +6302,17 @@ lean_dec(x_3);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_chFn___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_chFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-uint32_t x_6; uint8_t x_7; lean_object* x_8; 
-x_6 = lean_unbox_uint32(x_1);
+uint32_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox_uint32(x_1);
 lean_dec(x_1);
-x_7 = lean_unbox(x_2);
+x_6 = lean_unbox(x_2);
 lean_dec(x_2);
-x_8 = l_Lean_Parser_chFn___rarg(x_6, x_7, x_3, x_4, x_5);
-lean_dec(x_4);
+x_7 = l_Lean_Parser_chFn(x_5, x_6, x_3, x_4);
 lean_dec(x_3);
-return x_8;
-}
-}
-lean_object* l_Lean_Parser_chFn___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_chFn(x_2);
-return x_3;
+return x_7;
 }
 }
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_rawCh___elambda__1___spec__1(uint32_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
@@ -6844,57 +6356,49 @@ return x_14;
 }
 }
 }
-lean_object* l_Lean_Parser_rawCh___elambda__1___rarg(uint32_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_rawCh___elambda__1(uint32_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-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; 
-x_6 = lean_ctor_get(x_5, 1);
-lean_inc(x_6);
-x_7 = l_String_splitAux___main___closed__1;
-x_8 = lean_string_push(x_7, x_1);
-x_9 = l_Char_HasRepr___closed__1;
-x_10 = lean_string_append(x_9, x_8);
-lean_dec(x_8);
-x_11 = lean_string_append(x_10, x_9);
-x_12 = l_Lean_Parser_satisfyFn___at_Lean_Parser_rawCh___elambda__1___spec__1(x_1, x_11, x_4, x_5);
-x_13 = lean_ctor_get(x_12, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+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; 
+x_5 = l_String_splitAux___main___closed__1;
+x_6 = lean_string_push(x_5, x_1);
+x_7 = l_Char_HasRepr___closed__1;
+x_8 = lean_string_append(x_7, x_6);
+lean_dec(x_6);
+x_9 = lean_string_append(x_8, x_7);
+x_10 = lean_ctor_get(x_4, 1);
+lean_inc(x_10);
+x_11 = l_Lean_Parser_satisfyFn___at_Lean_Parser_rawCh___elambda__1___spec__1(x_1, x_9, x_3, x_4);
+x_12 = lean_ctor_get(x_11, 3);
+lean_inc(x_12);
+if (lean_obj_tag(x_12) == 0)
 {
-lean_object* x_14; 
-x_14 = l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(x_6, x_2, x_3, x_4, x_12);
-return x_14;
+lean_object* x_13; 
+x_13 = l___private_Init_Lean_Parser_Parser_3__rawAux(x_10, x_2, x_3, x_11);
+return x_13;
 }
 else
 {
-lean_dec(x_13);
-lean_dec(x_6);
-return x_12;
+lean_dec(x_12);
+lean_dec(x_10);
+return x_11;
 }
 }
 }
-lean_object* l_Lean_Parser_rawCh___elambda__1(uint8_t x_1) {
+lean_object* l_Lean_Parser_rawCh(uint32_t x_1, uint8_t x_2) {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_rawCh___elambda__1___rarg___boxed), 5, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_rawCh(uint8_t x_1, uint32_t x_2, uint8_t x_3) {
-_start:
-{
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_box_uint32(x_2);
-x_5 = lean_box(x_3);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_rawCh___elambda__1___rarg___boxed), 5, 2);
-lean_closure_set(x_6, 0, x_4);
-lean_closure_set(x_6, 1, x_5);
-x_7 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_8 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_8, 0, x_7);
-lean_ctor_set(x_8, 1, x_6);
-return x_8;
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_box_uint32(x_1);
+x_4 = lean_box(x_2);
+x_5 = lean_alloc_closure((void*)(l_Lean_Parser_rawCh___elambda__1___boxed), 4, 2);
+lean_closure_set(x_5, 0, x_3);
+lean_closure_set(x_5, 1, x_4);
+x_6 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_7 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_7, 0, x_6);
+lean_ctor_set(x_7, 1, x_5);
+return x_7;
 }
 }
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_rawCh___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
@@ -6908,44 +6412,31 @@ lean_dec(x_3);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_rawCh___elambda__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_rawCh___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-uint32_t x_6; uint8_t x_7; lean_object* x_8; 
-x_6 = lean_unbox_uint32(x_1);
+uint32_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox_uint32(x_1);
 lean_dec(x_1);
-x_7 = lean_unbox(x_2);
+x_6 = lean_unbox(x_2);
 lean_dec(x_2);
-x_8 = l_Lean_Parser_rawCh___elambda__1___rarg(x_6, x_7, x_3, x_4, x_5);
-lean_dec(x_4);
+x_7 = l_Lean_Parser_rawCh___elambda__1(x_5, x_6, x_3, x_4);
 lean_dec(x_3);
-return x_8;
-}
-}
-lean_object* l_Lean_Parser_rawCh___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_rawCh___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_rawCh___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; uint32_t x_5; uint8_t x_6; lean_object* x_7; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = lean_unbox_uint32(x_2);
-lean_dec(x_2);
-x_6 = lean_unbox(x_3);
-lean_dec(x_3);
-x_7 = l_Lean_Parser_rawCh(x_4, x_5, x_6);
 return x_7;
 }
 }
+lean_object* l_Lean_Parser_rawCh___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint32_t x_3; uint8_t x_4; lean_object* x_5; 
+x_3 = lean_unbox_uint32(x_1);
+lean_dec(x_1);
+x_4 = lean_unbox(x_2);
+lean_dec(x_2);
+x_5 = l_Lean_Parser_rawCh(x_3, x_4);
+return x_5;
+}
+}
 lean_object* _init_l_Lean_Parser_hexDigitFn___closed__1() {
 _start:
 {
@@ -9253,7 +8744,7 @@ lean_object* x_11; lean_object* x_12;
 lean_dec(x_1);
 x_11 = lean_ctor_get(x_9, 0);
 lean_inc(x_11);
-x_12 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_11);
+x_12 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_11);
 lean_dec(x_11);
 if (lean_obj_tag(x_12) == 3)
 {
@@ -9358,7 +8849,7 @@ x_13 = x_6 == x_12;
 if (x_13 == 0)
 {
 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_1, 2);
+x_14 = lean_ctor_get(x_1, 3);
 lean_inc(x_14);
 lean_inc(x_5);
 x_15 = l_Lean_Parser_Trie_matchPrefix___rarg(x_4, x_14, x_5);
@@ -9379,7 +8870,7 @@ x_20 = l___private_Init_Lean_Parser_Parser_5__isIdFirstOrBeginEscape(x_19);
 if (x_20 == 0)
 {
 lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_21 = lean_ctor_get(x_1, 2);
+x_21 = lean_ctor_get(x_1, 3);
 lean_inc(x_21);
 lean_inc(x_5);
 x_22 = l_Lean_Parser_Trie_matchPrefix___rarg(x_4, x_21, x_5);
@@ -9466,7 +8957,7 @@ x_12 = lean_ctor_get(x_2, 1);
 lean_dec(x_12);
 x_13 = lean_ctor_get(x_2, 0);
 lean_dec(x_13);
-x_14 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_4);
+x_14 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_4);
 lean_inc(x_5);
 x_15 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_15, 0, x_1);
@@ -9479,7 +8970,7 @@ else
 {
 lean_object* x_16; lean_object* x_17; lean_object* x_18; 
 lean_dec(x_2);
-x_16 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_4);
+x_16 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_4);
 lean_inc(x_5);
 x_17 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_17, 0, x_1);
@@ -9583,7 +9074,7 @@ if (lean_obj_tag(x_7) == 0)
 lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
-x_9 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_8);
+x_9 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_8);
 lean_dec(x_8);
 x_10 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
 lean_dec(x_4);
@@ -9658,7 +9149,7 @@ if (lean_obj_tag(x_7) == 0)
 lean_object* x_8; lean_object* x_9; 
 x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
-x_9 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_8);
+x_9 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_8);
 lean_dec(x_8);
 if (lean_obj_tag(x_9) == 2)
 {
@@ -9719,7 +9210,7 @@ if (lean_obj_tag(x_9) == 0)
 lean_object* x_10; lean_object* x_11; 
 x_10 = lean_ctor_get(x_8, 0);
 lean_inc(x_10);
-x_11 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_10);
+x_11 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_10);
 lean_dec(x_10);
 if (lean_obj_tag(x_11) == 2)
 {
@@ -9835,103 +9326,110 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_symbolFn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_symbolFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-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; 
-x_5 = l_Char_HasRepr___closed__1;
-x_6 = lean_string_append(x_5, x_1);
-x_7 = lean_string_append(x_6, x_5);
-x_8 = lean_box(0);
-x_9 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_9, 0, x_7);
-lean_ctor_set(x_9, 1, x_8);
-x_10 = lean_ctor_get(x_4, 1);
-lean_inc(x_10);
-x_11 = l_Lean_Parser_tokenFn(x_3, x_4);
-x_12 = lean_ctor_get(x_11, 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; 
+x_4 = l_Char_HasRepr___closed__1;
+x_5 = lean_string_append(x_4, x_1);
+x_6 = lean_string_append(x_5, x_4);
+x_7 = lean_box(0);
+x_8 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_8, 0, x_6);
+lean_ctor_set(x_8, 1, x_7);
+x_9 = lean_ctor_get(x_3, 1);
+lean_inc(x_9);
+x_10 = l_Lean_Parser_tokenFn(x_2, x_3);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_object* x_12; lean_object* x_13; 
+x_12 = lean_ctor_get(x_10, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_13 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_12);
+lean_dec(x_12);
+if (lean_obj_tag(x_13) == 2)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_11, 0);
-lean_inc(x_13);
-x_14 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_13);
+lean_object* x_14; uint8_t x_15; 
+x_14 = lean_ctor_get(x_13, 1);
+lean_inc(x_14);
 lean_dec(x_13);
-if (lean_obj_tag(x_14) == 2)
-{
-lean_object* x_15; uint8_t x_16; 
-x_15 = lean_ctor_get(x_14, 1);
-lean_inc(x_15);
+x_15 = lean_string_dec_eq(x_14, x_1);
 lean_dec(x_14);
-x_16 = lean_string_dec_eq(x_15, x_1);
-lean_dec(x_15);
-if (x_16 == 0)
+if (x_15 == 0)
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_9, x_10);
-return x_17;
+lean_object* x_16; 
+x_16 = l_Lean_Parser_ParserState_mkErrorsAt(x_10, x_8, x_9);
+return x_16;
 }
 else
 {
-lean_dec(x_10);
 lean_dec(x_9);
-return x_11;
+lean_dec(x_8);
+return x_10;
+}
+}
+else
+{
+lean_object* x_17; 
+lean_dec(x_13);
+x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_10, x_8, x_9);
+return x_17;
 }
 }
 else
 {
 lean_object* x_18; 
-lean_dec(x_14);
-x_18 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_9, x_10);
+lean_dec(x_11);
+x_18 = l_Lean_Parser_ParserState_mkErrorsAt(x_10, x_8, x_9);
 return x_18;
 }
 }
-else
-{
-lean_object* x_19; 
-lean_dec(x_12);
-x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_9, x_10);
-return x_19;
 }
-}
-}
-lean_object* l_Lean_Parser_symbolFn(uint8_t x_1) {
+lean_object* l_Lean_Parser_symbolFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_symbolFn___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_symbolFn___rarg(x_1, x_2, x_3, x_4);
-lean_dec(x_2);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_symbolFn(x_1, x_2, x_3);
 lean_dec(x_1);
-return x_5;
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_symbolFn___boxed(lean_object* x_1) {
+lean_object* l_Lean_Parser_symbolAux(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_3 = l_String_trim(x_1);
+lean_inc(x_3);
+x_4 = l_Lean_Parser_symbolInfo(x_3, x_2);
+x_5 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
+lean_closure_set(x_5, 0, x_3);
+x_6 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_5);
+return x_6;
+}
+}
+lean_object* l_Lean_Parser_symbolAux___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_Lean_Parser_symbolAux(x_1, x_2);
 lean_dec(x_1);
-x_3 = l_Lean_Parser_symbolFn(x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_symbolAux(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_symbol(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_4 = l_String_trim(x_2);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_3, 0, x_2);
+x_4 = l_String_trim(x_1);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_symbolInfo(x_4, x_3);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
 lean_closure_set(x_6, 0, x_4);
 x_7 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_7, 0, x_5);
@@ -9939,43 +9437,13 @@ lean_ctor_set(x_7, 1, x_6);
 return x_7;
 }
 }
-lean_object* l_Lean_Parser_symbolAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_symbol___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
+lean_object* x_3; 
+x_3 = l_Lean_Parser_symbol(x_1, x_2);
 lean_dec(x_1);
-x_5 = l_Lean_Parser_symbolAux(x_4, x_2, x_3);
-lean_dec(x_2);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_symbol(uint8_t 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; 
-x_4 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_4, 0, x_3);
-x_5 = l_String_trim(x_2);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_symbolInfo(x_5, x_4);
-x_7 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
-lean_closure_set(x_7, 0, x_5);
-x_8 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_8, 0, x_6);
-lean_ctor_set(x_8, 1, x_7);
-return x_8;
-}
-}
-lean_object* l_Lean_Parser_symbol___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_Parser_symbol(x_4, x_2, x_3);
-lean_dec(x_2);
-return x_5;
+return x_3;
 }
 }
 lean_object* l_Lean_Parser_nonReservedSymbolFnAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
@@ -9992,7 +9460,7 @@ if (lean_obj_tag(x_7) == 0)
 lean_object* x_8; lean_object* x_9; 
 x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
-x_9 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_8);
+x_9 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_8);
 lean_dec(x_8);
 switch (lean_obj_tag(x_9)) {
 case 2:
@@ -10222,54 +9690,32 @@ x_4 = l_Lean_Parser_nonReservedSymbolInfo(x_1, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_nonReservedSymbol___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_nonReservedSymbol(lean_object* x_1, uint8_t x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_5 = l_Char_HasRepr___closed__1;
-x_6 = lean_string_append(x_5, x_1);
-x_7 = lean_string_append(x_6, x_5);
-x_8 = l_Lean_Parser_nonReservedSymbolFnAux(x_1, x_7, x_3, x_4);
-return x_8;
-}
-}
-lean_object* l_Lean_Parser_nonReservedSymbol(uint8_t x_1, lean_object* x_2, uint8_t x_3) {
-_start:
-{
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_4 = l_String_trim(x_2);
-lean_inc(x_4);
-x_5 = l_Lean_Parser_nonReservedSymbolInfo(x_4, x_3);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_nonReservedSymbol___lambda__1___boxed), 4, 1);
-lean_closure_set(x_6, 0, x_4);
-x_7 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_7, 0, x_5);
-lean_ctor_set(x_7, 1, x_6);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_nonReservedSymbol___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_nonReservedSymbol___lambda__1(x_1, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_nonReservedSymbol___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; uint8_t x_5; lean_object* x_6; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = lean_unbox(x_3);
-lean_dec(x_3);
-x_6 = l_Lean_Parser_nonReservedSymbol(x_4, x_2, x_5);
-lean_dec(x_2);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_3 = l_String_trim(x_1);
+lean_inc(x_3);
+x_4 = l_Lean_Parser_nonReservedSymbolInfo(x_3, x_2);
+x_5 = lean_alloc_closure((void*)(l_Lean_Parser_nonReservedSymbolFn), 3, 1);
+lean_closure_set(x_5, 0, x_3);
+x_6 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_5);
 return x_6;
 }
 }
+lean_object* l_Lean_Parser_nonReservedSymbol___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = lean_unbox(x_2);
+lean_dec(x_2);
+x_4 = l_Lean_Parser_nonReservedSymbol(x_1, x_3);
+lean_dec(x_1);
+return x_4;
+}
+}
 lean_object* l_Lean_Parser_strAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
@@ -10402,7 +9848,7 @@ _start:
 lean_object* x_4; lean_object* x_5; uint8_t x_6; 
 x_4 = lean_ctor_get(x_3, 0);
 lean_inc(x_4);
-x_5 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_4);
+x_5 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_4);
 lean_dec(x_4);
 x_6 = l_Lean_Parser_checkTailWs(x_5);
 lean_dec(x_5);
@@ -10428,62 +9874,33 @@ lean_dec(x_2);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_checkWsBefore___elambda__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_checkWsBefore___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l_Lean_Parser_checkWsBeforeFn(x_1, x_3, x_4);
-return x_5;
+lean_object* x_4; 
+x_4 = l_Lean_Parser_checkWsBeforeFn(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_checkWsBefore___elambda__1(uint8_t x_1) {
+lean_object* l_Lean_Parser_checkWsBefore(lean_object* x_1) {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkWsBefore___elambda__1___rarg___boxed), 4, 0);
-return x_2;
+lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkWsBefore___elambda__1___boxed), 3, 1);
+lean_closure_set(x_2, 0, x_1);
+x_3 = l_Lean_Parser_epsilonInfo;
+x_4 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_4, 0, x_3);
+lean_ctor_set(x_4, 1, x_2);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_checkWsBefore(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_checkWsBefore___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_checkWsBefore___elambda__1___rarg___boxed), 4, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_epsilonInfo;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_checkWsBefore___elambda__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_checkWsBefore___elambda__1___rarg(x_1, x_2, x_3, x_4);
-lean_dec(x_3);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_checkWsBefore___elambda__1(x_1, x_2, x_3);
 lean_dec(x_2);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_checkWsBefore___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_checkWsBefore___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_checkWsBefore___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_checkWsBefore(x_3, x_2);
 return x_4;
 }
 }
@@ -10640,62 +10057,33 @@ lean_dec(x_2);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l_Lean_Parser_checkNoWsBeforeFn(x_1, x_3, x_4);
-return x_5;
+lean_object* x_4; 
+x_4 = l_Lean_Parser_checkNoWsBeforeFn(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1(uint8_t x_1) {
+lean_object* l_Lean_Parser_checkNoWsBefore(lean_object* x_1) {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___rarg___boxed), 4, 0);
-return x_2;
+lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___boxed), 3, 1);
+lean_closure_set(x_2, 0, x_1);
+x_3 = l_Lean_Parser_epsilonInfo;
+x_4 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_4, 0, x_3);
+lean_ctor_set(x_4, 1, x_2);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_checkNoWsBefore(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___rarg___boxed), 4, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_epsilonInfo;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_checkNoWsBefore___elambda__1___rarg(x_1, x_2, x_3, x_4);
-lean_dec(x_3);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_checkNoWsBefore___elambda__1(x_1, x_2, x_3);
 lean_dec(x_2);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_checkNoWsBefore___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_checkNoWsBefore___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_checkNoWsBefore(x_3, x_2);
 return x_4;
 }
 }
@@ -10766,83 +10154,82 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_symbolNoWsFnAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_symbolNoWsFnAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
-x_6 = lean_ctor_get(x_5, 0);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_4, 1);
 lean_inc(x_6);
-x_7 = lean_ctor_get(x_5, 1);
-lean_inc(x_7);
-x_8 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_6);
+x_7 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_5);
+lean_dec(x_5);
+x_8 = l_Lean_Parser_checkTailNoWs(x_7);
+lean_dec(x_7);
+if (x_8 == 0)
+{
+lean_object* x_9; 
 lean_dec(x_6);
-x_9 = l_Lean_Parser_checkTailNoWs(x_8);
-lean_dec(x_8);
-if (x_9 == 0)
-{
-lean_object* x_10; 
-lean_dec(x_7);
 lean_dec(x_1);
-x_10 = l_Lean_Parser_ParserState_mkError(x_5, x_2);
-return x_10;
+x_9 = l_Lean_Parser_ParserState_mkError(x_4, x_2);
+return x_9;
 }
 else
 {
-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_4, 0);
-x_12 = lean_ctor_get(x_11, 0);
-x_13 = lean_unsigned_to_nat(0u);
-x_14 = l_Lean_Parser_strAux___main(x_1, x_2, x_13, x_4, x_5);
-x_15 = lean_ctor_get(x_14, 3);
-lean_inc(x_15);
-if (lean_obj_tag(x_15) == 0)
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+x_10 = lean_ctor_get(x_3, 0);
+x_11 = lean_ctor_get(x_10, 0);
+x_12 = lean_unsigned_to_nat(0u);
+x_13 = l_Lean_Parser_strAux___main(x_1, x_2, x_12, x_3, x_4);
+x_14 = lean_ctor_get(x_13, 3);
+lean_inc(x_14);
+if (lean_obj_tag(x_14) == 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; lean_object* x_22; lean_object* x_23; 
-lean_inc_n(x_7, 2);
-lean_inc(x_12);
-x_16 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_16, 0, x_12);
-lean_ctor_set(x_16, 1, x_7);
-lean_ctor_set(x_16, 2, x_7);
-x_17 = lean_string_utf8_byte_size(x_1);
-x_18 = lean_nat_add(x_7, x_17);
-lean_dec(x_17);
-lean_inc(x_18);
-lean_inc(x_12);
+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_inc_n(x_6, 2);
+lean_inc(x_11);
+x_15 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_15, 0, x_11);
+lean_ctor_set(x_15, 1, x_6);
+lean_ctor_set(x_15, 2, x_6);
+x_16 = lean_string_utf8_byte_size(x_1);
+x_17 = lean_nat_add(x_6, x_16);
+lean_dec(x_16);
+lean_inc(x_17);
+lean_inc(x_11);
+x_18 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_18, 0, x_11);
+lean_ctor_set(x_18, 1, x_17);
+lean_ctor_set(x_18, 2, x_17);
 x_19 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_19, 0, x_12);
-lean_ctor_set(x_19, 1, x_18);
+lean_ctor_set(x_19, 0, x_15);
+lean_ctor_set(x_19, 1, x_6);
 lean_ctor_set(x_19, 2, x_18);
-x_20 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_20, 0, x_16);
-lean_ctor_set(x_20, 1, x_7);
-lean_ctor_set(x_20, 2, x_19);
-x_21 = lean_alloc_ctor(1, 1, 0);
+x_20 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_20, 0, x_19);
+x_21 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_21, 0, x_20);
-x_22 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_22, 0, x_21);
-lean_ctor_set(x_22, 1, x_1);
-x_23 = l_Lean_Parser_ParserState_pushSyntax(x_14, x_22);
-return x_23;
+lean_ctor_set(x_21, 1, x_1);
+x_22 = l_Lean_Parser_ParserState_pushSyntax(x_13, x_21);
+return x_22;
 }
 else
 {
-lean_dec(x_15);
-lean_dec(x_7);
+lean_dec(x_14);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_14;
+return x_13;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_symbolNoWsFnAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_symbolNoWsFnAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; 
-x_6 = l_Lean_Parser_symbolNoWsFnAux(x_1, x_2, x_3, x_4, x_5);
-lean_dec(x_4);
+lean_object* x_5; 
+x_5 = l_Lean_Parser_symbolNoWsFnAux(x_1, x_2, x_3, x_4);
 lean_dec(x_3);
-return x_6;
+return x_5;
 }
 }
 lean_object* _init_l_Lean_Parser_symbolNoWsFn___closed__1() {
@@ -10853,87 +10240,86 @@ x_1 = lean_mk_string("' without whitespaces around it");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_symbolNoWsFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_symbolNoWsFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-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; uint8_t x_12; 
-x_5 = l_Char_HasRepr___closed__1;
-x_6 = lean_string_append(x_5, x_1);
-x_7 = l_Lean_Parser_symbolNoWsFn___closed__1;
-x_8 = lean_string_append(x_6, x_7);
-x_9 = lean_ctor_get(x_4, 0);
+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; uint8_t x_11; 
+x_4 = l_Char_HasRepr___closed__1;
+x_5 = lean_string_append(x_4, x_1);
+x_6 = l_Lean_Parser_symbolNoWsFn___closed__1;
+x_7 = lean_string_append(x_5, x_6);
+x_8 = lean_ctor_get(x_3, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_3, 1);
 lean_inc(x_9);
-x_10 = lean_ctor_get(x_4, 1);
-lean_inc(x_10);
-x_11 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_9);
+x_10 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_8);
+lean_dec(x_8);
+x_11 = l_Lean_Parser_checkTailNoWs(x_10);
+lean_dec(x_10);
+if (x_11 == 0)
+{
+lean_object* x_12; 
 lean_dec(x_9);
-x_12 = l_Lean_Parser_checkTailNoWs(x_11);
-lean_dec(x_11);
-if (x_12 == 0)
-{
-lean_object* x_13; 
-lean_dec(x_10);
 lean_dec(x_1);
-x_13 = l_Lean_Parser_ParserState_mkError(x_4, x_8);
-return x_13;
+x_12 = l_Lean_Parser_ParserState_mkError(x_3, x_7);
+return x_12;
 }
 else
 {
-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_3, 0);
-x_15 = lean_ctor_get(x_14, 0);
-x_16 = lean_unsigned_to_nat(0u);
-x_17 = l_Lean_Parser_strAux___main(x_1, x_8, x_16, x_3, x_4);
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+x_13 = lean_ctor_get(x_2, 0);
+x_14 = lean_ctor_get(x_13, 0);
+x_15 = lean_unsigned_to_nat(0u);
+x_16 = l_Lean_Parser_strAux___main(x_1, x_7, x_15, x_2, x_3);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-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_inc_n(x_10, 2);
-lean_inc(x_15);
-x_19 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_19, 0, x_15);
-lean_ctor_set(x_19, 1, x_10);
-lean_ctor_set(x_19, 2, x_10);
-x_20 = lean_string_utf8_byte_size(x_1);
-x_21 = lean_nat_add(x_10, x_20);
-lean_dec(x_20);
-lean_inc(x_21);
-lean_inc(x_15);
+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_inc_n(x_9, 2);
+lean_inc(x_14);
+x_18 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_18, 0, x_14);
+lean_ctor_set(x_18, 1, x_9);
+lean_ctor_set(x_18, 2, x_9);
+x_19 = lean_string_utf8_byte_size(x_1);
+x_20 = lean_nat_add(x_9, x_19);
+lean_dec(x_19);
+lean_inc(x_20);
+lean_inc(x_14);
+x_21 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_21, 0, x_14);
+lean_ctor_set(x_21, 1, x_20);
+lean_ctor_set(x_21, 2, x_20);
 x_22 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_22, 0, x_15);
-lean_ctor_set(x_22, 1, x_21);
+lean_ctor_set(x_22, 0, x_18);
+lean_ctor_set(x_22, 1, x_9);
 lean_ctor_set(x_22, 2, x_21);
-x_23 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_23, 0, x_19);
-lean_ctor_set(x_23, 1, x_10);
-lean_ctor_set(x_23, 2, x_22);
-x_24 = lean_alloc_ctor(1, 1, 0);
+x_23 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_23, 0, x_22);
+x_24 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_24, 0, x_23);
-x_25 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_25, 0, x_24);
-lean_ctor_set(x_25, 1, x_1);
-x_26 = l_Lean_Parser_ParserState_pushSyntax(x_17, x_25);
-return x_26;
+lean_ctor_set(x_24, 1, x_1);
+x_25 = l_Lean_Parser_ParserState_pushSyntax(x_16, x_24);
+return x_25;
 }
 else
 {
-lean_dec(x_18);
-lean_dec(x_10);
+lean_dec(x_17);
+lean_dec(x_9);
 lean_dec(x_1);
-return x_17;
+return x_16;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_symbolNoWsFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_symbolNoWsFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l_Lean_Parser_symbolNoWsFn(x_1, x_2, x_3, x_4);
-lean_dec(x_3);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_symbolNoWsFn(x_1, x_2, x_3);
 lean_dec(x_2);
-return x_5;
+return x_4;
 }
 }
 lean_object* l_Lean_Parser_symbolNoWsAux(lean_object* x_1, lean_object* x_2) {
@@ -10943,7 +10329,7 @@ lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6;
 x_3 = l_String_trim(x_1);
 lean_inc(x_3);
 x_4 = l_Lean_Parser_symbolNoWsInfo(x_3, x_2);
-x_5 = lean_alloc_closure((void*)(l_Lean_Parser_symbolNoWsFn___boxed), 4, 1);
+x_5 = lean_alloc_closure((void*)(l_Lean_Parser_symbolNoWsFn___boxed), 3, 1);
 lean_closure_set(x_5, 0, x_3);
 x_6 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_6, 0, x_4);
@@ -10969,7 +10355,7 @@ lean_ctor_set(x_3, 0, x_2);
 x_4 = l_String_trim(x_1);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_symbolNoWsInfo(x_4, x_3);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_symbolNoWsFn___boxed), 4, 1);
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_symbolNoWsFn___boxed), 3, 1);
 lean_closure_set(x_6, 0, x_4);
 x_7 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_7, 0, x_5);
@@ -11000,7 +10386,7 @@ if (lean_obj_tag(x_8) == 0)
 lean_object* x_9; lean_object* x_10; 
 x_9 = lean_ctor_get(x_7, 0);
 lean_inc(x_9);
-x_10 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_9);
+x_10 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_9);
 lean_dec(x_9);
 if (lean_obj_tag(x_10) == 2)
 {
@@ -11147,7 +10533,7 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_unicodeSymbolFn___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_unicodeSymbolFn___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -11155,95 +10541,77 @@ x_1 = lean_mk_string("', '");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_unicodeSymbolFn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_unicodeSymbolFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-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; 
-x_6 = l_Char_HasRepr___closed__1;
-x_7 = lean_string_append(x_6, x_1);
-x_8 = l_Lean_Parser_unicodeSymbolFn___rarg___closed__1;
-x_9 = lean_string_append(x_7, x_8);
-x_10 = lean_string_append(x_9, x_2);
-x_11 = lean_string_append(x_10, x_6);
-x_12 = lean_box(0);
-x_13 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_13, 0, x_11);
-lean_ctor_set(x_13, 1, x_12);
-x_14 = l_Lean_Parser_unicodeSymbolFnAux(x_1, x_2, x_13, x_4, x_5);
-return x_14;
+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; 
+x_5 = l_Char_HasRepr___closed__1;
+x_6 = lean_string_append(x_5, x_1);
+x_7 = l_Lean_Parser_unicodeSymbolFn___closed__1;
+x_8 = lean_string_append(x_6, x_7);
+x_9 = lean_string_append(x_8, x_2);
+x_10 = lean_string_append(x_9, x_5);
+x_11 = lean_box(0);
+x_12 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_12, 0, x_10);
+lean_ctor_set(x_12, 1, x_11);
+x_13 = l_Lean_Parser_unicodeSymbolFnAux(x_1, x_2, x_12, x_3, x_4);
+return x_13;
 }
 }
-lean_object* l_Lean_Parser_unicodeSymbolFn(uint8_t x_1) {
+lean_object* l_Lean_Parser_unicodeSymbolFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___rarg___boxed), 5, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_unicodeSymbolFn___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_Parser_unicodeSymbolFn___rarg(x_1, x_2, x_3, x_4, x_5);
-lean_dec(x_3);
+lean_object* x_5; 
+x_5 = l_Lean_Parser_unicodeSymbolFn(x_1, x_2, x_3, x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_6;
+return x_5;
 }
 }
-lean_object* l_Lean_Parser_unicodeSymbolFn___boxed(lean_object* x_1) {
+lean_object* l_Lean_Parser_unicodeSymbol(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_unicodeSymbolFn(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_unicodeSymbol(uint8_t 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; lean_object* x_9; 
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_4 = l_String_trim(x_1);
 x_5 = l_String_trim(x_2);
-x_6 = l_String_trim(x_3);
-lean_inc(x_6);
 lean_inc(x_5);
-x_7 = l_Lean_Parser_unicodeSymbolInfo(x_5, x_6, x_4);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___rarg___boxed), 5, 2);
-lean_closure_set(x_8, 0, x_5);
-lean_closure_set(x_8, 1, x_6);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_7);
-lean_ctor_set(x_9, 1, x_8);
-return x_9;
+lean_inc(x_4);
+x_6 = l_Lean_Parser_unicodeSymbolInfo(x_4, x_5, x_3);
+x_7 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___boxed), 4, 2);
+lean_closure_set(x_7, 0, x_4);
+lean_closure_set(x_7, 1, x_5);
+x_8 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_8, 0, x_6);
+lean_ctor_set(x_8, 1, x_7);
+return x_8;
 }
 }
-lean_object* l_Lean_Parser_unicodeSymbol___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_unicodeSymbol___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_unicodeSymbol(x_5, x_2, x_3, x_4);
-lean_dec(x_3);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_unicodeSymbol(x_1, x_2, x_3);
 lean_dec(x_2);
-return x_6;
+lean_dec(x_1);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFnAux(lean_object* x_1, lean_object* x_2, 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* l_Lean_Parser_unicodeSymbolCheckPrecFnAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
 {
-uint8_t x_9; 
-x_9 = lean_nat_dec_lt(x_3, x_6);
+lean_object* x_8; uint8_t x_9; 
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_lt(x_3, x_8);
+lean_dec(x_8);
 if (x_9 == 0)
 {
 lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 lean_dec(x_5);
-x_10 = lean_ctor_get(x_8, 1);
+x_10 = lean_ctor_get(x_7, 1);
 lean_inc(x_10);
-x_11 = l_Lean_Parser_tokenFn(x_7, x_8);
+x_11 = l_Lean_Parser_tokenFn(x_6, x_7);
 x_12 = lean_ctor_get(x_11, 3);
 lean_inc(x_12);
 if (lean_obj_tag(x_12) == 0)
@@ -11251,7 +10619,7 @@ if (lean_obj_tag(x_12) == 0)
 lean_object* x_13; lean_object* x_14; 
 x_13 = lean_ctor_get(x_11, 0);
 lean_inc(x_13);
-x_14 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_13);
+x_14 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_13);
 lean_dec(x_13);
 if (lean_obj_tag(x_14) == 2)
 {
@@ -11305,23 +10673,22 @@ return x_20;
 else
 {
 lean_object* x_21; 
-lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_4);
-x_21 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_5);
+x_21 = l_Lean_Parser_ParserState_mkUnexpectedError(x_7, x_5);
 return x_21;
 }
 }
 }
-lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFnAux___boxed(lean_object* x_1, lean_object* x_2, 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* l_Lean_Parser_unicodeSymbolCheckPrecFnAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
 {
-lean_object* x_9; 
-x_9 = l_Lean_Parser_unicodeSymbolCheckPrecFnAux(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
-lean_dec(x_6);
+lean_object* x_8; 
+x_8 = l_Lean_Parser_unicodeSymbolCheckPrecFnAux(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__1() {
@@ -11340,40 +10707,39 @@ x_1 = lean_mk_string("' as expected, but brackets are needed");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-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; 
-x_7 = l_Char_HasRepr___closed__1;
-x_8 = lean_string_append(x_7, x_1);
-x_9 = lean_string_append(x_8, x_7);
-x_10 = lean_string_append(x_7, x_2);
-x_11 = lean_string_append(x_10, x_7);
-x_12 = lean_box(0);
+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; 
+x_6 = l_Char_HasRepr___closed__1;
+x_7 = lean_string_append(x_6, x_1);
+x_8 = lean_string_append(x_7, x_6);
+x_9 = lean_string_append(x_6, x_2);
+x_10 = lean_string_append(x_9, x_6);
+x_11 = lean_box(0);
+x_12 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_12, 0, x_10);
+lean_ctor_set(x_12, 1, x_11);
 x_13 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_13, 0, x_11);
+lean_ctor_set(x_13, 0, x_8);
 lean_ctor_set(x_13, 1, x_12);
-x_14 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_14, 0, x_9);
-lean_ctor_set(x_14, 1, x_13);
-x_15 = l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__1;
-x_16 = lean_string_append(x_15, x_1);
-x_17 = l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__2;
-x_18 = lean_string_append(x_16, x_17);
-x_19 = l_Lean_Parser_unicodeSymbolCheckPrecFnAux(x_1, x_2, x_3, x_14, x_18, x_4, x_5, x_6);
-return x_19;
+x_14 = l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__1;
+x_15 = lean_string_append(x_14, x_1);
+x_16 = l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__2;
+x_17 = lean_string_append(x_15, x_16);
+x_18 = l_Lean_Parser_unicodeSymbolCheckPrecFnAux(x_1, x_2, x_3, x_13, x_17, x_4, x_5);
+return x_18;
 }
 }
-lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFn___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_7; 
-x_7 = l_Lean_Parser_unicodeSymbolCheckPrecFn(x_1, x_2, x_3, x_4, x_5, x_6);
-lean_dec(x_4);
+lean_object* x_6; 
+x_6 = l_Lean_Parser_unicodeSymbolCheckPrecFn(x_1, x_2, x_3, x_4, x_5);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 }
 lean_object* l_Lean_Parser_unicodeSymbolCheckPrec(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
@@ -11388,7 +10754,7 @@ lean_ctor_set(x_6, 0, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_7 = l_Lean_Parser_unicodeSymbolInfo(x_4, x_5, x_6);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolCheckPrecFn___boxed), 6, 3);
+x_8 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolCheckPrecFn___boxed), 5, 3);
 lean_closure_set(x_8, 0, x_4);
 lean_closure_set(x_8, 1, x_5);
 lean_closure_set(x_8, 2, x_3);
@@ -11480,7 +10846,7 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_numLitFn___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_numLitFn(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; 
@@ -11494,7 +10860,7 @@ if (lean_obj_tag(x_5) == 0)
 lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
 x_6 = lean_ctor_get(x_4, 0);
 lean_inc(x_6);
-x_7 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_6);
+x_7 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_6);
 lean_dec(x_6);
 x_8 = l_Lean_numLitKind;
 x_9 = l_Lean_Syntax_isOfKind(x_7, x_8);
@@ -11521,25 +10887,6 @@ return x_13;
 }
 }
 }
-lean_object* l_Lean_Parser_numLitFn(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_numLitFn___rarg), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_numLitFn___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_numLitFn(x_3, x_2);
-lean_dec(x_2);
-return x_4;
-}
-}
 lean_object* _init_l_Lean_Parser_numLitNoAntiquot___closed__1() {
 _start:
 {
@@ -11549,31 +10896,35 @@ x_2 = l_Lean_Parser_mkAtomicInfo(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_numLitNoAntiquot(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_numLitNoAntiquot___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_numLitFn___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_numLitNoAntiquot___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_numLitFn), 2, 0);
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_numLitNoAntiquot___boxed(lean_object* x_1) {
+lean_object* _init_l_Lean_Parser_numLitNoAntiquot___closed__3() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_numLitNoAntiquot(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_numLitNoAntiquot___closed__1;
+x_2 = l_Lean_Parser_numLitNoAntiquot___closed__2;
+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_strLitFn___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_numLitNoAntiquot() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_numLitNoAntiquot___closed__3;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_strLitFn___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -11581,7 +10932,7 @@ x_1 = lean_mk_string("string literal");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_strLitFn___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_strLitFn(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; 
@@ -11595,14 +10946,14 @@ if (lean_obj_tag(x_5) == 0)
 lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
 x_6 = lean_ctor_get(x_4, 0);
 lean_inc(x_6);
-x_7 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_6);
+x_7 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_6);
 lean_dec(x_6);
 x_8 = l_Lean_strLitKind;
 x_9 = l_Lean_Syntax_isOfKind(x_7, x_8);
 if (x_9 == 0)
 {
 lean_object* x_10; lean_object* x_11; 
-x_10 = l_Lean_Parser_strLitFn___rarg___closed__1;
+x_10 = l_Lean_Parser_strLitFn___closed__1;
 x_11 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_10, x_3);
 return x_11;
 }
@@ -11616,31 +10967,12 @@ else
 {
 lean_object* x_12; lean_object* x_13; 
 lean_dec(x_5);
-x_12 = l_Lean_Parser_strLitFn___rarg___closed__1;
+x_12 = l_Lean_Parser_strLitFn___closed__1;
 x_13 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_12, x_3);
 return x_13;
 }
 }
 }
-lean_object* l_Lean_Parser_strLitFn(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_strLitFn___rarg), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_strLitFn___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_strLitFn(x_3, x_2);
-lean_dec(x_2);
-return x_4;
-}
-}
 lean_object* _init_l_Lean_Parser_strLitNoAntiquot___closed__1() {
 _start:
 {
@@ -11650,31 +10982,35 @@ x_2 = l_Lean_Parser_mkAtomicInfo(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_strLitNoAntiquot(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_strLitNoAntiquot___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_strLitFn___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_strLitNoAntiquot___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_strLitFn), 2, 0);
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_strLitNoAntiquot___boxed(lean_object* x_1) {
+lean_object* _init_l_Lean_Parser_strLitNoAntiquot___closed__3() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_strLitNoAntiquot(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_strLitNoAntiquot___closed__1;
+x_2 = l_Lean_Parser_strLitNoAntiquot___closed__2;
+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_charLitFn___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_strLitNoAntiquot() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_strLitNoAntiquot___closed__3;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_charLitFn___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -11682,7 +11018,7 @@ x_1 = lean_mk_string("character literal");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_charLitFn___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_charLitFn(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; 
@@ -11696,14 +11032,14 @@ if (lean_obj_tag(x_5) == 0)
 lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
 x_6 = lean_ctor_get(x_4, 0);
 lean_inc(x_6);
-x_7 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_6);
+x_7 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_6);
 lean_dec(x_6);
 x_8 = l_Lean_charLitKind;
 x_9 = l_Lean_Syntax_isOfKind(x_7, x_8);
 if (x_9 == 0)
 {
 lean_object* x_10; lean_object* x_11; 
-x_10 = l_Lean_Parser_charLitFn___rarg___closed__1;
+x_10 = l_Lean_Parser_charLitFn___closed__1;
 x_11 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_10, x_3);
 return x_11;
 }
@@ -11717,31 +11053,12 @@ else
 {
 lean_object* x_12; lean_object* x_13; 
 lean_dec(x_5);
-x_12 = l_Lean_Parser_charLitFn___rarg___closed__1;
+x_12 = l_Lean_Parser_charLitFn___closed__1;
 x_13 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_12, x_3);
 return x_13;
 }
 }
 }
-lean_object* l_Lean_Parser_charLitFn(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_charLitFn___rarg), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_charLitFn___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_charLitFn(x_3, x_2);
-lean_dec(x_2);
-return x_4;
-}
-}
 lean_object* _init_l_Lean_Parser_charLitNoAntiquot___closed__1() {
 _start:
 {
@@ -11751,31 +11068,35 @@ x_2 = l_Lean_Parser_mkAtomicInfo(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_charLitNoAntiquot(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_charLitNoAntiquot___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_charLitFn___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_charLitNoAntiquot___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_charLitFn), 2, 0);
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_charLitNoAntiquot___boxed(lean_object* x_1) {
+lean_object* _init_l_Lean_Parser_charLitNoAntiquot___closed__3() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_charLitNoAntiquot(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_charLitNoAntiquot___closed__1;
+x_2 = l_Lean_Parser_charLitNoAntiquot___closed__2;
+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_nameLitFn___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_charLitNoAntiquot() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_charLitNoAntiquot___closed__3;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_nameLitFn___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -11783,7 +11104,7 @@ x_1 = lean_mk_string("Name literal");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_nameLitFn___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_nameLitFn(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; 
@@ -11797,14 +11118,14 @@ if (lean_obj_tag(x_5) == 0)
 lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
 x_6 = lean_ctor_get(x_4, 0);
 lean_inc(x_6);
-x_7 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_6);
+x_7 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_6);
 lean_dec(x_6);
 x_8 = l_Lean_nameLitKind;
 x_9 = l_Lean_Syntax_isOfKind(x_7, x_8);
 if (x_9 == 0)
 {
 lean_object* x_10; lean_object* x_11; 
-x_10 = l_Lean_Parser_nameLitFn___rarg___closed__1;
+x_10 = l_Lean_Parser_nameLitFn___closed__1;
 x_11 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_10, x_3);
 return x_11;
 }
@@ -11818,31 +11139,12 @@ else
 {
 lean_object* x_12; lean_object* x_13; 
 lean_dec(x_5);
-x_12 = l_Lean_Parser_nameLitFn___rarg___closed__1;
+x_12 = l_Lean_Parser_nameLitFn___closed__1;
 x_13 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_12, x_3);
 return x_13;
 }
 }
 }
-lean_object* l_Lean_Parser_nameLitFn(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_nameLitFn___rarg), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_nameLitFn___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_nameLitFn(x_3, x_2);
-lean_dec(x_2);
-return x_4;
-}
-}
 lean_object* _init_l_Lean_Parser_nameLitNoAntiquot___closed__1() {
 _start:
 {
@@ -11852,31 +11154,35 @@ x_2 = l_Lean_Parser_mkAtomicInfo(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_nameLitNoAntiquot(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_nameLitNoAntiquot___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_nameLitFn___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_nameLitNoAntiquot___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_nameLitFn), 2, 0);
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_nameLitNoAntiquot___boxed(lean_object* x_1) {
+lean_object* _init_l_Lean_Parser_nameLitNoAntiquot___closed__3() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_nameLitNoAntiquot(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_nameLitNoAntiquot___closed__1;
+x_2 = l_Lean_Parser_nameLitNoAntiquot___closed__2;
+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_identFn___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_nameLitNoAntiquot() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_nameLitNoAntiquot___closed__3;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_identFn___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -11884,7 +11190,7 @@ x_1 = lean_mk_string("identifier");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_identFn___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_identFn(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; 
@@ -11898,14 +11204,14 @@ if (lean_obj_tag(x_5) == 0)
 lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_4, 0);
 lean_inc(x_6);
-x_7 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_6);
+x_7 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_6);
 lean_dec(x_6);
 x_8 = l_Lean_Syntax_isIdent(x_7);
 lean_dec(x_7);
 if (x_8 == 0)
 {
 lean_object* x_9; lean_object* x_10; 
-x_9 = l_Lean_Parser_identFn___rarg___closed__1;
+x_9 = l_Lean_Parser_identFn___closed__1;
 x_10 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_9, x_3);
 return x_10;
 }
@@ -11919,31 +11225,12 @@ else
 {
 lean_object* x_11; lean_object* x_12; 
 lean_dec(x_5);
-x_11 = l_Lean_Parser_identFn___rarg___closed__1;
+x_11 = l_Lean_Parser_identFn___closed__1;
 x_12 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_11, x_3);
 return x_12;
 }
 }
 }
-lean_object* l_Lean_Parser_identFn(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_identFn___rarg), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_identFn___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_identFn(x_3, x_2);
-lean_dec(x_2);
-return x_4;
-}
-}
 lean_object* _init_l_Lean_Parser_identNoAntiquot___closed__1() {
 _start:
 {
@@ -11953,79 +11240,63 @@ x_2 = l_Lean_Parser_mkAtomicInfo(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_identNoAntiquot(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_identNoAntiquot___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_identFn___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_identNoAntiquot___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_identFn), 2, 0);
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_identNoAntiquot___boxed(lean_object* x_1) {
+lean_object* _init_l_Lean_Parser_identNoAntiquot___closed__3() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_identNoAntiquot(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_identNoAntiquot___closed__1;
+x_2 = l_Lean_Parser_identNoAntiquot___closed__2;
+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* l_Lean_Parser_rawIdentNoAntiquot___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* _init_l_Lean_Parser_identNoAntiquot() {
 _start:
 {
-lean_object* x_4; 
-x_4 = l_Lean_Parser_rawIdentFn(x_2, x_3);
-return x_4;
+lean_object* x_1; 
+x_1 = l_Lean_Parser_identNoAntiquot___closed__3;
+return x_1;
 }
 }
 lean_object* _init_l_Lean_Parser_rawIdentNoAntiquot___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_rawIdentNoAntiquot___lambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_rawIdentFn___boxed), 2, 0);
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_rawIdentNoAntiquot(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_rawIdentNoAntiquot___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_3 = l_Lean_Parser_rawIdentNoAntiquot___closed__1;
-x_4 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_rawIdentNoAntiquot___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Lean_Parser_rawIdentNoAntiquot___lambda__1(x_1, x_2, x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_rawIdentNoAntiquot___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_rawIdentNoAntiquot(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_2 = l_Lean_Parser_rawIdentNoAntiquot___closed__1;
+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_identEqFn___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_rawIdentNoAntiquot() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_rawIdentNoAntiquot___closed__2;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_identEqFn___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -12033,118 +11304,81 @@ x_1 = lean_mk_string("expected identifier '");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_identEqFn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_identEqFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_tokenFn(x_3, x_4);
-x_7 = lean_ctor_get(x_6, 3);
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_tokenFn(x_2, x_3);
+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; 
+x_7 = lean_ctor_get(x_5, 0);
 lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
-{
-lean_object* x_8; lean_object* x_9; 
-x_8 = lean_ctor_get(x_6, 0);
-lean_inc(x_8);
-x_9 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_8);
-lean_dec(x_8);
-if (lean_obj_tag(x_9) == 3)
-{
-lean_object* x_10; uint8_t x_11; 
-x_10 = lean_ctor_get(x_9, 2);
-lean_inc(x_10);
-lean_dec(x_9);
-x_11 = lean_name_eq(x_10, x_1);
-lean_dec(x_10);
-if (x_11 == 0)
-{
-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; 
-x_12 = l_Lean_Name_toString___closed__1;
-x_13 = l_Lean_Name_toStringWithSep___main(x_12, x_1);
-x_14 = l_Lean_Parser_identEqFn___rarg___closed__1;
-x_15 = lean_string_append(x_14, x_13);
-lean_dec(x_13);
-x_16 = l_Char_HasRepr___closed__1;
-x_17 = lean_string_append(x_15, x_16);
-x_18 = l_Lean_Parser_ParserState_mkErrorAt(x_6, x_17, x_5);
-return x_18;
-}
-else
-{
-lean_dec(x_5);
-lean_dec(x_1);
-return x_6;
-}
-}
-else
-{
-lean_object* x_19; lean_object* x_20; 
-lean_dec(x_9);
-lean_dec(x_1);
-x_19 = l_Lean_Parser_identFn___rarg___closed__1;
-x_20 = l_Lean_Parser_ParserState_mkErrorAt(x_6, x_19, x_5);
-return x_20;
-}
-}
-else
-{
-lean_object* x_21; lean_object* x_22; 
+x_8 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_7);
 lean_dec(x_7);
+if (lean_obj_tag(x_8) == 3)
+{
+lean_object* x_9; uint8_t x_10; 
+x_9 = lean_ctor_get(x_8, 2);
+lean_inc(x_9);
+lean_dec(x_8);
+x_10 = lean_name_eq(x_9, x_1);
+lean_dec(x_9);
+if (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; lean_object* x_17; 
+x_11 = l_Lean_Name_toString___closed__1;
+x_12 = l_Lean_Name_toStringWithSep___main(x_11, x_1);
+x_13 = l_Lean_Parser_identEqFn___closed__1;
+x_14 = lean_string_append(x_13, x_12);
+lean_dec(x_12);
+x_15 = l_Char_HasRepr___closed__1;
+x_16 = lean_string_append(x_14, x_15);
+x_17 = l_Lean_Parser_ParserState_mkErrorAt(x_5, x_16, x_4);
+return x_17;
+}
+else
+{
+lean_dec(x_4);
 lean_dec(x_1);
-x_21 = l_Lean_Parser_identFn___rarg___closed__1;
-x_22 = l_Lean_Parser_ParserState_mkErrorAt(x_6, x_21, x_5);
-return x_22;
-}
-}
-}
-lean_object* l_Lean_Parser_identEqFn(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_identEqFn___rarg___boxed), 4, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_identEqFn___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_identEqFn___rarg(x_1, x_2, x_3, x_4);
-lean_dec(x_2);
 return x_5;
 }
 }
-lean_object* l_Lean_Parser_identEqFn___boxed(lean_object* x_1) {
-_start:
+else
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
+lean_object* x_18; lean_object* x_19; 
+lean_dec(x_8);
 lean_dec(x_1);
-x_3 = l_Lean_Parser_identEqFn(x_2);
-return x_3;
+x_18 = l_Lean_Parser_identFn___closed__1;
+x_19 = l_Lean_Parser_ParserState_mkErrorAt(x_5, x_18, x_4);
+return x_19;
 }
 }
-lean_object* l_Lean_Parser_identEq(uint8_t x_1, lean_object* x_2) {
-_start:
+else
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_identEqFn___rarg___boxed), 4, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_identNoAntiquot___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_identEq___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
+lean_object* x_20; lean_object* x_21; 
+lean_dec(x_6);
 lean_dec(x_1);
-x_4 = l_Lean_Parser_identEq(x_3, x_2);
+x_20 = l_Lean_Parser_identFn___closed__1;
+x_21 = l_Lean_Parser_ParserState_mkErrorAt(x_5, x_20, x_4);
+return x_21;
+}
+}
+}
+lean_object* l_Lean_Parser_identEq(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_identEqFn), 3, 1);
+lean_closure_set(x_2, 0, x_1);
+x_3 = l_Lean_Parser_identNoAntiquot___closed__1;
+x_4 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_4, 0, x_3);
+lean_ctor_set(x_4, 1, x_2);
 return x_4;
 }
 }
@@ -12272,141 +11506,107 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_quotedSymbolFn(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_quotedSymbolFn(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint32_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_5 = 96;
-x_6 = lean_ctor_get(x_4, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_29 = lean_ctor_get(x_4, 1);
-lean_inc(x_29);
-x_30 = l_Lean_Parser_quotedSymbolFn___closed__5;
-x_31 = l_Lean_Parser_satisfyFn___at_Lean_Parser_quotedSymbolFn___spec__1(x_5, x_30, x_3, x_4);
-x_32 = lean_ctor_get(x_31, 3);
-lean_inc(x_32);
-if (lean_obj_tag(x_32) == 0)
+uint32_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_3 = 96;
+x_4 = lean_ctor_get(x_2, 0);
+lean_inc(x_4);
+x_5 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_21 = lean_ctor_get(x_2, 1);
+lean_inc(x_21);
+x_22 = l_Lean_Parser_quotedSymbolFn___closed__5;
+x_23 = l_Lean_Parser_satisfyFn___at_Lean_Parser_quotedSymbolFn___spec__1(x_3, x_22, x_1, x_2);
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
 {
-uint8_t x_33; lean_object* x_34; lean_object* x_35; 
-x_33 = 0;
-x_34 = l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(x_29, x_33, x_2, x_3, x_31);
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
+uint8_t x_25; lean_object* x_26; lean_object* x_27; 
+x_25 = 0;
+x_26 = l___private_Init_Lean_Parser_Parser_3__rawAux(x_21, x_25, x_1, x_23);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-x_37 = l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_quotedSymbolFn___spec__2(x_5, x_3, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = lean_ctor_get(x_26, 1);
+lean_inc(x_28);
+x_29 = l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_quotedSymbolFn___spec__2(x_3, x_1, x_26);
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_39; 
-x_39 = l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(x_36, x_33, x_2, x_3, x_37);
-x_8 = x_39;
-goto block_28;
+lean_object* x_31; 
+x_31 = l___private_Init_Lean_Parser_Parser_3__rawAux(x_28, x_25, x_1, x_29);
+x_6 = x_31;
+goto block_20;
 }
 else
 {
-lean_dec(x_38);
-lean_dec(x_36);
-x_8 = x_37;
-goto block_28;
+lean_dec(x_30);
+lean_dec(x_28);
+x_6 = x_29;
+goto block_20;
 }
 }
 else
 {
-lean_dec(x_35);
-x_8 = x_34;
-goto block_28;
+lean_dec(x_27);
+x_6 = x_26;
+goto block_20;
 }
 }
 else
 {
-lean_dec(x_32);
-lean_dec(x_29);
-x_8 = x_31;
-goto block_28;
+lean_dec(x_24);
+lean_dec(x_21);
+x_6 = x_23;
+goto block_20;
 }
-block_28:
+block_20:
 {
-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_7; 
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = l_Lean_Parser_quotedSymbolFn___closed__5;
-x_12 = l_Lean_Parser_satisfyFn___at_Lean_Parser_quotedSymbolFn___spec__1(x_5, x_11, x_3, x_8);
-x_13 = lean_ctor_get(x_12, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = l_Lean_Parser_quotedSymbolFn___closed__5;
+x_10 = l_Lean_Parser_satisfyFn___at_Lean_Parser_quotedSymbolFn___spec__1(x_3, x_9, x_1, x_6);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
 {
-uint8_t x_14; lean_object* x_15; 
-x_14 = 1;
-x_15 = l___private_Init_Lean_Parser_Parser_3__rawAux___rarg(x_10, x_14, x_2, x_3, x_12);
-if (x_1 == 0)
+uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_12 = 1;
+x_13 = l___private_Init_Lean_Parser_Parser_3__rawAux(x_8, x_12, x_1, x_10);
+x_14 = l_Lean_Parser_quotedSymbolFn___closed__2;
+x_15 = l_Lean_Parser_ParserState_mkNode(x_13, x_14, x_5);
+return x_15;
+}
+else
 {
 lean_object* x_16; lean_object* x_17; 
+lean_dec(x_11);
+lean_dec(x_8);
 x_16 = l_Lean_Parser_quotedSymbolFn___closed__2;
-x_17 = l_Lean_Parser_ParserState_mkNode(x_15, x_16, x_7);
+x_17 = l_Lean_Parser_ParserState_mkNode(x_10, x_16, x_5);
 return x_17;
 }
+}
 else
 {
 lean_object* x_18; lean_object* x_19; 
+lean_dec(x_7);
 x_18 = l_Lean_Parser_quotedSymbolFn___closed__2;
-x_19 = l_Lean_Parser_ParserState_mkTrailingNode(x_15, x_18, x_7);
-lean_dec(x_7);
+x_19 = l_Lean_Parser_ParserState_mkNode(x_6, x_18, x_5);
 return x_19;
 }
 }
-else
-{
-lean_dec(x_13);
-lean_dec(x_10);
-if (x_1 == 0)
-{
-lean_object* x_20; lean_object* x_21; 
-x_20 = l_Lean_Parser_quotedSymbolFn___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_12, x_20, x_7);
-return x_21;
-}
-else
-{
-lean_object* x_22; lean_object* x_23; 
-x_22 = l_Lean_Parser_quotedSymbolFn___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkTrailingNode(x_12, x_22, x_7);
-lean_dec(x_7);
-return x_23;
-}
-}
-}
-else
-{
-lean_dec(x_9);
-if (x_1 == 0)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = l_Lean_Parser_quotedSymbolFn___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_8, x_24, x_7);
-return x_25;
-}
-else
-{
-lean_object* x_26; lean_object* x_27; 
-x_26 = l_Lean_Parser_quotedSymbolFn___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_26, x_7);
-lean_dec(x_7);
-return x_27;
-}
-}
-}
 }
 }
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_quotedSymbolFn___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
@@ -12431,63 +11631,44 @@ lean_dec(x_2);
 return x_5;
 }
 }
-lean_object* l_Lean_Parser_quotedSymbolFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_quotedSymbolFn___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
+lean_object* x_3; 
+x_3 = l_Lean_Parser_quotedSymbolFn(x_1, x_2);
 lean_dec(x_1);
-x_6 = l_Lean_Parser_quotedSymbolFn(x_5, x_2, x_3, x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_quotedSymbol___elambda__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_quotedSymbolFn(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_quotedSymbol(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_quotedSymbol___elambda__1___boxed), 4, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_quotedSymbol___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_quotedSymbol___elambda__1(x_5, x_2, x_3, x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_quotedSymbol___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_quotedSymbol(x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_unquotedSymbolFn___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_quotedSymbol___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_quotedSymbolFn___boxed), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_quotedSymbol___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_2 = l_Lean_Parser_quotedSymbol___closed__1;
+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_quotedSymbol() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_quotedSymbol___closed__2;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_unquotedSymbolFn___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -12495,7 +11676,7 @@ x_1 = lean_mk_string("symbol");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_unquotedSymbolFn___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_unquotedSymbolFn(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; 
@@ -12509,7 +11690,7 @@ if (lean_obj_tag(x_5) == 0)
 lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_4, 0);
 lean_inc(x_6);
-x_7 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_6);
+x_7 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_6);
 lean_dec(x_6);
 x_8 = l_Lean_Syntax_isIdent(x_7);
 if (x_8 == 0)
@@ -12526,7 +11707,7 @@ return x_4;
 else
 {
 lean_object* x_11; lean_object* x_12; 
-x_11 = l_Lean_Parser_unquotedSymbolFn___rarg___closed__1;
+x_11 = l_Lean_Parser_unquotedSymbolFn___closed__1;
 x_12 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_11, x_3);
 return x_12;
 }
@@ -12535,7 +11716,7 @@ else
 {
 lean_object* x_13; lean_object* x_14; 
 lean_dec(x_7);
-x_13 = l_Lean_Parser_unquotedSymbolFn___rarg___closed__1;
+x_13 = l_Lean_Parser_unquotedSymbolFn___closed__1;
 x_14 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_13, x_3);
 return x_14;
 }
@@ -12544,107 +11725,63 @@ else
 {
 lean_object* x_15; lean_object* x_16; 
 lean_dec(x_5);
-x_15 = l_Lean_Parser_unquotedSymbolFn___rarg___closed__1;
+x_15 = l_Lean_Parser_unquotedSymbolFn___closed__1;
 x_16 = l_Lean_Parser_ParserState_mkErrorAt(x_4, x_15, x_3);
 return x_16;
 }
 }
 }
-lean_object* l_Lean_Parser_unquotedSymbolFn(uint8_t x_1, lean_object* x_2) {
+lean_object* _init_l_Lean_Parser_unquotedSymbol___closed__1() {
 _start:
 {
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_unquotedSymbolFn___rarg), 2, 0);
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_unquotedSymbolFn), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_unquotedSymbol___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_2 = l_Lean_Parser_unquotedSymbol___closed__1;
+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* l_Lean_Parser_unquotedSymbolFn___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* _init_l_Lean_Parser_unquotedSymbol() {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
+lean_object* x_1; 
+x_1 = l_Lean_Parser_unquotedSymbol___closed__2;
+return x_1;
+}
+}
+lean_object* l_Lean_Parser_stringToParserCoe(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = lean_box(0);
+x_3 = l_String_trim(x_1);
+lean_inc(x_3);
+x_4 = l_Lean_Parser_symbolInfo(x_3, x_2);
+x_5 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
+lean_closure_set(x_5, 0, x_3);
+x_6 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_5);
+return x_6;
+}
+}
+lean_object* l_Lean_Parser_stringToParserCoe___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_Lean_Parser_stringToParserCoe(x_1);
 lean_dec(x_1);
-x_4 = l_Lean_Parser_unquotedSymbolFn(x_3, x_2);
-lean_dec(x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_unquotedSymbol___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Lean_Parser_unquotedSymbolFn___rarg(x_1, x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_unquotedSymbol___elambda__1(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_unquotedSymbol___elambda__1___rarg), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_unquotedSymbol(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_unquotedSymbol___elambda__1___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_unquotedSymbol___elambda__1___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_unquotedSymbol___elambda__1(x_3, x_2);
-lean_dec(x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_unquotedSymbol___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_unquotedSymbol(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_string2basic(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_3 = lean_box(0);
-x_4 = l_String_trim(x_2);
-lean_inc(x_4);
-x_5 = l_Lean_Parser_symbolInfo(x_4, x_3);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
-lean_closure_set(x_6, 0, x_4);
-x_7 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_7, 0, x_5);
-lean_ctor_set(x_7, 1, x_6);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_string2basic___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_string2basic(x_3, x_2);
-lean_dec(x_2);
-return x_4;
+return x_2;
 }
 }
 lean_object* l_Lean_Parser_ParserState_keepNewError(lean_object* x_1, lean_object* x_2) {
@@ -13001,7 +12138,7 @@ lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_obj
 x_4 = lean_ctor_get(x_1, 0);
 x_5 = lean_ctor_get(x_1, 3);
 lean_dec(x_5);
-x_6 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_4);
+x_6 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_4);
 x_7 = l_Array_shrink___main___rarg(x_4, x_2);
 x_8 = lean_array_push(x_7, x_6);
 x_9 = lean_box(0);
@@ -13019,7 +12156,7 @@ lean_inc(x_12);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_dec(x_1);
-x_13 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_10);
+x_13 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_10);
 x_14 = l_Array_shrink___main___rarg(x_10, x_2);
 x_15 = lean_array_push(x_14, x_13);
 x_16 = lean_box(0);
@@ -13059,160 +12196,142 @@ lean_dec(x_2);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_longestMatchStep___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_longestMatchStep(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_7 = lean_ctor_get(x_6, 3);
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_5, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_6, 1);
+x_8 = lean_ctor_get(x_5, 0);
 lean_inc(x_8);
-x_9 = lean_ctor_get(x_6, 0);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
-lean_dec(x_9);
-x_11 = l_Lean_Parser_ParserState_restore(x_6, x_10, x_2);
-x_12 = lean_apply_3(x_3, x_4, x_5, x_11);
-if (lean_obj_tag(x_7) == 0)
+x_9 = lean_array_get_size(x_8);
+lean_dec(x_8);
+x_10 = l_Lean_Parser_ParserState_restore(x_5, x_9, x_2);
+x_11 = lean_apply_2(x_3, x_4, x_10);
+if (lean_obj_tag(x_6) == 0)
 {
-lean_object* x_13; 
-x_13 = lean_ctor_get(x_12, 3);
+lean_object* x_12; 
+x_12 = lean_ctor_get(x_11, 3);
+lean_inc(x_12);
+if (lean_obj_tag(x_12) == 0)
+{
+lean_object* x_13; uint8_t x_14; 
+x_13 = lean_ctor_get(x_11, 1);
 lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+x_14 = lean_nat_dec_lt(x_7, x_13);
+if (x_14 == 0)
 {
-lean_object* x_14; uint8_t x_15; 
-x_14 = lean_ctor_get(x_12, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_lt(x_8, x_14);
+uint8_t x_15; 
+x_15 = lean_nat_dec_lt(x_13, x_7);
+lean_dec(x_13);
 if (x_15 == 0)
 {
-uint8_t x_16; 
-x_16 = lean_nat_dec_lt(x_14, x_8);
-lean_dec(x_14);
-if (x_16 == 0)
+lean_object* x_16; 
+lean_dec(x_7);
+x_16 = l_Lean_Parser_ParserState_mkLongestNodeAlt(x_11, x_9);
+return x_16;
+}
+else
 {
 lean_object* x_17; 
-lean_dec(x_8);
-x_17 = l_Lean_Parser_ParserState_mkLongestNodeAlt(x_12, x_10);
+x_17 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_7);
+lean_dec(x_9);
 return x_17;
 }
+}
 else
 {
 lean_object* x_18; 
-x_18 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_8);
-lean_dec(x_10);
+lean_dec(x_13);
+lean_dec(x_7);
+x_18 = l_Lean_Parser_ParserState_replaceLongest(x_11, x_1, x_9);
 return x_18;
 }
 }
 else
 {
 lean_object* x_19; 
-lean_dec(x_14);
-lean_dec(x_8);
-x_19 = l_Lean_Parser_ParserState_replaceLongest(x_12, x_1, x_10);
+lean_dec(x_12);
+x_19 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_7);
+lean_dec(x_9);
 return x_19;
 }
 }
 else
 {
 lean_object* x_20; 
-lean_dec(x_13);
-x_20 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_8);
-lean_dec(x_10);
-return x_20;
-}
-}
-else
+x_20 = lean_ctor_get(x_11, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_12, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-lean_dec(x_8);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
 lean_dec(x_7);
-x_22 = l_Lean_Parser_ParserState_mkLongestNodeAlt(x_12, x_10);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-x_24 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_23);
-lean_dec(x_23);
-x_25 = l_Lean_Parser_ParserState_shrinkStack(x_22, x_1);
-x_26 = l_Lean_Parser_ParserState_pushSyntax(x_25, x_24);
-return x_26;
+lean_dec(x_6);
+x_21 = l_Lean_Parser_ParserState_mkLongestNodeAlt(x_11, x_9);
+x_22 = lean_ctor_get(x_21, 0);
+lean_inc(x_22);
+x_23 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_22);
+lean_dec(x_22);
+x_24 = l_Lean_Parser_ParserState_shrinkStack(x_21, x_1);
+x_25 = l_Lean_Parser_ParserState_pushSyntax(x_24, x_23);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; uint8_t x_29; 
-lean_dec(x_21);
-x_27 = lean_ctor_get(x_7, 0);
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+lean_dec(x_20);
+x_26 = lean_ctor_get(x_6, 0);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_11, 1);
 lean_inc(x_27);
-x_28 = lean_ctor_get(x_12, 1);
-lean_inc(x_28);
-x_29 = lean_nat_dec_lt(x_8, x_28);
+x_28 = lean_nat_dec_lt(x_7, x_27);
+if (x_28 == 0)
+{
+uint8_t x_29; 
+x_29 = lean_nat_dec_lt(x_27, x_7);
+lean_dec(x_27);
 if (x_29 == 0)
 {
-uint8_t x_30; 
-x_30 = lean_nat_dec_lt(x_28, x_8);
-lean_dec(x_28);
-if (x_30 == 0)
+lean_object* x_30; 
+lean_dec(x_7);
+lean_dec(x_6);
+x_30 = l_Lean_Parser_ParserState_mergeErrors(x_11, x_9, x_26);
+lean_dec(x_9);
+return x_30;
+}
+else
 {
 lean_object* x_31; 
-lean_dec(x_8);
-lean_dec(x_7);
-x_31 = l_Lean_Parser_ParserState_mergeErrors(x_12, x_10, x_27);
-lean_dec(x_10);
+lean_dec(x_26);
+x_31 = l_Lean_Parser_ParserState_keepPrevError(x_11, x_9, x_7, x_6);
+lean_dec(x_9);
 return x_31;
 }
+}
 else
 {
 lean_object* x_32; 
 lean_dec(x_27);
-x_32 = l_Lean_Parser_ParserState_keepPrevError(x_12, x_10, x_8, x_7);
-lean_dec(x_10);
+lean_dec(x_26);
+lean_dec(x_7);
+lean_dec(x_6);
+x_32 = l_Lean_Parser_ParserState_keepNewError(x_11, x_9);
+lean_dec(x_9);
 return x_32;
 }
 }
-else
-{
-lean_object* x_33; 
-lean_dec(x_28);
-lean_dec(x_27);
-lean_dec(x_8);
-lean_dec(x_7);
-x_33 = l_Lean_Parser_ParserState_keepNewError(x_12, x_10);
-lean_dec(x_10);
-return x_33;
 }
 }
 }
-}
-}
-lean_object* l_Lean_Parser_longestMatchStep(uint8_t x_1) {
+lean_object* l_Lean_Parser_longestMatchStep___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_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_longestMatchStep___rarg___boxed), 6, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_longestMatchStep___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
-_start:
-{
-lean_object* x_7; 
-x_7 = l_Lean_Parser_longestMatchStep___rarg(x_1, x_2, x_3, x_4, x_5, x_6);
+lean_object* x_6; 
+x_6 = l_Lean_Parser_longestMatchStep(x_1, x_2, x_3, x_4, x_5);
 lean_dec(x_1);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_longestMatchStep___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_longestMatchStep(x_2);
-return x_3;
+return x_6;
 }
 }
 lean_object* l_Lean_Parser_longestMatchMkResult(lean_object* x_1, lean_object* x_2) {
@@ -13254,110 +12373,70 @@ return x_2;
 }
 }
 }
-lean_object* l_Lean_Parser_longestMatchFnAux___main(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_longestMatchFnAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-if (lean_obj_tag(x_4) == 0)
+if (lean_obj_tag(x_3) == 0)
 {
-lean_object* x_8; 
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_3);
-x_8 = l_Lean_Parser_longestMatchMkResult(x_2, x_7);
-return x_8;
+lean_object* x_6; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_6 = l_Lean_Parser_longestMatchMkResult(x_1, x_5);
+return x_6;
 }
 else
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_9 = lean_ctor_get(x_4, 0);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_3, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_3, 1);
+lean_inc(x_8);
+lean_dec(x_3);
+x_9 = lean_ctor_get(x_7, 1);
 lean_inc(x_9);
-x_10 = lean_ctor_get(x_4, 1);
-lean_inc(x_10);
-lean_dec(x_4);
-x_11 = lean_ctor_get(x_9, 1);
-lean_inc(x_11);
-lean_dec(x_9);
-lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_3);
-x_12 = l_Lean_Parser_longestMatchStep___rarg(x_2, x_3, x_11, x_5, x_6, x_7);
-x_4 = x_10;
-x_7 = x_12;
+lean_dec(x_7);
+lean_inc(x_4);
+lean_inc(x_2);
+x_10 = l_Lean_Parser_longestMatchStep(x_1, x_2, x_9, x_4, x_5);
+x_3 = x_8;
+x_5 = x_10;
 goto _start;
 }
 }
 }
-lean_object* l_Lean_Parser_longestMatchFnAux___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_longestMatchFnAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-uint8_t x_8; lean_object* x_9; 
-x_8 = lean_unbox(x_1);
-lean_dec(x_1);
-x_9 = l_Lean_Parser_longestMatchFnAux___main(x_8, x_2, x_3, x_4, x_5, x_6, x_7);
-return x_9;
+lean_object* x_6; 
+x_6 = l_Lean_Parser_longestMatchFnAux___main(x_1, x_2, x_3, x_4, x_5);
+return x_6;
 }
 }
-lean_object* l_Lean_Parser_longestMatchFnAux(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_longestMatchFn_u2081(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; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_6 = lean_apply_2(x_1, x_2, x_3);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
 lean_object* x_8; 
-x_8 = l_Lean_Parser_longestMatchFnAux___main(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+x_8 = l_Lean_Parser_ParserState_mkLongestNodeAlt(x_6, x_5);
 return x_8;
 }
-}
-lean_object* l_Lean_Parser_longestMatchFnAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-uint8_t x_8; lean_object* x_9; 
-x_8 = lean_unbox(x_1);
-lean_dec(x_1);
-x_9 = l_Lean_Parser_longestMatchFnAux(x_8, x_2, x_3, x_4, x_5, x_6, x_7);
-return x_9;
-}
-}
-lean_object* l_Lean_Parser_longestMatchFn_u2081___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; lean_object* x_8; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_apply_3(x_1, x_2, x_3, x_4);
-x_8 = lean_ctor_get(x_7, 3);
-lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; 
-x_9 = l_Lean_Parser_ParserState_mkLongestNodeAlt(x_7, x_6);
-return x_9;
-}
 else
 {
-lean_dec(x_8);
-lean_dec(x_6);
-return x_7;
+lean_dec(x_7);
+lean_dec(x_5);
+return x_6;
 }
 }
 }
-lean_object* l_Lean_Parser_longestMatchFn_u2081(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_longestMatchFn_u2081___rarg), 4, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_longestMatchFn_u2081___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_longestMatchFn_u2081(x_2);
-return x_3;
-}
-}
 lean_object* _init_l_Lean_Parser_longestMatchFn___closed__1() {
 _start:
 {
@@ -13366,85 +12445,73 @@ x_1 = lean_mk_string("longestMatch: empty list");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_longestMatchFn(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_longestMatchFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-if (lean_obj_tag(x_2) == 0)
+if (lean_obj_tag(x_1) == 0)
 {
-lean_object* x_6; lean_object* x_7; 
-lean_dec(x_4);
-lean_dec(x_3);
-x_6 = l_Lean_Parser_longestMatchFn___closed__1;
-x_7 = l_Lean_Parser_ParserState_mkError(x_5, x_6);
-return x_7;
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = l_Lean_Parser_longestMatchFn___closed__1;
+x_5 = l_Lean_Parser_ParserState_mkError(x_3, x_4);
+return x_5;
 }
 else
 {
-lean_object* x_8; 
-x_8 = lean_ctor_get(x_2, 1);
+lean_object* x_6; 
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_ctor_get(x_7, 1);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_9 = lean_ctor_get(x_2, 0);
-lean_inc(x_9);
-lean_dec(x_2);
-x_10 = lean_ctor_get(x_9, 1);
-lean_inc(x_10);
-lean_dec(x_9);
-x_11 = l_Lean_Parser_longestMatchFn_u2081___rarg(x_10, x_3, x_4, x_5);
-return x_11;
+lean_dec(x_7);
+x_9 = l_Lean_Parser_longestMatchFn_u2081(x_8, x_2, x_3);
+return x_9;
 }
 else
 {
-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; 
-x_12 = lean_ctor_get(x_2, 0);
-lean_inc(x_12);
-lean_dec(x_2);
-x_13 = lean_ctor_get(x_5, 0);
+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; 
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_ctor_get(x_3, 0);
+lean_inc(x_11);
+x_12 = lean_array_get_size(x_11);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_3, 1);
 lean_inc(x_13);
-x_14 = lean_array_get_size(x_13);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_5, 1);
-lean_inc(x_15);
-x_16 = lean_ctor_get(x_12, 1);
+x_14 = lean_ctor_get(x_10, 1);
+lean_inc(x_14);
+lean_dec(x_10);
+lean_inc(x_2);
+x_15 = lean_apply_2(x_14, x_2, x_3);
+x_16 = lean_ctor_get(x_15, 3);
 lean_inc(x_16);
-lean_dec(x_12);
-lean_inc(x_4);
-lean_inc(x_3);
-x_17 = lean_apply_3(x_16, x_3, x_4, x_5);
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+if (lean_obj_tag(x_16) == 0)
+{
+lean_object* x_17; lean_object* x_18; 
+lean_inc(x_12);
+x_17 = l_Lean_Parser_ParserState_mkLongestNodeAlt(x_15, x_12);
+x_18 = l_Lean_Parser_longestMatchFnAux___main(x_12, x_13, x_6, x_2, x_17);
+return x_18;
+}
+else
 {
 lean_object* x_19; lean_object* x_20; 
-lean_inc(x_14);
-x_19 = l_Lean_Parser_ParserState_mkLongestNodeAlt(x_17, x_14);
-x_20 = l_Lean_Parser_longestMatchFnAux___main(x_1, x_14, x_15, x_8, x_3, x_4, x_19);
+lean_dec(x_16);
+x_19 = l_Lean_Parser_ParserState_shrinkStack(x_15, x_12);
+x_20 = l_Lean_Parser_longestMatchFnAux___main(x_12, x_13, x_6, x_2, x_19);
 return x_20;
 }
-else
-{
-lean_object* x_21; lean_object* x_22; 
-lean_dec(x_18);
-x_21 = l_Lean_Parser_ParserState_shrinkStack(x_17, x_14);
-x_22 = l_Lean_Parser_longestMatchFnAux___main(x_1, x_14, x_15, x_8, x_3, x_4, x_21);
-return x_22;
 }
 }
 }
 }
-}
-lean_object* l_Lean_Parser_longestMatchFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l_Lean_Parser_longestMatchFn(x_6, x_2, x_3, x_4, x_5);
-return x_7;
-}
-}
 lean_object* _init_l_Lean_Parser_anyOfFn___main___closed__1() {
 _start:
 {
@@ -13453,126 +12520,102 @@ x_1 = lean_mk_string("anyOf: empty list");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_anyOfFn___main(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_anyOfFn___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-if (lean_obj_tag(x_2) == 0)
+if (lean_obj_tag(x_1) == 0)
 {
-lean_object* x_6; lean_object* x_7; 
-lean_dec(x_4);
-lean_dec(x_3);
-x_6 = l_Lean_Parser_anyOfFn___main___closed__1;
-x_7 = l_Lean_Parser_ParserState_mkError(x_5, x_6);
-return x_7;
-}
-else
-{
-lean_object* x_8; 
-x_8 = lean_ctor_get(x_2, 1);
-lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_9 = lean_ctor_get(x_2, 0);
-lean_inc(x_9);
+lean_object* x_4; lean_object* x_5; 
 lean_dec(x_2);
-x_10 = lean_ctor_get(x_9, 1);
-lean_inc(x_10);
-lean_dec(x_9);
-x_11 = lean_apply_3(x_10, x_3, x_4, x_5);
-return x_11;
+x_4 = l_Lean_Parser_anyOfFn___main___closed__1;
+x_5 = l_Lean_Parser_ParserState_mkError(x_3, x_4);
+return x_5;
 }
 else
 {
-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; 
-x_12 = lean_ctor_get(x_2, 0);
-lean_inc(x_12);
-lean_dec(x_2);
-x_13 = lean_ctor_get(x_12, 1);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_5, 0);
-lean_inc(x_14);
-x_15 = lean_array_get_size(x_14);
-lean_dec(x_14);
-x_16 = lean_ctor_get(x_5, 1);
-lean_inc(x_16);
-lean_inc(x_4);
-lean_inc(x_3);
-x_17 = lean_apply_3(x_13, x_3, x_4, x_5);
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_dec(x_16);
-lean_dec(x_15);
-lean_dec(x_8);
-lean_dec(x_4);
-lean_dec(x_3);
-return x_17;
-}
-else
-{
-lean_object* x_19; lean_object* x_20; uint8_t x_21; 
-x_19 = lean_ctor_get(x_18, 0);
-lean_inc(x_19);
-lean_dec(x_18);
-x_20 = lean_ctor_get(x_17, 1);
-lean_inc(x_20);
-x_21 = lean_nat_dec_eq(x_20, x_16);
-lean_dec(x_20);
-if (x_21 == 0)
-{
-lean_dec(x_19);
-lean_dec(x_16);
-lean_dec(x_15);
-lean_dec(x_8);
-lean_dec(x_4);
-lean_dec(x_3);
-return x_17;
-}
-else
-{
-lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-lean_inc(x_16);
-x_22 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
-lean_dec(x_15);
-x_23 = l_Lean_Parser_anyOfFn___main(x_1, x_8, x_3, x_4, x_22);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_19, x_16);
-lean_dec(x_16);
-return x_24;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_anyOfFn___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l_Lean_Parser_anyOfFn___main(x_6, x_2, x_3, x_4, x_5);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_anyOfFn(uint8_t 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_Parser_anyOfFn___main(x_1, x_2, x_3, x_4, x_5);
-return x_6;
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_ctor_get(x_7, 1);
+lean_inc(x_8);
+lean_dec(x_7);
+x_9 = lean_apply_2(x_8, x_2, x_3);
+return x_9;
+}
+else
+{
+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; 
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_ctor_get(x_10, 1);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_3, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+x_14 = lean_ctor_get(x_3, 1);
+lean_inc(x_14);
+lean_inc(x_2);
+x_15 = lean_apply_2(x_11, x_2, x_3);
+x_16 = lean_ctor_get(x_15, 3);
+lean_inc(x_16);
+if (lean_obj_tag(x_16) == 0)
+{
+lean_dec(x_14);
+lean_dec(x_13);
+lean_dec(x_6);
+lean_dec(x_2);
+return x_15;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; uint8_t x_19; 
+x_17 = lean_ctor_get(x_16, 0);
+lean_inc(x_17);
+lean_dec(x_16);
+x_18 = lean_ctor_get(x_15, 1);
+lean_inc(x_18);
+x_19 = lean_nat_dec_eq(x_18, x_14);
+lean_dec(x_18);
+if (x_19 == 0)
+{
+lean_dec(x_17);
+lean_dec(x_14);
+lean_dec(x_13);
+lean_dec(x_6);
+lean_dec(x_2);
+return x_15;
+}
+else
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+lean_inc(x_14);
+x_20 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
+lean_dec(x_13);
+x_21 = l_Lean_Parser_anyOfFn___main(x_6, x_2, x_20);
+x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_17, x_14);
+lean_dec(x_14);
+return x_22;
 }
 }
-lean_object* l_Lean_Parser_anyOfFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+}
+}
+}
+}
+lean_object* l_Lean_Parser_anyOfFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l_Lean_Parser_anyOfFn(x_6, x_2, x_3, x_4, x_5);
-return x_7;
+lean_object* x_4; 
+x_4 = l_Lean_Parser_anyOfFn___main(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* l_Lean_Parser_checkColGeFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
@@ -13613,73 +12656,353 @@ lean_dec(x_1);
 return x_5;
 }
 }
-lean_object* l_Lean_Parser_checkColGe___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_checkColGe(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_6 = lean_ctor_get(x_4, 0);
-x_7 = lean_ctor_get(x_6, 2);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
-x_9 = l_Lean_FileMap_toPosition(x_7, x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_9, 1);
-lean_inc(x_10);
-lean_dec(x_9);
-x_11 = lean_nat_dec_le(x_1, x_10);
-lean_dec(x_10);
-if (x_11 == 0)
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_checkColGeFn___boxed), 4, 2);
+lean_closure_set(x_3, 0, x_1);
+lean_closure_set(x_3, 1, x_2);
+x_4 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_5 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_5, 0, x_4);
+lean_ctor_set(x_5, 1, x_3);
+return x_5;
+}
+}
+lean_object* l_Lean_Parser_withPosition___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
 {
-lean_object* x_12; 
-x_12 = l_Lean_Parser_ParserState_mkError(x_5, x_2);
-return x_12;
+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 = lean_ctor_get(x_2, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_4, 2);
+lean_inc(x_5);
+lean_dec(x_4);
+x_6 = lean_ctor_get(x_3, 1);
+lean_inc(x_6);
+x_7 = l_Lean_FileMap_toPosition(x_5, x_6);
+lean_dec(x_6);
+lean_dec(x_5);
+x_8 = lean_apply_1(x_1, x_7);
+x_9 = lean_ctor_get(x_8, 1);
+lean_inc(x_9);
+lean_dec(x_8);
+x_10 = lean_apply_2(x_9, x_2, x_3);
+return x_10;
+}
+}
+lean_object* l_Lean_Parser_withPosition(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; uint8_t x_4; 
+x_2 = l_Lean_Position_Inhabited___closed__1;
+lean_inc(x_1);
+x_3 = lean_apply_1(x_1, x_2);
+x_4 = !lean_is_exclusive(x_3);
+if (x_4 == 0)
+{
+lean_object* x_5; lean_object* x_6; 
+x_5 = lean_ctor_get(x_3, 1);
+lean_dec(x_5);
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_withPosition___lambda__1), 3, 1);
+lean_closure_set(x_6, 0, x_1);
+lean_ctor_set(x_3, 1, x_6);
+return x_3;
 }
 else
 {
-lean_dec(x_2);
-return x_5;
-}
-}
-}
-lean_object* l_Lean_Parser_checkColGe(uint8_t 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_alloc_closure((void*)(l_Lean_Parser_checkColGe___lambda__1___boxed), 5, 2);
-lean_closure_set(x_4, 0, x_2);
-lean_closure_set(x_4, 1, x_3);
-x_5 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_6 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_6, 0, x_5);
-lean_ctor_set(x_6, 1, x_4);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_checkColGe___lambda__1___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_Parser_checkColGe___lambda__1(x_1, x_2, x_3, x_4, x_5);
-lean_dec(x_4);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_7 = lean_ctor_get(x_3, 0);
+lean_inc(x_7);
 lean_dec(x_3);
-lean_dec(x_1);
-return x_6;
+x_8 = lean_alloc_closure((void*)(l_Lean_Parser_withPosition___lambda__1), 3, 1);
+lean_closure_set(x_8, 0, x_1);
+x_9 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_9, 0, x_7);
+lean_ctor_set(x_9, 1, x_8);
+return x_9;
 }
 }
-lean_object* l_Lean_Parser_checkColGe___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+}
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
+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_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; 
+x_7 = lean_ctor_get(x_3, 0);
+x_8 = lean_ctor_get(x_7, 2);
+x_9 = lean_ctor_get(x_4, 1);
+x_10 = l_Lean_FileMap_toPosition(x_8, x_9);
+x_11 = lean_ctor_get(x_10, 1);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_1, 1);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_6, 0);
+lean_inc(x_13);
+x_14 = lean_array_get_size(x_13);
+lean_dec(x_13);
+x_15 = lean_ctor_get(x_6, 1);
+lean_inc(x_15);
+x_32 = lean_ctor_get(x_5, 0);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_32, 2);
+lean_inc(x_33);
+lean_dec(x_32);
+x_34 = l_Lean_FileMap_toPosition(x_33, x_15);
+lean_dec(x_33);
+x_35 = lean_ctor_get(x_34, 1);
+lean_inc(x_35);
+lean_dec(x_34);
+x_36 = lean_nat_dec_le(x_11, x_35);
+lean_dec(x_35);
+lean_dec(x_11);
+if (x_36 == 0)
+{
+lean_object* x_37; 
+lean_inc(x_2);
+x_37 = l_Lean_Parser_ParserState_mkError(x_6, x_2);
+x_16 = x_37;
+goto block_31;
+}
+else
+{
+x_16 = x_6;
+goto block_31;
+}
+block_31:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_5);
+x_18 = lean_apply_2(x_12, x_5, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; uint8_t x_21; 
+lean_dec(x_14);
+x_20 = lean_ctor_get(x_18, 1);
+lean_inc(x_20);
+x_21 = lean_nat_dec_eq(x_15, x_20);
+lean_dec(x_20);
+lean_dec(x_15);
+if (x_21 == 0)
+{
+x_6 = x_18;
+goto _start;
+}
+else
+{
+lean_object* x_23; lean_object* x_24; 
+lean_dec(x_5);
+lean_dec(x_2);
 lean_dec(x_1);
-x_5 = l_Lean_Parser_checkColGe(x_4, x_2, x_3);
-return x_5;
+x_23 = l_Lean_Parser_manyAux___main___closed__1;
+x_24 = l_Lean_Parser_ParserState_mkUnexpectedError(x_18, x_23);
+return x_24;
 }
 }
-lean_object* l_Lean_Parser_withPosition___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+else
+{
+lean_object* x_25; uint8_t x_26; 
+lean_dec(x_19);
+lean_dec(x_5);
+lean_dec(x_2);
+lean_dec(x_1);
+x_25 = lean_ctor_get(x_18, 1);
+lean_inc(x_25);
+x_26 = lean_nat_dec_eq(x_15, x_25);
+lean_dec(x_25);
+if (x_26 == 0)
+{
+lean_dec(x_15);
+lean_dec(x_14);
+return x_18;
+}
+else
+{
+lean_object* x_27; 
+x_27 = l_Lean_Parser_ParserState_restore(x_18, x_14, x_15);
+lean_dec(x_14);
+return x_27;
+}
+}
+}
+else
+{
+lean_object* x_28; uint8_t x_29; 
+lean_dec(x_17);
+lean_dec(x_12);
+lean_dec(x_5);
+lean_dec(x_2);
+lean_dec(x_1);
+x_28 = lean_ctor_get(x_16, 1);
+lean_inc(x_28);
+x_29 = lean_nat_dec_eq(x_15, x_28);
+lean_dec(x_28);
+if (x_29 == 0)
+{
+lean_dec(x_15);
+lean_dec(x_14);
+return x_16;
+}
+else
+{
+lean_object* x_30; 
+x_30 = l_Lean_Parser_ParserState_restore(x_16, x_14, x_15);
+lean_dec(x_14);
+return x_30;
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-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_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_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; 
+x_7 = lean_ctor_get(x_3, 0);
+x_8 = lean_ctor_get(x_7, 2);
+x_9 = lean_ctor_get(x_4, 1);
+x_10 = l_Lean_FileMap_toPosition(x_8, x_9);
+x_11 = lean_ctor_get(x_10, 1);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_1, 1);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_6, 0);
+lean_inc(x_13);
+x_14 = lean_array_get_size(x_13);
+lean_dec(x_13);
+x_15 = lean_ctor_get(x_6, 1);
+lean_inc(x_15);
+x_32 = lean_ctor_get(x_5, 0);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_32, 2);
+lean_inc(x_33);
+lean_dec(x_32);
+x_34 = l_Lean_FileMap_toPosition(x_33, x_15);
+lean_dec(x_33);
+x_35 = lean_ctor_get(x_34, 1);
+lean_inc(x_35);
+lean_dec(x_34);
+x_36 = lean_nat_dec_le(x_11, x_35);
+lean_dec(x_35);
+lean_dec(x_11);
+if (x_36 == 0)
+{
+lean_object* x_37; 
+lean_inc(x_2);
+x_37 = l_Lean_Parser_ParserState_mkError(x_6, x_2);
+x_16 = x_37;
+goto block_31;
+}
+else
+{
+x_16 = x_6;
+goto block_31;
+}
+block_31:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_5);
+x_18 = lean_apply_2(x_12, x_5, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; uint8_t x_21; 
+lean_dec(x_14);
+x_20 = lean_ctor_get(x_18, 1);
+lean_inc(x_20);
+x_21 = lean_nat_dec_eq(x_15, x_20);
+lean_dec(x_20);
+lean_dec(x_15);
+if (x_21 == 0)
+{
+x_6 = x_18;
+goto _start;
+}
+else
+{
+lean_object* x_23; lean_object* x_24; 
+lean_dec(x_5);
+lean_dec(x_2);
+lean_dec(x_1);
+x_23 = l_Lean_Parser_manyAux___main___closed__1;
+x_24 = l_Lean_Parser_ParserState_mkUnexpectedError(x_18, x_23);
+return x_24;
+}
+}
+else
+{
+lean_object* x_25; uint8_t x_26; 
+lean_dec(x_19);
+lean_dec(x_5);
+lean_dec(x_2);
+lean_dec(x_1);
+x_25 = lean_ctor_get(x_18, 1);
+lean_inc(x_25);
+x_26 = lean_nat_dec_eq(x_15, x_25);
+lean_dec(x_25);
+if (x_26 == 0)
+{
+lean_dec(x_15);
+lean_dec(x_14);
+return x_18;
+}
+else
+{
+lean_object* x_27; 
+x_27 = l_Lean_Parser_ParserState_restore(x_18, x_14, x_15);
+lean_dec(x_14);
+return x_27;
+}
+}
+}
+else
+{
+lean_object* x_28; uint8_t x_29; 
+lean_dec(x_17);
+lean_dec(x_12);
+lean_dec(x_5);
+lean_dec(x_2);
+lean_dec(x_1);
+x_28 = lean_ctor_get(x_16, 1);
+lean_inc(x_28);
+x_29 = lean_nat_dec_eq(x_15, x_28);
+lean_dec(x_28);
+if (x_29 == 0)
+{
+lean_dec(x_15);
+lean_dec(x_14);
+return x_16;
+}
+else
+{
+lean_object* x_30; 
+x_30 = l_Lean_Parser_ParserState_restore(x_16, x_14, x_15);
+lean_dec(x_14);
+return x_30;
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_many1Indent___lambda__1(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; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
 x_5 = lean_ctor_get(x_3, 0);
 lean_inc(x_5);
 x_6 = lean_ctor_get(x_5, 2);
@@ -13690,476 +13013,115 @@ lean_inc(x_7);
 x_8 = l_Lean_FileMap_toPosition(x_6, x_7);
 lean_dec(x_7);
 lean_dec(x_6);
-x_9 = lean_apply_1(x_1, x_8);
-x_10 = lean_ctor_get(x_9, 1);
-lean_inc(x_10);
-lean_dec(x_9);
-x_11 = lean_apply_3(x_10, x_2, x_3, x_4);
-return x_11;
-}
-}
-lean_object* l_Lean_Parser_withPosition(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; lean_object* x_4; uint8_t x_5; 
-x_3 = l_Lean_Position_Inhabited___closed__1;
-lean_inc(x_2);
-x_4 = lean_apply_1(x_2, x_3);
-x_5 = !lean_is_exclusive(x_4);
-if (x_5 == 0)
-{
-lean_object* x_6; lean_object* x_7; 
-x_6 = lean_ctor_get(x_4, 1);
-lean_dec(x_6);
-x_7 = lean_alloc_closure((void*)(l_Lean_Parser_withPosition___lambda__1), 4, 1);
-lean_closure_set(x_7, 0, x_2);
-lean_ctor_set(x_4, 1, x_7);
-return x_4;
-}
-else
-{
-lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_8 = lean_ctor_get(x_4, 0);
-lean_inc(x_8);
-lean_dec(x_4);
-x_9 = lean_alloc_closure((void*)(l_Lean_Parser_withPosition___lambda__1), 4, 1);
-lean_closure_set(x_9, 0, x_2);
-x_10 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_10, 0, x_8);
-lean_ctor_set(x_10, 1, x_9);
-return x_10;
-}
-}
-}
-lean_object* l_Lean_Parser_withPosition___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_withPosition(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; 
-x_9 = lean_ctor_get(x_2, 1);
+x_9 = lean_ctor_get(x_8, 1);
 lean_inc(x_9);
-x_10 = lean_ctor_get(x_8, 0);
-lean_inc(x_10);
-x_11 = lean_array_get_size(x_10);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_8, 1);
-lean_inc(x_12);
-x_29 = lean_ctor_get(x_7, 0);
-lean_inc(x_29);
-x_30 = lean_ctor_get(x_29, 2);
-lean_inc(x_30);
-lean_dec(x_29);
-x_31 = l_Lean_FileMap_toPosition(x_30, x_12);
-lean_dec(x_30);
-x_32 = lean_ctor_get(x_31, 1);
-lean_inc(x_32);
-lean_dec(x_31);
-x_33 = lean_nat_dec_le(x_4, x_32);
-lean_dec(x_32);
-if (x_33 == 0)
-{
-lean_object* x_34; 
-lean_inc(x_3);
-x_34 = l_Lean_Parser_ParserState_mkError(x_8, x_3);
-x_13 = x_34;
-goto block_28;
-}
-else
-{
-x_13 = x_8;
-goto block_28;
-}
-block_28:
-{
-lean_object* x_14; 
-x_14 = lean_ctor_get(x_13, 3);
-lean_inc(x_14);
-if (lean_obj_tag(x_14) == 0)
-{
-lean_object* x_15; lean_object* x_16; 
-lean_inc(x_7);
-lean_inc(x_6);
-x_15 = lean_apply_3(x_9, x_6, x_7, x_13);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; uint8_t x_18; 
-lean_dec(x_11);
-x_17 = lean_ctor_get(x_15, 1);
-lean_inc(x_17);
-x_18 = lean_nat_dec_eq(x_12, x_17);
-lean_dec(x_17);
-lean_dec(x_12);
-if (x_18 == 0)
-{
-x_8 = x_15;
-goto _start;
-}
-else
-{
-lean_object* x_20; lean_object* x_21; 
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_3);
-lean_dec(x_2);
-x_20 = l_Lean_Parser_manyAux___main___closed__1;
-x_21 = l_Lean_Parser_ParserState_mkUnexpectedError(x_15, x_20);
-return x_21;
-}
-}
-else
-{
-lean_object* x_22; uint8_t x_23; 
-lean_dec(x_16);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_3);
-lean_dec(x_2);
-x_22 = lean_ctor_get(x_15, 1);
-lean_inc(x_22);
-x_23 = lean_nat_dec_eq(x_12, x_22);
-lean_dec(x_22);
-if (x_23 == 0)
-{
-lean_dec(x_12);
-lean_dec(x_11);
-return x_15;
-}
-else
-{
-lean_object* x_24; 
-x_24 = l_Lean_Parser_ParserState_restore(x_15, x_11, x_12);
-lean_dec(x_11);
-return x_24;
-}
-}
-}
-else
-{
-lean_object* x_25; uint8_t x_26; 
-lean_dec(x_14);
-lean_dec(x_9);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_3);
-lean_dec(x_2);
-x_25 = lean_ctor_get(x_13, 1);
-lean_inc(x_25);
-x_26 = lean_nat_dec_eq(x_12, x_25);
-lean_dec(x_25);
-if (x_26 == 0)
-{
-lean_dec(x_12);
-lean_dec(x_11);
-return x_13;
-}
-else
-{
-lean_object* x_27; 
-x_27 = l_Lean_Parser_ParserState_restore(x_13, x_11, x_12);
-lean_dec(x_11);
-return x_27;
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; 
-x_9 = lean_ctor_get(x_2, 1);
-lean_inc(x_9);
-x_10 = lean_ctor_get(x_8, 0);
-lean_inc(x_10);
-x_11 = lean_array_get_size(x_10);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_8, 1);
-lean_inc(x_12);
-x_29 = lean_ctor_get(x_7, 0);
-lean_inc(x_29);
-x_30 = lean_ctor_get(x_29, 2);
-lean_inc(x_30);
-lean_dec(x_29);
-x_31 = l_Lean_FileMap_toPosition(x_30, x_12);
-lean_dec(x_30);
-x_32 = lean_ctor_get(x_31, 1);
-lean_inc(x_32);
-lean_dec(x_31);
-x_33 = lean_nat_dec_le(x_4, x_32);
-lean_dec(x_32);
-if (x_33 == 0)
-{
-lean_object* x_34; 
-lean_inc(x_3);
-x_34 = l_Lean_Parser_ParserState_mkError(x_8, x_3);
-x_13 = x_34;
-goto block_28;
-}
-else
-{
-x_13 = x_8;
-goto block_28;
-}
-block_28:
-{
-lean_object* x_14; 
-x_14 = lean_ctor_get(x_13, 3);
-lean_inc(x_14);
-if (lean_obj_tag(x_14) == 0)
-{
-lean_object* x_15; lean_object* x_16; 
-lean_inc(x_7);
-lean_inc(x_6);
-x_15 = lean_apply_3(x_9, x_6, x_7, x_13);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; uint8_t x_18; 
-lean_dec(x_11);
-x_17 = lean_ctor_get(x_15, 1);
-lean_inc(x_17);
-x_18 = lean_nat_dec_eq(x_12, x_17);
-lean_dec(x_17);
-lean_dec(x_12);
-if (x_18 == 0)
-{
-x_8 = x_15;
-goto _start;
-}
-else
-{
-lean_object* x_20; lean_object* x_21; 
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_3);
-lean_dec(x_2);
-x_20 = l_Lean_Parser_manyAux___main___closed__1;
-x_21 = l_Lean_Parser_ParserState_mkUnexpectedError(x_15, x_20);
-return x_21;
-}
-}
-else
-{
-lean_object* x_22; uint8_t x_23; 
-lean_dec(x_16);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_3);
-lean_dec(x_2);
-x_22 = lean_ctor_get(x_15, 1);
-lean_inc(x_22);
-x_23 = lean_nat_dec_eq(x_12, x_22);
-lean_dec(x_22);
-if (x_23 == 0)
-{
-lean_dec(x_12);
-lean_dec(x_11);
-return x_15;
-}
-else
-{
-lean_object* x_24; 
-x_24 = l_Lean_Parser_ParserState_restore(x_15, x_11, x_12);
-lean_dec(x_11);
-return x_24;
-}
-}
-}
-else
-{
-lean_object* x_25; uint8_t x_26; 
-lean_dec(x_14);
-lean_dec(x_9);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_3);
-lean_dec(x_2);
-x_25 = lean_ctor_get(x_13, 1);
-lean_inc(x_25);
-x_26 = lean_nat_dec_eq(x_12, x_25);
-lean_dec(x_25);
-if (x_26 == 0)
-{
-lean_dec(x_12);
-lean_dec(x_11);
-return x_13;
-}
-else
-{
-lean_object* x_27; 
-x_27 = l_Lean_Parser_ParserState_restore(x_13, x_11, x_12);
-lean_dec(x_11);
-return x_27;
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_many1Indent___lambda__1(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
-_start:
-{
-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; uint8_t x_15; 
-x_7 = lean_ctor_get(x_5, 0);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_7, 2);
-lean_inc(x_8);
-lean_dec(x_7);
-x_9 = lean_ctor_get(x_6, 1);
-lean_inc(x_9);
-x_10 = l_Lean_FileMap_toPosition(x_8, x_9);
-lean_dec(x_9);
 lean_dec(x_8);
-x_11 = lean_ctor_get(x_10, 1);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_4, 0);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_1, 1);
-lean_inc(x_12);
-x_13 = lean_ctor_get(x_6, 0);
-lean_inc(x_13);
-x_14 = lean_array_get_size(x_13);
-lean_dec(x_13);
-x_15 = lean_nat_dec_le(x_11, x_11);
-if (x_15 == 0)
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_dec(x_12);
+x_12 = lean_array_get_size(x_11);
 lean_dec(x_11);
-lean_dec(x_5);
-lean_dec(x_4);
+x_13 = lean_nat_dec_le(x_9, x_9);
+lean_dec(x_9);
+if (x_13 == 0)
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_10);
+lean_dec(x_3);
 lean_dec(x_1);
-x_16 = l_Lean_Parser_ParserState_mkError(x_6, x_2);
-x_17 = l_Lean_nullKind;
-x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_14);
-return x_18;
+x_14 = l_Lean_Parser_ParserState_mkError(x_4, x_2);
+x_15 = l_Lean_nullKind;
+x_16 = l_Lean_Parser_ParserState_mkNode(x_14, x_15, x_12);
+return x_16;
 }
 else
 {
-lean_object* x_19; 
-x_19 = lean_ctor_get(x_6, 3);
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_4, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_4);
+lean_inc(x_3);
+x_18 = lean_apply_2(x_10, x_3, x_4);
+x_19 = lean_ctor_get(x_18, 3);
 lean_inc(x_19);
 if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_20; lean_object* x_21; 
-lean_inc(x_5);
-lean_inc(x_4);
-x_20 = lean_apply_3(x_12, x_4, x_5, x_6);
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+lean_inc(x_3);
+x_20 = l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2(x_1, x_2, x_3, x_4, x_3, x_18);
+lean_dec(x_4);
+lean_dec(x_3);
+x_21 = l_Lean_nullKind;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_12);
+return x_22;
+}
+else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_22 = l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2(x_3, x_1, x_2, x_11, x_3, x_4, x_5, x_20);
-lean_dec(x_11);
+lean_object* x_23; lean_object* x_24; 
+lean_dec(x_19);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
 x_23 = l_Lean_nullKind;
-x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_14);
+x_24 = l_Lean_Parser_ParserState_mkNode(x_18, x_23, x_12);
 return x_24;
 }
+}
 else
 {
 lean_object* x_25; lean_object* x_26; 
-lean_dec(x_21);
-lean_dec(x_11);
-lean_dec(x_5);
-lean_dec(x_4);
+lean_dec(x_17);
+lean_dec(x_10);
+lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_25 = l_Lean_nullKind;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_20, x_25, x_14);
+x_26 = l_Lean_Parser_ParserState_mkNode(x_4, x_25, x_12);
 return x_26;
 }
 }
-else
+}
+}
+lean_object* l_Lean_Parser_many1Indent(lean_object* x_1, lean_object* x_2) {
+_start:
 {
-lean_object* x_27; lean_object* x_28; 
-lean_dec(x_19);
-lean_dec(x_12);
-lean_dec(x_11);
-lean_dec(x_5);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_5 = l_Lean_Parser_andthenInfo(x_4, x_3);
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_many1Indent___lambda__1), 4, 2);
+lean_closure_set(x_6, 0, x_1);
+lean_closure_set(x_6, 1, x_2);
+x_7 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_7, 0, x_5);
+lean_ctor_set(x_7, 1, x_6);
+return x_7;
+}
+}
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; 
+x_7 = l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_4);
-lean_dec(x_2);
-lean_dec(x_1);
-x_27 = l_Lean_nullKind;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_6, x_27, x_14);
-return x_28;
-}
-}
-}
-}
-lean_object* l_Lean_Parser_many1Indent(uint8_t 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; 
-x_4 = lean_ctor_get(x_2, 0);
-lean_inc(x_4);
-x_5 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_6 = l_Lean_Parser_andthenInfo(x_5, x_4);
-x_7 = lean_box(x_1);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_many1Indent___lambda__1___boxed), 6, 3);
-lean_closure_set(x_8, 0, x_2);
-lean_closure_set(x_8, 1, x_3);
-lean_closure_set(x_8, 2, x_7);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_6);
-lean_ctor_set(x_9, 1, x_8);
-return x_9;
-}
-}
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_5);
-lean_dec(x_5);
-x_11 = l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1(x_9, x_2, x_3, x_4, x_10, x_6, x_7, x_8);
-lean_dec(x_4);
-return x_11;
-}
-}
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_5);
-lean_dec(x_5);
-x_11 = l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2(x_9, x_2, x_3, x_4, x_10, x_6, x_7, x_8);
-lean_dec(x_4);
-return x_11;
-}
-}
-lean_object* l_Lean_Parser_many1Indent___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
-_start:
-{
-uint8_t x_7; lean_object* x_8; 
-x_7 = lean_unbox(x_3);
 lean_dec(x_3);
-x_8 = l_Lean_Parser_many1Indent___lambda__1(x_1, x_2, x_7, x_4, x_5, x_6);
-return x_8;
+return x_7;
 }
 }
-lean_object* l_Lean_Parser_many1Indent___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_Parser_many1Indent(x_4, x_2, x_3);
-return x_5;
+lean_object* x_7; 
+x_7 = l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2(x_1, x_2, x_3, x_4, x_5, x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+return x_7;
 }
 }
 lean_object* l_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
@@ -24125,7 +23087,7 @@ if (x_44 == 0)
 lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; 
 lean_free_object(x_4);
 lean_dec(x_12);
-x_45 = lean_ctor_get(x_2, 2);
+x_45 = lean_ctor_get(x_2, 3);
 lean_inc(x_45);
 lean_dec(x_2);
 x_46 = lean_unsigned_to_nat(0u);
@@ -24326,7 +23288,7 @@ if (x_76 == 0)
 {
 lean_object* x_77; lean_object* x_78; lean_object* x_79; uint8_t x_80; 
 lean_free_object(x_4);
-x_77 = lean_ctor_get(x_2, 2);
+x_77 = lean_ctor_get(x_2, 3);
 lean_inc(x_77);
 lean_dec(x_2);
 x_78 = lean_unsigned_to_nat(0u);
@@ -24543,7 +23505,7 @@ if (x_112 == 0)
 {
 lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; 
 lean_dec(x_12);
-x_113 = lean_ctor_get(x_2, 2);
+x_113 = lean_ctor_get(x_2, 3);
 lean_inc(x_113);
 lean_dec(x_2);
 x_114 = lean_unsigned_to_nat(0u);
@@ -24682,7 +23644,7 @@ lean_dec(x_12);
 if (x_133 == 0)
 {
 lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; 
-x_134 = lean_ctor_get(x_2, 2);
+x_134 = lean_ctor_get(x_2, 3);
 lean_inc(x_134);
 lean_dec(x_2);
 x_135 = lean_unsigned_to_nat(0u);
@@ -25256,129 +24218,116 @@ return x_1;
 }
 }
 }
-lean_object* l_Lean_Parser_leadingParser(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_leadingParser(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-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; uint8_t x_15; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = lean_ctor_get(x_2, 0);
-lean_inc(x_9);
-lean_inc(x_5);
-x_10 = l_Lean_Parser_indexed___rarg(x_9, x_5, x_6, x_3);
-lean_dec(x_9);
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-lean_dec(x_10);
-x_13 = lean_ctor_get(x_2, 1);
-lean_inc(x_13);
-lean_dec(x_2);
-x_14 = l_List_append___rarg(x_13, x_12);
-x_15 = l_List_isEmpty___rarg(x_14);
-if (x_15 == 0)
-{
-uint8_t x_16; lean_object* x_17; lean_object* x_18; 
-lean_dec(x_1);
-x_16 = 0;
-x_17 = l_Lean_Parser_longestMatchFn(x_16, x_14, x_4, x_5, x_11);
-x_18 = l___private_Init_Lean_Parser_Parser_10__mkResult(x_17, x_8);
-return x_18;
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-lean_dec(x_14);
-lean_dec(x_8);
-lean_dec(x_5);
-lean_dec(x_4);
-x_19 = l_Lean_Name_toString___closed__1;
-x_20 = l_Lean_Name_toStringWithSep___main(x_19, x_1);
-x_21 = l_Lean_Parser_ParserState_mkError(x_11, x_20);
-return x_21;
-}
-}
-}
-lean_object* l_Lean_Parser_leadingParser___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
-_start:
-{
-uint8_t x_7; lean_object* x_8; 
-x_7 = lean_unbox(x_3);
-lean_dec(x_3);
-x_8 = l_Lean_Parser_leadingParser(x_1, x_2, x_7, x_4, x_5, x_6);
-return x_8;
-}
-}
-lean_object* l_Lean_Parser_trailingLoopStep(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; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_6 = lean_ctor_get(x_1, 3);
+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; uint8_t x_14; 
+x_6 = lean_ctor_get(x_5, 0);
 lean_inc(x_6);
-lean_dec(x_1);
-x_7 = lean_ctor_get(x_5, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = lean_ctor_get(x_5, 1);
-lean_inc(x_9);
-x_10 = 1;
-x_11 = lean_box(0);
+x_7 = lean_array_get_size(x_6);
+lean_dec(x_6);
+x_8 = lean_ctor_get(x_2, 0);
+lean_inc(x_8);
 lean_inc(x_4);
-x_12 = l_Lean_Parser_longestMatchFn(x_10, x_2, x_11, x_4, x_5);
-x_13 = lean_ctor_get(x_12, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
-{
-lean_dec(x_9);
+x_9 = l_Lean_Parser_indexed___rarg(x_8, x_4, x_5, x_3);
 lean_dec(x_8);
-lean_dec(x_6);
-lean_dec(x_4);
-return x_12;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_12, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_15, x_9);
-lean_dec(x_15);
-if (x_16 == 0)
-{
-lean_dec(x_14);
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_9, 1);
+lean_inc(x_11);
 lean_dec(x_9);
-lean_dec(x_8);
-lean_dec(x_6);
-lean_dec(x_4);
-return x_12;
+x_12 = lean_ctor_get(x_2, 1);
+lean_inc(x_12);
+lean_dec(x_2);
+x_13 = l_List_append___rarg(x_12, x_11);
+x_14 = l_List_isEmpty___rarg(x_13);
+if (x_14 == 0)
+{
+lean_object* x_15; lean_object* x_16; 
+lean_dec(x_1);
+x_15 = l_Lean_Parser_longestMatchFn(x_13, x_4, x_10);
+x_16 = l___private_Init_Lean_Parser_Parser_10__mkResult(x_15, x_7);
+return x_16;
 }
 else
 {
 lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-lean_inc(x_9);
-x_17 = l_Lean_Parser_ParserState_restore(x_12, x_8, x_9);
-lean_dec(x_8);
-x_18 = l_Lean_Parser_anyOfFn___main(x_10, x_6, x_11, x_4, x_17);
-x_19 = l_Lean_Parser_mergeOrElseErrors(x_18, x_14, x_9);
-lean_dec(x_9);
+lean_dec(x_13);
+lean_dec(x_7);
+lean_dec(x_4);
+x_17 = l_Lean_Name_toString___closed__1;
+x_18 = l_Lean_Name_toStringWithSep___main(x_17, x_1);
+x_19 = l_Lean_Parser_ParserState_mkError(x_10, x_18);
 return x_19;
 }
 }
 }
-}
-lean_object* l_Lean_Parser_trailingLoopStep___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_leadingParser___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_Parser_trailingLoopStep(x_1, x_2, x_3, x_4, x_5);
+uint8_t x_6; lean_object* x_7; 
+x_6 = lean_unbox(x_3);
 lean_dec(x_3);
-return x_6;
+x_7 = l_Lean_Parser_leadingParser(x_1, x_2, x_6, x_4, x_5);
+return x_7;
+}
+}
+lean_object* l_Lean_Parser_trailingLoopStep(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; lean_object* x_9; lean_object* x_10; 
+x_5 = lean_ctor_get(x_1, 3);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_4, 0);
+lean_inc(x_6);
+x_7 = lean_array_get_size(x_6);
+lean_dec(x_6);
+x_8 = lean_ctor_get(x_4, 1);
+lean_inc(x_8);
+lean_inc(x_3);
+x_9 = l_Lean_Parser_longestMatchFn(x_2, x_3, x_4);
+x_10 = lean_ctor_get(x_9, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_3);
+return x_9;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_9, 1);
+lean_inc(x_12);
+x_13 = lean_nat_dec_eq(x_12, x_8);
+lean_dec(x_12);
+if (x_13 == 0)
+{
+lean_dec(x_11);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_3);
+return x_9;
+}
+else
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_inc(x_8);
+x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+lean_dec(x_7);
+x_15 = l_Lean_Parser_anyOfFn___main(x_5, x_3, x_14);
+x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
+lean_dec(x_8);
+return x_16;
+}
+}
 }
 }
 lean_object* l___private_Init_Lean_Parser_Parser_11__mkTrailingResult(lean_object* x_1, lean_object* x_2) {
@@ -25388,7 +24337,7 @@ lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_obj
 x_3 = l___private_Init_Lean_Parser_Parser_10__mkResult(x_1, x_2);
 x_4 = lean_ctor_get(x_3, 0);
 lean_inc(x_4);
-x_5 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_4);
+x_5 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_4);
 lean_dec(x_4);
 x_6 = l_Lean_Parser_ParserState_popSyntax(x_3);
 x_7 = l_Lean_Parser_ParserState_popSyntax(x_6);
@@ -25396,36 +24345,39 @@ x_8 = l_Lean_Parser_ParserState_pushSyntax(x_7, x_5);
 return x_8;
 }
 }
-lean_object* l_Lean_Parser_trailingLoop___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_trailingLoop___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_5);
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_4);
+lean_dec(x_4);
+lean_inc(x_2);
+x_6 = l_Lean_Parser_currLbp(x_5, x_2, x_3);
 lean_dec(x_5);
-lean_inc(x_3);
-x_7 = l_Lean_Parser_currLbp(x_6, x_3, x_4);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_7, 0);
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_6, 1);
 lean_inc(x_8);
-x_9 = lean_ctor_get(x_7, 1);
+lean_dec(x_6);
+x_9 = lean_ctor_get(x_2, 1);
 lean_inc(x_9);
-lean_dec(x_7);
-x_10 = lean_nat_dec_le(x_9, x_2);
+x_10 = lean_nat_dec_le(x_8, x_9);
 lean_dec(x_9);
+lean_dec(x_8);
 if (x_10 == 0)
 {
 lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; 
-x_11 = lean_ctor_get(x_8, 0);
+x_11 = lean_ctor_get(x_7, 0);
 lean_inc(x_11);
 x_12 = lean_array_get_size(x_11);
 lean_dec(x_11);
 x_13 = lean_ctor_get(x_1, 2);
 lean_inc(x_13);
 x_14 = 0;
-lean_inc(x_3);
-x_15 = l_Lean_Parser_indexed___rarg(x_13, x_3, x_8, x_14);
+lean_inc(x_2);
+x_15 = l_Lean_Parser_indexed___rarg(x_13, x_2, x_7, x_14);
 lean_dec(x_13);
 x_16 = lean_ctor_get(x_15, 0);
 lean_inc(x_16);
@@ -25435,66 +24387,64 @@ lean_dec(x_15);
 x_18 = l_List_isEmpty___rarg(x_17);
 if (x_18 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = lean_box(0);
-lean_inc(x_3);
+lean_object* x_19; lean_object* x_20; 
+lean_inc(x_2);
 lean_inc(x_1);
-x_20 = l_Lean_Parser_trailingLoopStep(x_1, x_17, x_19, x_3, x_16);
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
+x_19 = l_Lean_Parser_trailingLoopStep(x_1, x_17, x_2, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_22; 
-x_22 = l___private_Init_Lean_Parser_Parser_11__mkTrailingResult(x_20, x_12);
-x_4 = x_22;
+lean_object* x_21; 
+x_21 = l___private_Init_Lean_Parser_Parser_11__mkTrailingResult(x_19, x_12);
+x_3 = x_21;
 goto _start;
 }
 else
 {
-lean_dec(x_21);
+lean_dec(x_20);
 lean_dec(x_12);
-lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_20;
+return x_19;
 }
 }
 else
 {
-lean_object* x_24; uint8_t x_25; 
-x_24 = lean_ctor_get(x_1, 3);
-lean_inc(x_24);
-x_25 = l_List_isEmpty___rarg(x_24);
-lean_dec(x_24);
-if (x_25 == 0)
+lean_object* x_23; uint8_t x_24; 
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+x_24 = l_List_isEmpty___rarg(x_23);
+lean_dec(x_23);
+if (x_24 == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_26 = lean_box(0);
-lean_inc(x_3);
+lean_object* x_25; lean_object* x_26; 
+lean_inc(x_2);
 lean_inc(x_1);
-x_27 = l_Lean_Parser_trailingLoopStep(x_1, x_17, x_26, x_3, x_16);
-x_28 = lean_ctor_get(x_27, 3);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
+x_25 = l_Lean_Parser_trailingLoopStep(x_1, x_17, x_2, x_16);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
 {
-lean_object* x_29; 
-x_29 = l___private_Init_Lean_Parser_Parser_11__mkTrailingResult(x_27, x_12);
-x_4 = x_29;
+lean_object* x_27; 
+x_27 = l___private_Init_Lean_Parser_Parser_11__mkTrailingResult(x_25, x_12);
+x_3 = x_27;
 goto _start;
 }
 else
 {
-lean_dec(x_28);
+lean_dec(x_26);
 lean_dec(x_12);
-lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_27;
+return x_25;
 }
 }
 else
 {
 lean_dec(x_17);
 lean_dec(x_12);
-lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 return x_16;
 }
@@ -25502,88 +24452,67 @@ return x_16;
 }
 else
 {
-lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_8;
-}
-}
-}
-lean_object* l_Lean_Parser_trailingLoop___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_trailingLoop___main(x_1, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_trailingLoop(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_trailingLoop___main(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_trailingLoop___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_trailingLoop(x_1, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_prattParser(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
-_start:
-{
-lean_object* x_7; lean_object* x_8; 
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_2);
-x_7 = l_Lean_Parser_leadingParser(x_1, x_2, x_3, x_4, x_5, x_6);
-x_8 = lean_ctor_get(x_7, 3);
-lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; 
-x_9 = l_Lean_Parser_trailingLoop___main(x_2, x_4, x_5, x_7);
-lean_dec(x_4);
-return x_9;
-}
-else
-{
-lean_dec(x_8);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_2);
 return x_7;
 }
 }
 }
-lean_object* l_Lean_Parser_prattParser___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_trailingLoop(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-uint8_t x_7; lean_object* x_8; 
-x_7 = lean_unbox(x_3);
-lean_dec(x_3);
-x_8 = l_Lean_Parser_prattParser(x_1, x_2, x_7, x_4, x_5, x_6);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_trailingLoop___main(x_1, x_2, x_3);
+return x_4;
+}
+}
+lean_object* l_Lean_Parser_prattParser(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; lean_object* x_7; 
+lean_inc(x_4);
+lean_inc(x_2);
+x_6 = l_Lean_Parser_leadingParser(x_1, x_2, x_3, x_4, x_5);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; 
+x_8 = l_Lean_Parser_trailingLoop___main(x_2, x_4, x_6);
 return x_8;
 }
+else
+{
+lean_dec(x_7);
+lean_dec(x_4);
+lean_dec(x_2);
+return x_6;
 }
-lean_object* l_Lean_Parser_mkCategoryParserFnRef___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+}
+}
+lean_object* l_Lean_Parser_prattParser___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_5; 
-x_5 = l_Lean_Parser_whitespace___main(x_3, x_4);
-return x_5;
+uint8_t x_6; lean_object* x_7; 
+x_6 = lean_unbox(x_3);
+lean_dec(x_3);
+x_7 = l_Lean_Parser_prattParser(x_1, x_2, x_6, x_4, x_5);
+return x_7;
+}
+}
+lean_object* l_Lean_Parser_mkCategoryParserFnRef___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Lean_Parser_whitespace___main(x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_mkCategoryParserFnRef___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_mkCategoryParserFnRef___lambda__1___boxed), 4, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_mkCategoryParserFnRef___lambda__1___boxed), 3, 0);
 return x_1;
 }
 }
@@ -25596,29 +24525,28 @@ x_3 = lean_io_mk_ref(x_2, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_mkCategoryParserFnRef___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_mkCategoryParserFnRef___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l_Lean_Parser_mkCategoryParserFnRef___lambda__1(x_1, x_2, x_3, x_4);
-lean_dec(x_3);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_mkCategoryParserFnRef___lambda__1(x_1, x_2, x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_5;
+return x_4;
 }
 }
-lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_inc(x_4);
-return x_4;
+lean_inc(x_3);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1___boxed), 4, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1___boxed), 3, 0);
 return x_1;
 }
 }
@@ -25873,16 +24801,15 @@ x_3 = l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExten
 return x_3;
 }
 }
-lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1(x_1, x_2, x_3, x_4);
-lean_dec(x_4);
+lean_object* x_4; 
+x_4 = l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1(x_1, x_2, x_3);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_5;
+return x_4;
 }
 }
 lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1___rarg(lean_object* x_1) {
@@ -25892,12 +24819,12 @@ lean_inc(x_1);
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; 
-x_4 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParserFnExtension___elambda__1___rarg___boxed), 1, 0);
-return x_4;
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParserFnExtension___elambda__1___rarg___boxed), 1, 0);
+return x_3;
 }
 }
 lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__2(lean_object* x_1) {
@@ -25923,7 +24850,7 @@ lean_object* _init_l_Lean_Parser_categoryParserFnExtension___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParserFnExtension___elambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParserFnExtension___elambda__1___boxed), 2, 0);
 return x_1;
 }
 }
@@ -25950,86 +24877,74 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; 
-x_4 = l_Lean_Parser_categoryParserFnExtension___elambda__1(x_1, x_2, x_3);
-lean_dec(x_3);
+lean_object* x_3; 
+x_3 = l_Lean_Parser_categoryParserFnExtension___elambda__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_categoryParserFn(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; 
-x_5 = lean_ctor_get(x_3, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_categoryParserFnExtension;
-x_7 = l_Lean_EnvExtension_getStateUnsafe___rarg(x_6, x_5);
-lean_dec(x_5);
-x_8 = lean_apply_4(x_7, x_1, x_2, x_3, x_4);
-return x_8;
-}
-}
-lean_object* l_Lean_Parser_categoryParser___elambda__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; 
-x_6 = l_Lean_Parser_categoryParserFn(x_1, x_2, x_4, x_5);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_categoryParser___elambda__1(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1___rarg___boxed), 5, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_categoryParser(uint8_t 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_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1___rarg___boxed), 5, 2);
-lean_closure_set(x_4, 0, x_2);
-lean_closure_set(x_4, 1, x_3);
-x_5 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_6 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_6, 0, x_5);
-lean_ctor_set(x_6, 1, x_4);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_categoryParser___elambda__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_Parser_categoryParser___elambda__1___rarg(x_1, x_2, x_3, x_4, x_5);
-lean_dec(x_3);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_categoryParser___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_categoryParser___elambda__1(x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_categoryParser___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_categoryParserFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_Parser_categoryParser(x_4, x_2, x_3);
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_4 = lean_ctor_get(x_2, 2);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_categoryParserFnExtension;
+x_6 = l_Lean_EnvExtension_getStateUnsafe___rarg(x_5, x_4);
+lean_dec(x_4);
+x_7 = lean_apply_3(x_6, x_1, x_2, x_3);
+return x_7;
+}
+}
+lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; 
+x_5 = !lean_is_exclusive(x_3);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; 
+x_6 = lean_ctor_get(x_3, 1);
+lean_dec(x_6);
+lean_ctor_set(x_3, 1, x_2);
+x_7 = l_Lean_Parser_categoryParserFn(x_1, x_3, x_4);
+return x_7;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_8 = lean_ctor_get(x_3, 0);
+x_9 = lean_ctor_get(x_3, 2);
+x_10 = lean_ctor_get(x_3, 3);
+lean_inc(x_10);
+lean_inc(x_9);
+lean_inc(x_8);
+lean_dec(x_3);
+x_11 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_11, 0, x_8);
+lean_ctor_set(x_11, 1, x_2);
+lean_ctor_set(x_11, 2, x_9);
+lean_ctor_set(x_11, 3, x_10);
+x_12 = l_Lean_Parser_categoryParserFn(x_1, x_11, x_4);
+return x_12;
+}
+}
+}
+lean_object* l_Lean_Parser_categoryParser(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 2);
+lean_closure_set(x_3, 0, x_1);
+lean_closure_set(x_3, 1, x_2);
+x_4 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_5 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_5, 0, x_4);
+lean_ctor_set(x_5, 1, x_3);
 return x_5;
 }
 }
@@ -26051,26 +24966,16 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_termParser(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_termParser(lean_object* x_1) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; 
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_3, x_2);
-return x_4;
+lean_object* x_2; lean_object* x_3; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_categoryParser(x_2, x_1);
+return x_3;
 }
 }
-lean_object* l_Lean_Parser_termParser___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_termParser(x_3, x_2);
-return x_4;
-}
-}
-lean_object* _init_l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -26079,39 +24984,39 @@ x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__2() {
 _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_dollarSymbol___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_dollarSymbol___elambda__1___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__3() {
+lean_object* _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__2;
+x_1 = l_Lean_Parser_dollarSymbol___elambda__1___closed__2;
 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_dollarSymbol___elambda__1___rarg___closed__4() {
+lean_object* _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__3;
+x_2 = l_Lean_Parser_dollarSymbol___elambda__1___closed__3;
 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* l_Lean_Parser_dollarSymbol___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_dollarSymbol___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; 
@@ -26125,7 +25030,7 @@ if (lean_obj_tag(x_5) == 0)
 lean_object* x_6; lean_object* x_7; 
 x_6 = lean_ctor_get(x_4, 0);
 lean_inc(x_6);
-x_7 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_6);
+x_7 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_6);
 lean_dec(x_6);
 if (lean_obj_tag(x_7) == 2)
 {
@@ -26133,13 +25038,13 @@ lean_object* x_8; lean_object* x_9; uint8_t x_10;
 x_8 = lean_ctor_get(x_7, 1);
 lean_inc(x_8);
 lean_dec(x_7);
-x_9 = l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__1;
+x_9 = l_Lean_Parser_dollarSymbol___elambda__1___closed__1;
 x_10 = lean_string_dec_eq(x_8, x_9);
 lean_dec(x_8);
 if (x_10 == 0)
 {
 lean_object* x_11; lean_object* x_12; 
-x_11 = l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__4;
+x_11 = l_Lean_Parser_dollarSymbol___elambda__1___closed__4;
 x_12 = l_Lean_Parser_ParserState_mkErrorsAt(x_4, x_11, x_3);
 return x_12;
 }
@@ -26153,7 +25058,7 @@ else
 {
 lean_object* x_13; lean_object* x_14; 
 lean_dec(x_7);
-x_13 = l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__4;
+x_13 = l_Lean_Parser_dollarSymbol___elambda__1___closed__4;
 x_14 = l_Lean_Parser_ParserState_mkErrorsAt(x_4, x_13, x_3);
 return x_14;
 }
@@ -26162,20 +25067,12 @@ else
 {
 lean_object* x_15; lean_object* x_16; 
 lean_dec(x_5);
-x_15 = l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__4;
+x_15 = l_Lean_Parser_dollarSymbol___elambda__1___closed__4;
 x_16 = l_Lean_Parser_ParserState_mkErrorsAt(x_4, x_15, x_3);
 return x_16;
 }
 }
 }
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_dollarSymbol___elambda__1___rarg), 2, 0);
-return x_3;
-}
-}
 lean_object* _init_l_Lean_Parser_dollarSymbol___closed__1() {
 _start:
 {
@@ -26190,48 +25087,41 @@ lean_object* _init_l_Lean_Parser_dollarSymbol___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__1;
+x_1 = l_Lean_Parser_dollarSymbol___elambda__1___closed__1;
 x_2 = l_Lean_Parser_dollarSymbol___closed__1;
 x_3 = l_Lean_Parser_symbolInfo(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_dollarSymbol(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_dollarSymbol___closed__3() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_dollarSymbol___elambda__1___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_dollarSymbol___closed__2;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_dollarSymbol___elambda__1), 2, 0);
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* _init_l_Lean_Parser_dollarSymbol___closed__4() {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_dollarSymbol___elambda__1(x_3, x_2);
-lean_dec(x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_dollarSymbol___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_dollarSymbol(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_dollarSymbol___closed__2;
+x_2 = l_Lean_Parser_dollarSymbol___closed__3;
+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___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_dollarSymbol() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_dollarSymbol___closed__4;
+return x_1;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -26239,13 +25129,13 @@ x_1 = lean_mk_string("unexpected ':'");
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; uint8_t x_5; 
 x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-x_4 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_3);
+x_4 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_3);
 lean_dec(x_3);
 x_5 = l_Lean_Parser_checkTailNoWs(x_4);
 lean_dec(x_4);
@@ -26275,7 +25165,7 @@ return x_2;
 else
 {
 lean_object* x_13; lean_object* x_14; 
-x_13 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg___closed__1;
+x_13 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___closed__1;
 x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_2, x_13);
 return x_14;
 }
@@ -26288,287 +25178,266 @@ return x_2;
 }
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1(uint8_t x_1, lean_object* x_2) {
+lean_object* _init_l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__1() {
 _start:
 {
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg___boxed), 2, 0);
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___boxed), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_2 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__1;
+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* l___private_Init_Lean_Parser_Parser_12__noImmediateColon(uint8_t x_1) {
+lean_object* _init_l___private_Init_Lean_Parser_Parser_12__noImmediateColon() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg(x_1, x_2);
-lean_dec(x_1);
-return x_3;
+lean_object* x_1; 
+x_1 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__2;
+return x_1;
 }
 }
 lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
+lean_object* x_3; 
+x_3 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1(x_1, x_2);
 lean_dec(x_1);
-x_4 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1(x_3, x_2);
-lean_dec(x_2);
-return x_4;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_12__noImmediateColon___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon(x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_setExpectedFn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_setExpectedFn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; 
-x_5 = lean_apply_3(x_1, x_2, x_3, x_4);
-x_6 = lean_ctor_get(x_5, 3);
-lean_inc(x_6);
-if (lean_obj_tag(x_6) == 0)
+lean_object* x_4; lean_object* x_5; 
+x_4 = lean_apply_2(x_1, x_2, x_3);
+x_5 = lean_ctor_get(x_4, 3);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 0)
 {
-return x_5;
+return x_4;
 }
 else
 {
+uint8_t x_6; 
+x_6 = !lean_is_exclusive(x_5);
+if (x_6 == 0)
+{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_6);
+x_7 = !lean_is_exclusive(x_4);
 if (x_7 == 0)
 {
-uint8_t x_8; 
-x_8 = !lean_is_exclusive(x_5);
-if (x_8 == 0)
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_6, 0);
-x_10 = lean_ctor_get(x_5, 3);
-lean_dec(x_10);
-x_11 = !lean_is_exclusive(x_9);
-if (x_11 == 0)
-{
-lean_object* x_12; lean_object* x_13; 
-x_12 = lean_ctor_get(x_9, 1);
-lean_dec(x_12);
-x_13 = lean_box(0);
-lean_ctor_set(x_9, 1, x_13);
-return x_5;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_14 = lean_ctor_get(x_9, 0);
-lean_inc(x_14);
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_5, 0);
+x_9 = lean_ctor_get(x_4, 3);
 lean_dec(x_9);
-x_15 = lean_box(0);
-x_16 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_16, 0, x_14);
-lean_ctor_set(x_16, 1, x_15);
-lean_ctor_set(x_6, 0, x_16);
-return x_5;
+x_10 = !lean_is_exclusive(x_8);
+if (x_10 == 0)
+{
+lean_object* x_11; lean_object* x_12; 
+x_11 = lean_ctor_get(x_8, 1);
+lean_dec(x_11);
+x_12 = lean_box(0);
+lean_ctor_set(x_8, 1, x_12);
+return x_4;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_13 = lean_ctor_get(x_8, 0);
+lean_inc(x_13);
+lean_dec(x_8);
+x_14 = lean_box(0);
+x_15 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_15, 0, x_13);
+lean_ctor_set(x_15, 1, x_14);
+lean_ctor_set(x_5, 0, x_15);
+return x_4;
 }
 }
 else
 {
-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; 
-x_17 = lean_ctor_get(x_6, 0);
-x_18 = lean_ctor_get(x_5, 0);
-x_19 = lean_ctor_get(x_5, 1);
-x_20 = lean_ctor_get(x_5, 2);
-lean_inc(x_20);
+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; 
+x_16 = lean_ctor_get(x_5, 0);
+x_17 = lean_ctor_get(x_4, 0);
+x_18 = lean_ctor_get(x_4, 1);
+x_19 = lean_ctor_get(x_4, 2);
 lean_inc(x_19);
 lean_inc(x_18);
+lean_inc(x_17);
+lean_dec(x_4);
+x_20 = lean_ctor_get(x_16, 0);
+lean_inc(x_20);
+if (lean_is_exclusive(x_16)) {
+ lean_ctor_release(x_16, 0);
+ lean_ctor_release(x_16, 1);
+ x_21 = x_16;
+} else {
+ lean_dec_ref(x_16);
+ x_21 = lean_box(0);
+}
+x_22 = lean_box(0);
+if (lean_is_scalar(x_21)) {
+ x_23 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_23 = x_21;
+}
+lean_ctor_set(x_23, 0, x_20);
+lean_ctor_set(x_23, 1, x_22);
+lean_ctor_set(x_5, 0, x_23);
+x_24 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_24, 0, x_17);
+lean_ctor_set(x_24, 1, x_18);
+lean_ctor_set(x_24, 2, x_19);
+lean_ctor_set(x_24, 3, x_5);
+return x_24;
+}
+}
+else
+{
+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; 
+x_25 = lean_ctor_get(x_5, 0);
+lean_inc(x_25);
 lean_dec(x_5);
-x_21 = lean_ctor_get(x_17, 0);
-lean_inc(x_21);
-if (lean_is_exclusive(x_17)) {
- lean_ctor_release(x_17, 0);
- lean_ctor_release(x_17, 1);
- x_22 = x_17;
-} else {
- lean_dec_ref(x_17);
- x_22 = lean_box(0);
-}
-x_23 = lean_box(0);
-if (lean_is_scalar(x_22)) {
- x_24 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_24 = x_22;
-}
-lean_ctor_set(x_24, 0, x_21);
-lean_ctor_set(x_24, 1, x_23);
-lean_ctor_set(x_6, 0, x_24);
-x_25 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_25, 0, x_18);
-lean_ctor_set(x_25, 1, x_19);
-lean_ctor_set(x_25, 2, x_20);
-lean_ctor_set(x_25, 3, x_6);
-return x_25;
-}
-}
-else
-{
-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_26 = lean_ctor_get(x_6, 0);
+x_26 = lean_ctor_get(x_4, 0);
 lean_inc(x_26);
-lean_dec(x_6);
-x_27 = lean_ctor_get(x_5, 0);
+x_27 = lean_ctor_get(x_4, 1);
 lean_inc(x_27);
-x_28 = lean_ctor_get(x_5, 1);
+x_28 = lean_ctor_get(x_4, 2);
 lean_inc(x_28);
-x_29 = lean_ctor_get(x_5, 2);
-lean_inc(x_29);
-if (lean_is_exclusive(x_5)) {
- lean_ctor_release(x_5, 0);
- lean_ctor_release(x_5, 1);
- lean_ctor_release(x_5, 2);
- lean_ctor_release(x_5, 3);
- x_30 = x_5;
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_29 = x_4;
 } else {
- lean_dec_ref(x_5);
- x_30 = lean_box(0);
+ lean_dec_ref(x_4);
+ x_29 = lean_box(0);
 }
-x_31 = lean_ctor_get(x_26, 0);
-lean_inc(x_31);
-if (lean_is_exclusive(x_26)) {
- lean_ctor_release(x_26, 0);
- lean_ctor_release(x_26, 1);
- x_32 = x_26;
+x_30 = lean_ctor_get(x_25, 0);
+lean_inc(x_30);
+if (lean_is_exclusive(x_25)) {
+ lean_ctor_release(x_25, 0);
+ lean_ctor_release(x_25, 1);
+ x_31 = x_25;
 } else {
- lean_dec_ref(x_26);
- x_32 = lean_box(0);
+ lean_dec_ref(x_25);
+ x_31 = lean_box(0);
 }
-x_33 = lean_box(0);
-if (lean_is_scalar(x_32)) {
- x_34 = lean_alloc_ctor(0, 2, 0);
+x_32 = lean_box(0);
+if (lean_is_scalar(x_31)) {
+ x_33 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_34 = x_32;
+ x_33 = x_31;
 }
-lean_ctor_set(x_34, 0, x_31);
-lean_ctor_set(x_34, 1, x_33);
-x_35 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_35, 0, x_34);
-if (lean_is_scalar(x_30)) {
- x_36 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_33, 0, x_30);
+lean_ctor_set(x_33, 1, x_32);
+x_34 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_34, 0, x_33);
+if (lean_is_scalar(x_29)) {
+ x_35 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_36 = x_30;
+ x_35 = x_29;
 }
-lean_ctor_set(x_36, 0, x_27);
-lean_ctor_set(x_36, 1, x_28);
-lean_ctor_set(x_36, 2, x_29);
-lean_ctor_set(x_36, 3, x_35);
-return x_36;
+lean_ctor_set(x_35, 0, x_26);
+lean_ctor_set(x_35, 1, x_27);
+lean_ctor_set(x_35, 2, x_28);
+lean_ctor_set(x_35, 3, x_34);
+return x_35;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_setExpectedFn(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_setExpectedFn(lean_object* x_1) {
 _start:
 {
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_setExpectedFn___rarg), 4, 0);
-return x_3;
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_setExpectedFn___rarg), 3, 0);
+return x_2;
 }
 }
-lean_object* l_Lean_Parser_setExpectedFn___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_setExpectedFn___boxed(lean_object* x_1) {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
+lean_object* x_2; 
+x_2 = l_Lean_Parser_setExpectedFn(x_1);
 lean_dec(x_1);
-x_4 = l_Lean_Parser_setExpectedFn(x_3, x_2);
-lean_dec(x_2);
+return x_2;
+}
+}
+lean_object* l_Lean_Parser_setExpected___elambda__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Lean_Parser_setExpectedFn___rarg(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_setExpected___elambda__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_setExpected___elambda__1(lean_object* x_1) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l_Lean_Parser_setExpectedFn___rarg(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_setExpected___elambda__1___rarg), 3, 0);
+return x_2;
 }
 }
-lean_object* l_Lean_Parser_setExpected___elambda__1(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_setExpected(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_setExpected___elambda__1___rarg), 4, 0);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_setExpected(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
-_start:
+uint8_t x_3; 
+x_3 = !lean_is_exclusive(x_2);
+if (x_3 == 0)
 {
-uint8_t x_4; 
-x_4 = !lean_is_exclusive(x_3);
-if (x_4 == 0)
-{
-lean_object* x_5; lean_object* x_6; 
-x_5 = lean_ctor_get(x_3, 1);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_setExpected___elambda__1___rarg), 4, 1);
-lean_closure_set(x_6, 0, x_5);
-lean_ctor_set(x_3, 1, x_6);
-return x_3;
+lean_object* x_4; lean_object* x_5; 
+x_4 = lean_ctor_get(x_2, 1);
+x_5 = lean_alloc_closure((void*)(l_Lean_Parser_setExpected___elambda__1___rarg), 3, 1);
+lean_closure_set(x_5, 0, x_4);
+lean_ctor_set(x_2, 1, x_5);
+return x_2;
 }
 else
 {
-lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_3, 0);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_6 = lean_ctor_get(x_2, 0);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-lean_dec(x_3);
-x_9 = lean_alloc_closure((void*)(l_Lean_Parser_setExpected___elambda__1___rarg), 4, 1);
-lean_closure_set(x_9, 0, x_8);
-x_10 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_10, 0, x_7);
-lean_ctor_set(x_10, 1, x_9);
-return x_10;
+lean_inc(x_6);
+lean_dec(x_2);
+x_8 = lean_alloc_closure((void*)(l_Lean_Parser_setExpected___elambda__1___rarg), 3, 1);
+lean_closure_set(x_8, 0, x_7);
+x_9 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_9, 0, x_6);
+lean_ctor_set(x_9, 1, x_8);
+return x_9;
 }
 }
 }
-lean_object* l_Lean_Parser_setExpected___elambda__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_setExpected___elambda__1___boxed(lean_object* x_1) {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
+lean_object* x_2; 
+x_2 = l_Lean_Parser_setExpected___elambda__1(x_1);
 lean_dec(x_1);
-x_4 = l_Lean_Parser_setExpected___elambda__1(x_3, x_2);
-lean_dec(x_2);
-return x_4;
+return x_2;
 }
 }
-lean_object* l_Lean_Parser_setExpected___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_setExpected___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
+lean_object* x_3; 
+x_3 = l_Lean_Parser_setExpected(x_1, x_2);
 lean_dec(x_1);
-x_5 = l_Lean_Parser_setExpected(x_4, x_2, x_3);
-lean_dec(x_2);
-return x_5;
+return x_3;
 }
 }
 lean_object* l_Lean_Parser_pushNone___elambda__1___rarg(lean_object* x_1) {
@@ -26580,127 +25449,130 @@ x_3 = l_Lean_Parser_ParserState_pushSyntax(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_pushNone___elambda__1(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_pushNone___elambda__1(lean_object* x_1) {
 _start:
 {
-lean_object* x_4; 
-x_4 = lean_alloc_closure((void*)(l_Lean_Parser_pushNone___elambda__1___rarg), 1, 0);
-return x_4;
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_pushNone___elambda__1___rarg), 1, 0);
+return x_2;
 }
 }
-lean_object* l_Lean_Parser_pushNone(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_pushNone___closed__1() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_pushNone___elambda__1___boxed), 3, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_pushNone___elambda__1___boxed), 1, 0);
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_pushNone___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* _init_l_Lean_Parser_pushNone___closed__2() {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_Parser_pushNone___elambda__1(x_4, x_2, x_3);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_pushNone___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_pushNone(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_2 = l_Lean_Parser_pushNone___closed__1;
+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* l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* _init_l_Lean_Parser_pushNone() {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_apply_3(x_2, x_3, x_4, x_5);
-if (x_1 == 0)
+lean_object* x_1; 
+x_1 = l_Lean_Parser_pushNone___closed__2;
+return x_1;
+}
+}
+lean_object* l_Lean_Parser_pushNone___elambda__1___boxed(lean_object* x_1) {
+_start:
 {
-lean_object* x_9; lean_object* x_10; 
-x_9 = l_Lean_mkTermIdFromIdent___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7);
-return x_10;
+lean_object* x_2; 
+x_2 = l_Lean_Parser_pushNone___elambda__1(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+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_5 = l_Lean_Parser_identFn(x_1, x_2);
+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; 
+x_7 = l_Lean_Parser_pushNone___elambda__1___rarg(x_5);
+x_8 = l_Lean_mkTermIdFromIdent___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkNode(x_7, x_8, x_4);
+return x_9;
 }
 else
 {
-lean_object* x_11; lean_object* x_12; 
-x_11 = l_Lean_mkTermIdFromIdent___closed__2;
-x_12 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_11, x_7);
-lean_dec(x_7);
-return x_12;
+lean_object* x_10; lean_object* x_11; 
+lean_dec(x_6);
+x_10 = l_Lean_mkTermIdFromIdent___closed__2;
+x_11 = l_Lean_Parser_ParserState_mkNode(x_5, x_10, x_4);
+return x_11;
 }
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId(uint8_t x_1) {
+lean_object* _init_l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__1() {
 _start:
 {
-lean_object* x_2; 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; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_identFn___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_pushNone(x_1);
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-lean_dec(x_4);
-x_6 = l_Lean_Parser_identNoAntiquot___closed__1;
-x_7 = l_Lean_Parser_andthenInfo(x_6, x_5);
-x_8 = lean_box(x_1);
-x_9 = lean_alloc_closure((void*)(l_Lean_Parser_pushNone___elambda__1___boxed), 3, 1);
-lean_closure_set(x_9, 0, x_8);
-x_10 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_10, 0, x_3);
-lean_closure_set(x_10, 1, x_9);
-x_11 = l_Lean_mkTermIdFromIdent___closed__2;
-x_12 = l_Lean_Parser_nodeInfo(x_11, x_7);
-x_13 = lean_box(x_1);
-x_14 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1___boxed), 5, 2);
-lean_closure_set(x_14, 0, x_13);
-lean_closure_set(x_14, 1, x_10);
-x_15 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_15, 0, x_12);
-lean_ctor_set(x_15, 1, x_14);
-return x_15;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_pushNone;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_identNoAntiquot___closed__1;
+x_4 = l_Lean_Parser_andthenInfo(x_3, x_2);
+return x_4;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* _init_l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__2() {
 _start:
 {
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1(x_6, x_2, x_3, x_4, x_5);
-return x_7;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_13__antiquotId___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l___private_Init_Lean_Parser_Parser_13__antiquotId(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_mkTermIdFromIdent___closed__2;
+x_2 = l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__1;
+x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
 }
 }
+lean_object* _init_l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__3() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__2;
+x_2 = l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__3;
+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___private_Init_Lean_Parser_Parser_13__antiquotId() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__4;
+return x_1;
+}
+}
 lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1() {
 _start:
 {
@@ -26719,33 +25591,7 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_apply_3(x_2, x_3, x_4, x_5);
-if (x_1 == 0)
-{
-lean_object* x_9; lean_object* x_10; 
-x_9 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7);
-return x_10;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; 
-x_11 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-x_12 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_11, x_7);
-lean_dec(x_7);
-return x_12;
-}
-}
-}
-lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1() {
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -26754,39 +25600,7 @@ x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_3 = l_Lean_Parser_symbolInfo(x_2, x_1);
-return x_3;
-}
-}
-lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__3() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
-lean_closure_set(x_2, 0, x_1);
-return x_2;
-}
-}
-lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__4() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_termParser___closed__2;
-x_2 = lean_unsigned_to_nat(0u);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1___rarg___boxed), 5, 2);
-lean_closure_set(x_3, 0, x_1);
-lean_closure_set(x_3, 1, x_2);
-return x_3;
-}
-}
-lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5() {
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -26795,238 +25609,493 @@ x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6() {
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___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___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_3 = lean_string_append(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__6() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___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___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___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___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___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___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__8() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Char_HasRepr___closed__1;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_3 = lean_string_append(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__9() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__8;
+x_2 = l_Char_HasRepr___closed__1;
+x_3 = lean_string_append(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__9;
+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* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+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_46 = lean_ctor_get(x_2, 1);
+lean_inc(x_46);
+lean_inc(x_1);
+x_47 = l_Lean_Parser_tokenFn(x_1, x_2);
+x_48 = lean_ctor_get(x_47, 3);
+lean_inc(x_48);
+if (lean_obj_tag(x_48) == 0)
+{
+lean_object* x_49; lean_object* x_50; 
+x_49 = lean_ctor_get(x_47, 0);
+lean_inc(x_49);
+x_50 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_49);
+lean_dec(x_49);
+if (lean_obj_tag(x_50) == 2)
+{
+lean_object* x_51; lean_object* x_52; uint8_t x_53; 
+x_51 = lean_ctor_get(x_50, 1);
+lean_inc(x_51);
+lean_dec(x_50);
+x_52 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_53 = lean_string_dec_eq(x_51, x_52);
+lean_dec(x_51);
+if (x_53 == 0)
+{
+lean_object* x_54; lean_object* x_55; 
+x_54 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_54, x_46);
+x_5 = x_55;
+goto block_45;
+}
+else
+{
+lean_dec(x_46);
+x_5 = x_47;
+goto block_45;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; 
+lean_dec(x_50);
+x_56 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_56, x_46);
+x_5 = x_57;
+goto block_45;
+}
+}
+else
+{
+lean_object* x_58; lean_object* x_59; 
+lean_dec(x_48);
+x_58 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_58, x_46);
+x_5 = x_59;
+goto block_45;
+}
+block_45:
+{
+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_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_7 = lean_ctor_get(x_5, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_38 = l_Lean_Parser_termParser___closed__2;
+x_39 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_40 = l_Lean_Parser_categoryParser___elambda__1(x_38, x_39, x_1, x_5);
+x_41 = lean_ctor_get(x_40, 3);
+lean_inc(x_41);
+if (lean_obj_tag(x_41) == 0)
+{
+lean_object* x_42; 
+x_42 = l_Lean_Parser_pushNone___elambda__1___rarg(x_40);
+x_9 = x_42;
+goto block_37;
+}
+else
+{
+lean_dec(x_41);
+x_9 = x_40;
+goto block_37;
+}
+block_37:
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_10 = l_Lean_nullKind;
+x_11 = l_Lean_Parser_ParserState_mkNode(x_9, x_10, x_8);
+x_12 = lean_ctor_get(x_11, 3);
+lean_inc(x_12);
+if (lean_obj_tag(x_12) == 0)
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_13 = lean_ctor_get(x_11, 1);
+lean_inc(x_13);
+x_14 = l_Lean_Parser_tokenFn(x_1, x_11);
+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; 
+x_16 = lean_ctor_get(x_14, 0);
+lean_inc(x_16);
+x_17 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_16);
+lean_dec(x_16);
+if (lean_obj_tag(x_17) == 2)
+{
+lean_object* x_18; lean_object* x_19; uint8_t x_20; 
+x_18 = lean_ctor_get(x_17, 1);
+lean_inc(x_18);
+lean_dec(x_17);
+x_19 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_20 = lean_string_dec_eq(x_18, x_19);
+lean_dec(x_18);
+if (x_20 == 0)
+{
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_21 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_22 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_21, x_13);
+x_23 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_4);
+return x_24;
+}
+else
+{
+lean_object* x_25; lean_object* x_26; 
+lean_dec(x_13);
+x_25 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_14, x_25, x_4);
+return x_26;
+}
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_17);
+x_27 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_27, x_13);
+x_29 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_4);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_15);
+x_31 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_31, x_13);
+x_33 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_4);
+return x_34;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_12);
+lean_dec(x_1);
+x_35 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_11, x_35, x_4);
+return x_36;
+}
+}
+}
+else
+{
+lean_object* x_43; lean_object* x_44; 
+lean_dec(x_6);
+lean_dec(x_1);
+x_43 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_5, x_43, x_4);
+return x_44;
+}
+}
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
 x_3 = l_Lean_Parser_symbolInfo(x_2, x_1);
 return x_3;
 }
 }
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_termParser___closed__2;
+x_2 = lean_unsigned_to_nat(0u);
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_pushNone;
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_andthenInfo(x_2, x_4);
+return x_5;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_nullKind;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__3;
+x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_3 = l_Lean_Parser_symbolInfo(x_2, x_1);
+return x_3;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__4;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+return x_3;
+}
+}
 lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__7() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; 
-x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
-lean_closure_set(x_2, 0, x_1);
-return x_2;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 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; 
-x_2 = l_Lean_Parser_termParser___closed__2;
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-x_5 = l_Lean_Parser_pushNone(x_1);
-x_6 = lean_ctor_get(x_4, 0);
-lean_inc(x_6);
-lean_dec(x_4);
-x_7 = lean_ctor_get(x_5, 0);
-lean_inc(x_7);
-lean_dec(x_5);
-x_8 = l_Lean_Parser_andthenInfo(x_6, x_7);
-x_9 = lean_box(x_1);
-x_10 = lean_alloc_closure((void*)(l_Lean_Parser_pushNone___elambda__1___boxed), 3, 1);
-lean_closure_set(x_10, 0, x_9);
-x_11 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__4;
-x_12 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_12, 0, x_11);
-lean_closure_set(x_12, 1, x_10);
-x_13 = l_Lean_nullKind;
-x_14 = l_Lean_Parser_nodeInfo(x_13, x_8);
-x_15 = lean_box(x_1);
-x_16 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_16, 0, x_15);
-lean_closure_set(x_16, 1, x_13);
-lean_closure_set(x_16, 2, x_12);
-x_17 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
-x_18 = l_Lean_Parser_andthenInfo(x_14, x_17);
-x_19 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__7;
-x_20 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_20, 0, x_16);
-lean_closure_set(x_20, 1, x_19);
-x_21 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
-x_22 = l_Lean_Parser_andthenInfo(x_21, x_18);
-x_23 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__3;
-x_24 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_24, 0, x_23);
-lean_closure_set(x_24, 1, x_20);
-x_25 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-x_26 = l_Lean_Parser_nodeInfo(x_25, x_22);
-x_27 = lean_box(x_1);
-x_28 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___boxed), 5, 2);
-lean_closure_set(x_28, 0, x_27);
-lean_closure_set(x_28, 1, x_24);
-x_29 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_29, 0, x_26);
-lean_ctor_set(x_29, 1, x_28);
-return x_29;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1(x_6, x_2, x_3, x_4, x_5);
-return x_7;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__8() {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
-lean_inc(x_4);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__7;
+x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__9() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__10() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__8;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__9;
+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___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__10;
+return x_1;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-x_9 = lean_apply_3(x_1, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
+x_4 = lean_array_get_size(x_3);
 lean_dec(x_3);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
-lean_dec(x_11);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_apply_3(x_2, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
-}
-}
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1___rarg), 5, 0);
-return x_2;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 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; 
-x_2 = l___private_Init_Lean_Parser_Parser_13__antiquotId(x_1);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr(x_1);
-x_4 = lean_ctor_get(x_2, 0);
-lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 0);
+x_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_orelseInfo(x_4, x_5);
-x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_1);
+x_6 = l___private_Init_Lean_Parser_Parser_13__antiquotId___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
 lean_inc(x_7);
-lean_dec(x_2);
-x_8 = lean_ctor_get(x_3, 1);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-lean_dec(x_3);
-x_9 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1___rarg), 5, 2);
-lean_closure_set(x_9, 0, x_7);
-lean_closure_set(x_9, 1, x_8);
-x_10 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_10, 0, x_6);
-lean_ctor_set(x_10, 1, x_9);
-return x_10;
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+x_10 = lean_nat_dec_eq(x_9, x_5);
+lean_dec(x_9);
+if (x_10 == 0)
+{
+lean_dec(x_8);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1(x_1, x_11);
+x_13 = l_Lean_Parser_mergeOrElseErrors(x_12, x_8, x_5);
+lean_dec(x_5);
+return x_13;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1___boxed(lean_object* x_1) {
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__1() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_1 = l___private_Init_Lean_Parser_Parser_13__antiquotId;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr;
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_orelseInfo(x_2, x_4);
+return x_5;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_15__antiquotExpr___elambda__1), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__1;
+x_2 = l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__2;
+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* l___private_Init_Lean_Parser_Parser_15__antiquotExpr___boxed(lean_object* x_1) {
+lean_object* _init_l___private_Init_Lean_Parser_Parser_15__antiquotExpr() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l___private_Init_Lean_Parser_Parser_15__antiquotExpr(x_2);
-return x_3;
+lean_object* x_1; 
+x_1 = l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__3;
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_mkAntiquotAux___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_mkAntiquot___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_9 = l_Lean_Parser_ParserState_mkNode(x_8, x_1, x_7);
-return x_9;
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_2, x_3, x_4);
+x_8 = l_Lean_Parser_ParserState_mkNode(x_7, x_1, x_6);
+return x_8;
 }
 }
-lean_object* l_Lean_Parser_mkAntiquotAux___elambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_mkAntiquot___elambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_9 = l_Lean_Parser_ParserState_mkNode(x_8, x_1, x_7);
-return x_9;
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_2, x_3, x_4);
+x_8 = l_Lean_Parser_ParserState_mkNode(x_7, x_1, x_6);
+return x_8;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__1() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -27036,7 +26105,7 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__2() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -27044,7 +26113,7 @@ x_1 = lean_mk_string("no space before ':");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__3() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -27053,56 +26122,37 @@ x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__4() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_mkAntiquotAux___closed__3;
+x_2 = l_Lean_Parser_mkAntiquot___closed__3;
 x_3 = l_Lean_Parser_symbolInfo(x_2, x_1);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__5() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__3;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
+x_1 = l_Lean_Parser_mkAntiquot___closed__3;
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__6() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__6() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_dollarSymbol(x_1);
-return x_2;
-}
-}
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__7() {
-_start:
-{
-lean_object* x_1; uint8_t x_2; lean_object* x_3; lean_object* x_4; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = 0;
-x_3 = l_Lean_Parser_mkAntiquotAux___closed__6;
-x_4 = l_Lean_Parser_setExpected(x_2, x_1, x_3);
-return x_4;
+x_2 = l_Lean_Parser_dollarSymbol;
+x_3 = l_Lean_Parser_setExpected(x_1, x_2);
+return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__8() {
-_start:
-{
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l___private_Init_Lean_Parser_Parser_15__antiquotExpr(x_1);
-return x_2;
-}
-}
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__9() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__7() {
 _start:
 {
 lean_object* x_1; 
@@ -27110,87 +26160,87 @@ x_1 = lean_mk_string("*");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__10() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__9;
+x_1 = l_Lean_Parser_mkAntiquot___closed__7;
 x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__11() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__9() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_mkAntiquotAux___closed__10;
+x_2 = l_Lean_Parser_mkAntiquot___closed__8;
 x_3 = l_Lean_Parser_symbolInfo(x_2, x_1);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__12() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__10() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__10;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
+x_1 = l_Lean_Parser_mkAntiquot___closed__8;
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__13() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__11() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_epsilonInfo;
-x_2 = l_Lean_Parser_mkAntiquotAux___closed__11;
+x_2 = l_Lean_Parser_mkAntiquot___closed__9;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__14() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__12() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_String_splitAux___main___closed__1;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___rarg___boxed), 4, 1);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___boxed), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__15() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__14;
-x_2 = l_Lean_Parser_mkAntiquotAux___closed__12;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_1 = l_Lean_Parser_mkAntiquot___closed__12;
+x_2 = l_Lean_Parser_mkAntiquot___closed__10;
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__16() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__14() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__13;
+x_1 = l_Lean_Parser_mkAntiquot___closed__11;
 x_2 = l_Lean_Parser_optionaInfo(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__17() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__15() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__15;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn___rarg), 4, 1);
+x_1 = l_Lean_Parser_mkAntiquot___closed__13;
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__18() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__16() {
 _start:
 {
 lean_object* x_1; 
@@ -27198,39 +26248,21 @@ x_1 = lean_mk_string("no space before");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__19() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__17() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__18;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___rarg___boxed), 4, 1);
+x_1 = l_Lean_Parser_mkAntiquot___closed__16;
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___boxed), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__20() {
-_start:
-{
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon(x_1);
-return x_2;
-}
-}
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__21() {
-_start:
-{
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_pushNone(x_1);
-return x_2;
-}
-}
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__22() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__18() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__21;
+x_1 = l_Lean_Parser_pushNone;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 lean_inc(x_2);
@@ -27238,68 +26270,46 @@ x_3 = l_Lean_Parser_andthenInfo(x_2, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__23() {
-_start:
-{
-uint8_t x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = 0;
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_pushNone___elambda__1___boxed), 3, 1);
-lean_closure_set(x_3, 0, x_2);
-return x_3;
-}
-}
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__24() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__19() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__23;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_1 = l_Lean_Parser_pushNone___closed__1;
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_2, 0, x_1);
 lean_closure_set(x_2, 1, x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__25() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__20() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__20;
+x_1 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_mkAntiquotAux___closed__22;
+x_3 = l_Lean_Parser_mkAntiquot___closed__18;
 x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__26() {
-_start:
-{
-uint8_t x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = 0;
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-return x_3;
-}
-}
-lean_object* _init_l_Lean_Parser_mkAntiquotAux___closed__27() {
+lean_object* _init_l_Lean_Parser_mkAntiquot___closed__21() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__26;
-x_2 = l_Lean_Parser_mkAntiquotAux___closed__24;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_1 = l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__1;
+x_2 = l_Lean_Parser_mkAntiquot___closed__19;
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_mkAntiquotAux(lean_object* x_1, lean_object* x_2, uint8_t x_3) {
+lean_object* l_Lean_Parser_mkAntiquot(lean_object* x_1, lean_object* x_2, uint8_t x_3) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t 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; 
-x_4 = l_Lean_Parser_mkAntiquotAux___closed__2;
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t 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; 
+x_4 = l_Lean_Parser_mkAntiquot___closed__2;
 x_5 = lean_string_append(x_4, x_1);
 x_6 = l_Char_HasRepr___closed__1;
 x_7 = lean_string_append(x_5, x_6);
@@ -27307,82 +26317,81 @@ x_8 = l_String_trim(x_1);
 x_9 = 0;
 lean_inc(x_8);
 x_10 = l_Lean_Parser_nonReservedSymbolInfo(x_8, x_9);
-x_11 = lean_alloc_closure((void*)(l_Lean_Parser_nonReservedSymbol___lambda__1___boxed), 4, 1);
+x_11 = lean_alloc_closure((void*)(l_Lean_Parser_nonReservedSymbolFn), 3, 1);
 lean_closure_set(x_11, 0, x_8);
-x_12 = l_Lean_Parser_mkAntiquotAux___closed__4;
+x_12 = l_Lean_Parser_mkAntiquot___closed__4;
 x_13 = l_Lean_Parser_andthenInfo(x_12, x_10);
-x_14 = l_Lean_Parser_mkAntiquotAux___closed__5;
-x_15 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_14 = l_Lean_Parser_mkAntiquot___closed__5;
+x_15 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_15, 0, x_14);
 lean_closure_set(x_15, 1, x_11);
 x_16 = l_Lean_Parser_epsilonInfo;
 x_17 = l_Lean_Parser_andthenInfo(x_16, x_13);
-x_18 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___rarg___boxed), 4, 1);
+x_18 = lean_alloc_closure((void*)(l_Lean_Parser_checkNoWsBefore___elambda__1___boxed), 3, 1);
 lean_closure_set(x_18, 0, x_7);
-x_19 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_19 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_19, 0, x_18);
 lean_closure_set(x_19, 1, x_15);
-x_20 = l_Lean_Parser_mkAntiquotAux___closed__8;
+x_20 = l___private_Init_Lean_Parser_Parser_15__antiquotExpr;
 x_21 = lean_ctor_get(x_20, 0);
 lean_inc(x_21);
-x_22 = lean_ctor_get(x_20, 1);
-lean_inc(x_22);
-x_23 = l_Lean_Parser_mkAntiquotAux___closed__6;
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = l_Lean_Parser_mkAntiquotAux___closed__7;
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
+x_22 = l_Lean_Parser_dollarSymbol;
+x_23 = lean_ctor_get(x_22, 0);
+lean_inc(x_23);
+x_24 = l_Lean_Parser_mkAntiquot___closed__6;
+x_25 = lean_ctor_get(x_24, 1);
+lean_inc(x_25);
 if (lean_obj_tag(x_2) == 0)
 {
-lean_object* x_65; 
-x_65 = lean_box(0);
-x_27 = x_65;
-goto block_64;
+lean_object* x_66; 
+x_66 = lean_box(0);
+x_26 = x_66;
+goto block_65;
 }
 else
 {
-lean_object* x_66; 
-x_66 = lean_ctor_get(x_2, 0);
-lean_inc(x_66);
+lean_object* x_67; 
+x_67 = lean_ctor_get(x_2, 0);
+lean_inc(x_67);
 lean_dec(x_2);
-x_27 = x_66;
-goto block_64;
+x_26 = x_67;
+goto block_65;
 }
-block_64:
+block_65:
 {
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Lean_Parser_mkAntiquotAux___closed__1;
-x_29 = l_Lean_Name_append___main(x_27, x_28);
-lean_dec(x_27);
+lean_object* x_27; lean_object* x_28; 
+x_27 = l_Lean_Parser_mkAntiquot___closed__1;
+x_28 = l_Lean_Name_append___main(x_26, x_27);
+lean_dec(x_26);
 if (x_3 == 0)
 {
-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; 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; lean_object* x_44; 
-x_30 = l_Lean_Parser_mkAntiquotAux___closed__16;
-x_31 = l_Lean_Parser_andthenInfo(x_17, x_30);
-x_32 = l_Lean_Parser_mkAntiquotAux___closed__17;
-x_33 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_33, 0, x_19);
-lean_closure_set(x_33, 1, x_32);
-x_34 = l_Lean_Parser_andthenInfo(x_21, x_31);
-x_35 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_35, 0, x_22);
-lean_closure_set(x_35, 1, x_33);
-x_36 = l_Lean_Parser_andthenInfo(x_16, x_34);
-x_37 = l_Lean_Parser_mkAntiquotAux___closed__19;
-x_38 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+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; 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; lean_object* x_44; 
+x_29 = l_Lean_Parser_mkAntiquot___closed__14;
+x_30 = l_Lean_Parser_andthenInfo(x_17, x_29);
+x_31 = l_Lean_Parser_mkAntiquot___closed__15;
+x_32 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_32, 0, x_19);
+lean_closure_set(x_32, 1, x_31);
+x_33 = l_Lean_Parser_andthenInfo(x_21, x_30);
+x_34 = l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__2;
+x_35 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_35, 0, x_34);
+lean_closure_set(x_35, 1, x_32);
+x_36 = l_Lean_Parser_andthenInfo(x_16, x_33);
+x_37 = l_Lean_Parser_mkAntiquot___closed__17;
+x_38 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_38, 0, x_37);
 lean_closure_set(x_38, 1, x_35);
-x_39 = l_Lean_Parser_andthenInfo(x_24, x_36);
-x_40 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_40, 0, x_26);
+x_39 = l_Lean_Parser_andthenInfo(x_23, x_36);
+x_40 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_40, 0, x_25);
 lean_closure_set(x_40, 1, x_38);
-x_41 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
+x_41 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn), 3, 1);
 lean_closure_set(x_41, 0, x_40);
-lean_inc(x_29);
-x_42 = l_Lean_Parser_nodeInfo(x_29, x_39);
-x_43 = lean_alloc_closure((void*)(l_Lean_Parser_mkAntiquotAux___elambda__1), 5, 2);
-lean_closure_set(x_43, 0, x_29);
+lean_inc(x_28);
+x_42 = l_Lean_Parser_nodeInfo(x_28, x_39);
+x_43 = lean_alloc_closure((void*)(l_Lean_Parser_mkAntiquot___elambda__1), 4, 2);
+lean_closure_set(x_43, 0, x_28);
 lean_closure_set(x_43, 1, x_41);
 x_44 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_44, 0, x_42);
@@ -27391,323 +26400,158 @@ 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_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_45 = l_Lean_Parser_mkAntiquotAux___closed__25;
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 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; 
+x_45 = l_Lean_Parser_mkAntiquot___closed__20;
 x_46 = l_Lean_Parser_orelseInfo(x_17, x_45);
-x_47 = l_Lean_Parser_mkAntiquotAux___closed__27;
-x_48 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 2);
+x_47 = l_Lean_Parser_mkAntiquot___closed__21;
+x_48 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn), 4, 2);
 lean_closure_set(x_48, 0, x_19);
 lean_closure_set(x_48, 1, x_47);
-x_49 = l_Lean_Parser_mkAntiquotAux___closed__16;
+x_49 = l_Lean_Parser_mkAntiquot___closed__14;
 x_50 = l_Lean_Parser_andthenInfo(x_46, x_49);
-x_51 = l_Lean_Parser_mkAntiquotAux___closed__17;
-x_52 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_51 = l_Lean_Parser_mkAntiquot___closed__15;
+x_52 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_52, 0, x_48);
 lean_closure_set(x_52, 1, x_51);
 x_53 = l_Lean_Parser_andthenInfo(x_21, x_50);
-x_54 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_54, 0, x_22);
-lean_closure_set(x_54, 1, x_52);
-x_55 = l_Lean_Parser_andthenInfo(x_16, x_53);
-x_56 = l_Lean_Parser_mkAntiquotAux___closed__19;
-x_57 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_57, 0, x_56);
-lean_closure_set(x_57, 1, x_54);
-x_58 = l_Lean_Parser_andthenInfo(x_24, x_55);
-x_59 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_59, 0, x_26);
-lean_closure_set(x_59, 1, x_57);
-x_60 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
-lean_closure_set(x_60, 0, x_59);
-lean_inc(x_29);
-x_61 = l_Lean_Parser_nodeInfo(x_29, x_58);
-x_62 = lean_alloc_closure((void*)(l_Lean_Parser_mkAntiquotAux___elambda__2), 5, 2);
-lean_closure_set(x_62, 0, x_29);
-lean_closure_set(x_62, 1, x_60);
-x_63 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_63, 0, x_61);
-lean_ctor_set(x_63, 1, x_62);
-return x_63;
+x_54 = l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__2;
+x_55 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_55, 0, x_54);
+lean_closure_set(x_55, 1, x_52);
+x_56 = l_Lean_Parser_andthenInfo(x_16, x_53);
+x_57 = l_Lean_Parser_mkAntiquot___closed__17;
+x_58 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_58, 0, x_57);
+lean_closure_set(x_58, 1, x_55);
+x_59 = l_Lean_Parser_andthenInfo(x_23, x_56);
+x_60 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_60, 0, x_25);
+lean_closure_set(x_60, 1, x_58);
+x_61 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn), 3, 1);
+lean_closure_set(x_61, 0, x_60);
+lean_inc(x_28);
+x_62 = l_Lean_Parser_nodeInfo(x_28, x_59);
+x_63 = lean_alloc_closure((void*)(l_Lean_Parser_mkAntiquot___elambda__2), 4, 2);
+lean_closure_set(x_63, 0, x_28);
+lean_closure_set(x_63, 1, x_61);
+x_64 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_64, 0, x_62);
+lean_ctor_set(x_64, 1, x_63);
+return x_64;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_mkAntiquotAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_mkAntiquot___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint8_t x_4; lean_object* x_5; 
 x_4 = lean_unbox(x_3);
 lean_dec(x_3);
-x_5 = l_Lean_Parser_mkAntiquotAux(x_1, x_2, x_4);
+x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_4);
 lean_dec(x_1);
 return x_5;
 }
 }
-lean_object* l_Lean_Parser_mkAntiquot___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_nodeWithAntiquot___elambda__1(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_ctor_get(x_1, 1);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_5 = lean_ctor_get(x_4, 0);
 lean_inc(x_5);
-lean_dec(x_1);
-x_6 = lean_unsigned_to_nat(0u);
-x_7 = lean_apply_3(x_5, x_6, x_3, x_4);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_mkAntiquot(uint8_t x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4) {
-_start:
-{
-if (x_1 == 0)
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_mkAntiquotAux(x_2, x_3, x_4);
-return x_5;
-}
-else
-{
-lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
-x_6 = l_Lean_Parser_mkAntiquotAux(x_2, x_3, x_4);
-x_7 = lean_ctor_get(x_6, 0);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_4, 1);
 lean_inc(x_7);
-lean_inc(x_6);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_mkAntiquot___elambda__1___boxed), 4, 1);
-lean_closure_set(x_8, 0, x_6);
-x_9 = !lean_is_exclusive(x_6);
-if (x_9 == 0)
+lean_inc(x_3);
+x_8 = lean_apply_2(x_2, x_3, x_4);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_10; lean_object* x_11; 
-x_10 = lean_ctor_get(x_6, 1);
 lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_apply_2(x_1, x_3, x_13);
+x_15 = l_Lean_Parser_mergeOrElseErrors(x_14, x_10, x_7);
+lean_dec(x_7);
+return x_15;
+}
+}
+}
+}
+lean_object* l_Lean_Parser_nodeWithAntiquot(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint8_t 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_inc(x_2);
+x_4 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_4, 0, x_2);
+x_5 = 0;
+x_6 = l_Lean_Parser_mkAntiquot(x_1, x_4, x_5);
+x_7 = lean_ctor_get(x_3, 0);
+lean_inc(x_7);
+lean_inc(x_2);
+x_8 = l_Lean_Parser_nodeInfo(x_2, x_7);
+x_9 = lean_ctor_get(x_3, 1);
+lean_inc(x_9);
+lean_dec(x_3);
+x_10 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+lean_closure_set(x_10, 0, x_2);
+lean_closure_set(x_10, 1, x_9);
 x_11 = lean_ctor_get(x_6, 0);
-lean_dec(x_11);
-lean_ctor_set(x_6, 1, x_8);
-return x_6;
-}
-else
-{
-lean_object* x_12; 
-lean_dec(x_6);
-x_12 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_12, 0, x_7);
-lean_ctor_set(x_12, 1, x_8);
-return x_12;
-}
-}
-}
-}
-lean_object* l_Lean_Parser_mkAntiquot___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Lean_Parser_mkAntiquot___elambda__1(x_1, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_mkAntiquot___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; uint8_t x_6; lean_object* x_7; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = lean_unbox(x_4);
-lean_dec(x_4);
-x_7 = l_Lean_Parser_mkAntiquot(x_5, x_2, x_3, x_6);
-lean_dec(x_2);
-return x_7;
-}
-}
-lean_object* l_Lean_Parser_nodeWithAntiquot___elambda__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; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
-lean_inc(x_4);
-lean_inc(x_3);
-x_9 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
-lean_dec(x_11);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_apply_3(x_1, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
-}
-}
-}
-}
-lean_object* l_Lean_Parser_nodeWithAntiquot___elambda__1(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_nodeWithAntiquot___elambda__1___rarg), 5, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_nodeWithAntiquot(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; uint8_t 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_inc(x_3);
-x_5 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_5, 0, x_3);
-x_6 = 0;
-x_7 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_5, x_6);
-x_8 = lean_ctor_get(x_4, 0);
-lean_inc(x_8);
-lean_inc(x_3);
-x_9 = l_Lean_Parser_nodeInfo(x_3, x_8);
-x_10 = lean_ctor_get(x_4, 1);
-lean_inc(x_10);
-lean_dec(x_4);
-x_11 = lean_box(x_1);
-x_12 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_12, 0, x_11);
-lean_closure_set(x_12, 1, x_3);
-lean_closure_set(x_12, 2, x_10);
-x_13 = lean_ctor_get(x_7, 0);
+x_12 = l_Lean_Parser_orelseInfo(x_11, x_8);
+x_13 = lean_ctor_get(x_6, 1);
 lean_inc(x_13);
-x_14 = l_Lean_Parser_orelseInfo(x_13, x_9);
-x_15 = lean_ctor_get(x_7, 1);
-lean_inc(x_15);
-lean_dec(x_7);
-x_16 = lean_alloc_closure((void*)(l_Lean_Parser_nodeWithAntiquot___elambda__1___rarg), 5, 2);
-lean_closure_set(x_16, 0, x_12);
-lean_closure_set(x_16, 1, x_15);
-x_17 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_17, 0, x_14);
-lean_ctor_set(x_17, 1, x_16);
-return x_17;
-}
-}
-lean_object* l_Lean_Parser_nodeWithAntiquot___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_nodeWithAntiquot___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_nodeWithAntiquot___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_nodeWithAntiquot(x_5, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_ident___elambda__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; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
-lean_inc(x_4);
-lean_inc(x_3);
-x_9 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
-lean_dec(x_11);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_apply_3(x_1, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
+x_14 = lean_alloc_closure((void*)(l_Lean_Parser_nodeWithAntiquot___elambda__1), 4, 2);
+lean_closure_set(x_14, 0, x_10);
+lean_closure_set(x_14, 1, x_13);
+x_15 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_15, 0, x_12);
+lean_ctor_set(x_15, 1, x_14);
+return x_15;
 }
 }
-}
-}
-lean_object* l_Lean_Parser_ident___elambda__1(uint8_t x_1) {
+lean_object* l_Lean_Parser_nodeWithAntiquot___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_ident___elambda__1___rarg), 5, 0);
-return x_2;
+lean_object* x_4; 
+x_4 = l_Lean_Parser_nodeWithAntiquot(x_1, x_2, x_3);
+lean_dec(x_1);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_ident___closed__1() {
+lean_object* _init_l_Lean_Parser_ident___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -27717,231 +26561,211 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_ident(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_ident___elambda__1___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; uint8_t 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; 
-x_2 = l_Lean_identKind___closed__1;
-x_3 = l_Lean_Parser_ident___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-x_6 = lean_box(x_1);
-x_7 = lean_alloc_closure((void*)(l_Lean_Parser_identFn___boxed), 2, 1);
-lean_closure_set(x_7, 0, x_6);
-x_8 = lean_ctor_get(x_5, 0);
-lean_inc(x_8);
-x_9 = l_Lean_Parser_identNoAntiquot___closed__1;
-x_10 = l_Lean_Parser_orelseInfo(x_8, x_9);
-x_11 = lean_ctor_get(x_5, 1);
-lean_inc(x_11);
-lean_dec(x_5);
-x_12 = lean_alloc_closure((void*)(l_Lean_Parser_ident___elambda__1___rarg), 5, 2);
-lean_closure_set(x_12, 0, x_7);
-lean_closure_set(x_12, 1, x_11);
-x_13 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_13, 0, x_10);
-lean_ctor_set(x_13, 1, x_12);
-return x_13;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_identKind___closed__1;
+x_2 = l_Lean_Parser_ident___elambda__1___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_ident___elambda__1___boxed(lean_object* x_1) {
+lean_object* l_Lean_Parser_ident___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_ident___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_ident___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_ident(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_rawIdent___elambda__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; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
+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; 
+x_3 = l_Lean_Parser_ident___elambda__1___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
 lean_inc(x_4);
-lean_inc(x_3);
-x_9 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
-lean_dec(x_11);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_apply_3(x_1, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
-}
-}
-}
-}
-lean_object* l_Lean_Parser_rawIdent___elambda__1(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_rawIdent___elambda__1___rarg), 5, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_rawIdent(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; lean_object* x_3; uint8_t 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; 
-x_2 = l_Lean_identKind___closed__1;
-x_3 = l_Lean_Parser_ident___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_8 = l_Lean_Parser_orelseInfo(x_6, x_7);
-x_9 = lean_ctor_get(x_5, 1);
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
 lean_inc(x_9);
-lean_dec(x_5);
-x_10 = l_Lean_Parser_rawIdentNoAntiquot___closed__1;
-x_11 = lean_alloc_closure((void*)(l_Lean_Parser_rawIdent___elambda__1___rarg), 5, 2);
-lean_closure_set(x_11, 0, x_10);
-lean_closure_set(x_11, 1, x_9);
-x_12 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_12, 0, x_8);
-lean_ctor_set(x_12, 1, x_11);
-return x_12;
-}
-}
-lean_object* l_Lean_Parser_rawIdent___elambda__1___boxed(lean_object* x_1) {
-_start:
+if (lean_obj_tag(x_9) == 0)
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_rawIdent___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_rawIdent___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_rawIdent(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_numLit___elambda__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; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
-lean_inc(x_4);
-lean_inc(x_3);
-x_9 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = l_Lean_Parser_identFn(x_1, x_13);
+x_15 = l_Lean_Parser_mergeOrElseErrors(x_14, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_apply_3(x_1, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
+return x_15;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_numLit___elambda__1(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_ident___closed__1() {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_numLit___elambda__1___rarg), 5, 0);
-return x_2;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_ident___elambda__1___closed__2;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_identNoAntiquot___closed__1;
+x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_numLit___closed__1() {
+lean_object* _init_l_Lean_Parser_ident___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_ident___elambda__1), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_ident___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_ident___closed__1;
+x_2 = l_Lean_Parser_ident___closed__2;
+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_ident() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_ident___closed__3;
+return x_1;
+}
+}
+lean_object* l_Lean_Parser_rawIdent___elambda__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+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; 
+x_3 = l_Lean_Parser_ident___elambda__1___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = l_Lean_Parser_rawIdentFn(x_1, x_13);
+lean_dec(x_1);
+x_15 = l_Lean_Parser_mergeOrElseErrors(x_14, x_10, x_7);
+lean_dec(x_7);
+return x_15;
+}
+}
+}
+}
+lean_object* _init_l_Lean_Parser_rawIdent___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_ident___elambda__1___closed__2;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
+return x_4;
+}
+}
+lean_object* _init_l_Lean_Parser_rawIdent___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_rawIdent___elambda__1), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_rawIdent___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_rawIdent___closed__1;
+x_2 = l_Lean_Parser_rawIdent___closed__2;
+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_rawIdent() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_rawIdent___closed__3;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_numLit___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -27951,120 +26775,114 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_numLit(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_numLit___elambda__1___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; uint8_t 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; 
-x_2 = l_Lean_numLitKind___closed__1;
-x_3 = l_Lean_Parser_numLit___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-x_6 = lean_box(x_1);
-x_7 = lean_alloc_closure((void*)(l_Lean_Parser_numLitFn___boxed), 2, 1);
-lean_closure_set(x_7, 0, x_6);
-x_8 = lean_ctor_get(x_5, 0);
-lean_inc(x_8);
-x_9 = l_Lean_Parser_numLitNoAntiquot___closed__1;
-x_10 = l_Lean_Parser_orelseInfo(x_8, x_9);
-x_11 = lean_ctor_get(x_5, 1);
-lean_inc(x_11);
-lean_dec(x_5);
-x_12 = lean_alloc_closure((void*)(l_Lean_Parser_numLit___elambda__1___rarg), 5, 2);
-lean_closure_set(x_12, 0, x_7);
-lean_closure_set(x_12, 1, x_11);
-x_13 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_13, 0, x_10);
-lean_ctor_set(x_13, 1, x_12);
-return x_13;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_numLitKind___closed__1;
+x_2 = l_Lean_Parser_numLit___elambda__1___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_numLit___elambda__1___boxed(lean_object* x_1) {
+lean_object* l_Lean_Parser_numLit___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_numLit___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_numLit___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_numLit(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_strLit___elambda__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; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
+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; 
+x_3 = l_Lean_Parser_numLit___elambda__1___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
 lean_inc(x_4);
-lean_inc(x_3);
-x_9 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = l_Lean_Parser_numLitFn(x_1, x_13);
+x_15 = l_Lean_Parser_mergeOrElseErrors(x_14, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_apply_3(x_1, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
+return x_15;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_strLit___elambda__1(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_numLit___closed__1() {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_strLit___elambda__1___rarg), 5, 0);
-return x_2;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_numLit___elambda__1___closed__2;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_numLitNoAntiquot___closed__1;
+x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_strLit___closed__1() {
+lean_object* _init_l_Lean_Parser_numLit___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_numLit___elambda__1), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_numLit___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_numLit___closed__1;
+x_2 = l_Lean_Parser_numLit___closed__2;
+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_numLit() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_numLit___closed__3;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_strLit___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -28074,120 +26892,114 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_strLit(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_strLit___elambda__1___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; uint8_t 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; 
-x_2 = l_Lean_strLitKind___closed__1;
-x_3 = l_Lean_Parser_strLit___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-x_6 = lean_box(x_1);
-x_7 = lean_alloc_closure((void*)(l_Lean_Parser_strLitFn___boxed), 2, 1);
-lean_closure_set(x_7, 0, x_6);
-x_8 = lean_ctor_get(x_5, 0);
-lean_inc(x_8);
-x_9 = l_Lean_Parser_strLitNoAntiquot___closed__1;
-x_10 = l_Lean_Parser_orelseInfo(x_8, x_9);
-x_11 = lean_ctor_get(x_5, 1);
-lean_inc(x_11);
-lean_dec(x_5);
-x_12 = lean_alloc_closure((void*)(l_Lean_Parser_strLit___elambda__1___rarg), 5, 2);
-lean_closure_set(x_12, 0, x_7);
-lean_closure_set(x_12, 1, x_11);
-x_13 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_13, 0, x_10);
-lean_ctor_set(x_13, 1, x_12);
-return x_13;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_strLitKind___closed__1;
+x_2 = l_Lean_Parser_strLit___elambda__1___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_strLit___elambda__1___boxed(lean_object* x_1) {
+lean_object* l_Lean_Parser_strLit___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_strLit___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_strLit___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_strLit(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_charLit___elambda__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; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
+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; 
+x_3 = l_Lean_Parser_strLit___elambda__1___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
 lean_inc(x_4);
-lean_inc(x_3);
-x_9 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = l_Lean_Parser_strLitFn(x_1, x_13);
+x_15 = l_Lean_Parser_mergeOrElseErrors(x_14, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_apply_3(x_1, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
+return x_15;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_charLit___elambda__1(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_strLit___closed__1() {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_charLit___elambda__1___rarg), 5, 0);
-return x_2;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_strLit___elambda__1___closed__2;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_strLitNoAntiquot___closed__1;
+x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_charLit___closed__1() {
+lean_object* _init_l_Lean_Parser_strLit___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_strLit___elambda__1), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_strLit___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_strLit___closed__1;
+x_2 = l_Lean_Parser_strLit___closed__2;
+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_strLit() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_strLit___closed__3;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_charLit___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -28197,120 +27009,114 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_charLit(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_charLit___elambda__1___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; uint8_t 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; 
-x_2 = l_Lean_charLitKind___closed__1;
-x_3 = l_Lean_Parser_charLit___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-x_6 = lean_box(x_1);
-x_7 = lean_alloc_closure((void*)(l_Lean_Parser_charLitFn___boxed), 2, 1);
-lean_closure_set(x_7, 0, x_6);
-x_8 = lean_ctor_get(x_5, 0);
-lean_inc(x_8);
-x_9 = l_Lean_Parser_charLitNoAntiquot___closed__1;
-x_10 = l_Lean_Parser_orelseInfo(x_8, x_9);
-x_11 = lean_ctor_get(x_5, 1);
-lean_inc(x_11);
-lean_dec(x_5);
-x_12 = lean_alloc_closure((void*)(l_Lean_Parser_charLit___elambda__1___rarg), 5, 2);
-lean_closure_set(x_12, 0, x_7);
-lean_closure_set(x_12, 1, x_11);
-x_13 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_13, 0, x_10);
-lean_ctor_set(x_13, 1, x_12);
-return x_13;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_charLitKind___closed__1;
+x_2 = l_Lean_Parser_charLit___elambda__1___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_charLit___elambda__1___boxed(lean_object* x_1) {
+lean_object* l_Lean_Parser_charLit___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_charLit___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_charLit___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_charLit(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_nameLit___elambda__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; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
+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; 
+x_3 = l_Lean_Parser_charLit___elambda__1___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
 lean_inc(x_4);
-lean_inc(x_3);
-x_9 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = l_Lean_Parser_charLitFn(x_1, x_13);
+x_15 = l_Lean_Parser_mergeOrElseErrors(x_14, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_apply_3(x_1, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
+return x_15;
 }
 }
 }
 }
-lean_object* l_Lean_Parser_nameLit___elambda__1(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_charLit___closed__1() {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_nameLit___elambda__1___rarg), 5, 0);
-return x_2;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_charLit___elambda__1___closed__2;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_charLitNoAntiquot___closed__1;
+x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_nameLit___closed__1() {
+lean_object* _init_l_Lean_Parser_charLit___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_charLit___elambda__1), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_charLit___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_charLit___closed__1;
+x_2 = l_Lean_Parser_charLit___closed__2;
+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_charLit() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_charLit___closed__3;
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_nameLit___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -28320,51 +27126,111 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_nameLit(uint8_t x_1) {
+lean_object* _init_l_Lean_Parser_nameLit___elambda__1___closed__2() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; uint8_t 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; 
-x_2 = l_Lean_nameLitKind___closed__1;
-x_3 = l_Lean_Parser_nameLit___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-x_6 = lean_box(x_1);
-x_7 = lean_alloc_closure((void*)(l_Lean_Parser_nameLitFn___boxed), 2, 1);
-lean_closure_set(x_7, 0, x_6);
-x_8 = lean_ctor_get(x_5, 0);
-lean_inc(x_8);
-x_9 = l_Lean_Parser_nameLitNoAntiquot___closed__1;
-x_10 = l_Lean_Parser_orelseInfo(x_8, x_9);
-x_11 = lean_ctor_get(x_5, 1);
-lean_inc(x_11);
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_nameLitKind___closed__1;
+x_2 = l_Lean_Parser_nameLit___elambda__1___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
+}
+}
+lean_object* l_Lean_Parser_nameLit___elambda__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+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; 
+x_3 = l_Lean_Parser_nameLit___elambda__1___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
 lean_dec(x_5);
-x_12 = lean_alloc_closure((void*)(l_Lean_Parser_nameLit___elambda__1___rarg), 5, 2);
-lean_closure_set(x_12, 0, x_7);
-lean_closure_set(x_12, 1, x_11);
-x_13 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_13, 0, x_10);
-lean_ctor_set(x_13, 1, x_12);
-return x_13;
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = l_Lean_Parser_nameLitFn(x_1, x_13);
+x_15 = l_Lean_Parser_mergeOrElseErrors(x_14, x_10, x_7);
+lean_dec(x_7);
+return x_15;
 }
 }
-lean_object* l_Lean_Parser_nameLit___elambda__1___boxed(lean_object* x_1) {
+}
+}
+lean_object* _init_l_Lean_Parser_nameLit___closed__1() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_nameLit___elambda__1(x_2);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_nameLit___elambda__1___closed__2;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_nameLitNoAntiquot___closed__1;
+x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
+return x_4;
+}
+}
+lean_object* _init_l_Lean_Parser_nameLit___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_nameLit___elambda__1), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_nameLit___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_nameLit___closed__1;
+x_2 = l_Lean_Parser_nameLit___closed__2;
+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* l_Lean_Parser_nameLit___boxed(lean_object* x_1) {
+lean_object* _init_l_Lean_Parser_nameLit() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_nameLit(x_2);
-return x_3;
+lean_object* x_1; 
+x_1 = l_Lean_Parser_nameLit___closed__3;
+return x_1;
 }
 }
 lean_object* _init_l_Lean_Parser_categoryParserOfStackFn___closed__1() {
@@ -28383,127 +27249,122 @@ x_1 = lean_mk_string("failed to determine parser category using syntax stack, st
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_categoryParserOfStackFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_categoryParserOfStackFn(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _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_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-x_7 = lean_unsigned_to_nat(1u);
-x_8 = lean_nat_add(x_1, x_7);
-x_9 = lean_nat_dec_lt(x_6, x_8);
-lean_dec(x_8);
-if (x_9 == 0)
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = lean_array_get_size(x_4);
+x_6 = lean_unsigned_to_nat(1u);
+x_7 = lean_nat_add(x_1, x_6);
+x_8 = lean_nat_dec_lt(x_5, x_7);
+lean_dec(x_7);
+if (x_8 == 0)
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_10 = lean_nat_sub(x_6, x_1);
-lean_dec(x_6);
-x_11 = lean_nat_sub(x_10, x_7);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_9 = lean_nat_sub(x_5, x_1);
+lean_dec(x_5);
+x_10 = lean_nat_sub(x_9, x_6);
+lean_dec(x_9);
+x_11 = l_Lean_Syntax_inhabited;
+x_12 = lean_array_get(x_11, x_4, x_10);
 lean_dec(x_10);
-x_12 = l_Lean_Syntax_inhabited;
-x_13 = lean_array_get(x_12, x_5, x_11);
-lean_dec(x_11);
-lean_dec(x_5);
-if (lean_obj_tag(x_13) == 3)
+lean_dec(x_4);
+if (lean_obj_tag(x_12) == 3)
 {
-lean_object* x_14; lean_object* x_15; 
-x_14 = lean_ctor_get(x_13, 2);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = l_Lean_Parser_categoryParserFn(x_14, x_2, x_3, x_4);
-return x_15;
+lean_object* x_13; lean_object* x_14; 
+x_13 = lean_ctor_get(x_12, 2);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_categoryParserFn(x_13, x_2, x_3);
+return x_14;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; 
-lean_dec(x_13);
-lean_dec(x_3);
+lean_object* x_15; lean_object* x_16; 
+lean_dec(x_12);
 lean_dec(x_2);
-x_16 = l_Lean_Parser_categoryParserOfStackFn___closed__1;
-x_17 = l_Lean_Parser_ParserState_mkUnexpectedError(x_4, x_16);
-return x_17;
+x_15 = l_Lean_Parser_categoryParserOfStackFn___closed__1;
+x_16 = l_Lean_Parser_ParserState_mkUnexpectedError(x_3, x_15);
+return x_16;
 }
 }
 else
 {
-lean_object* x_18; lean_object* x_19; 
-lean_dec(x_6);
+lean_object* x_17; lean_object* x_18; 
 lean_dec(x_5);
-lean_dec(x_3);
+lean_dec(x_4);
 lean_dec(x_2);
-x_18 = l_Lean_Parser_categoryParserOfStackFn___closed__2;
-x_19 = l_Lean_Parser_ParserState_mkUnexpectedError(x_4, x_18);
-return x_19;
+x_17 = l_Lean_Parser_categoryParserOfStackFn___closed__2;
+x_18 = l_Lean_Parser_ParserState_mkUnexpectedError(x_3, x_17);
+return x_18;
 }
 }
 }
-lean_object* l_Lean_Parser_categoryParserOfStackFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_categoryParserOfStackFn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l_Lean_Parser_categoryParserOfStackFn(x_1, x_2, x_3, x_4);
+lean_object* x_4; 
+x_4 = l_Lean_Parser_categoryParserOfStackFn(x_1, x_2, x_3);
 lean_dec(x_1);
+return x_4;
+}
+}
+lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; 
+x_5 = !lean_is_exclusive(x_3);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; 
+x_6 = lean_ctor_get(x_3, 1);
+lean_dec(x_6);
+lean_ctor_set(x_3, 1, x_2);
+x_7 = l_Lean_Parser_categoryParserOfStackFn(x_1, x_3, x_4);
+return x_7;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_8 = lean_ctor_get(x_3, 0);
+x_9 = lean_ctor_get(x_3, 2);
+x_10 = lean_ctor_get(x_3, 3);
+lean_inc(x_10);
+lean_inc(x_9);
+lean_inc(x_8);
+lean_dec(x_3);
+x_11 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_11, 0, x_8);
+lean_ctor_set(x_11, 1, x_2);
+lean_ctor_set(x_11, 2, x_9);
+lean_ctor_set(x_11, 3, x_10);
+x_12 = l_Lean_Parser_categoryParserOfStackFn(x_1, x_11, x_4);
+return x_12;
+}
+}
+}
+lean_object* l_Lean_Parser_categoryParserOfStack(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParserOfStack___elambda__1___boxed), 4, 2);
+lean_closure_set(x_3, 0, x_1);
+lean_closure_set(x_3, 1, x_2);
+x_4 = l_Lean_Parser_Parser_inhabited___closed__1;
+x_5 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_5, 0, x_4);
+lean_ctor_set(x_5, 1, x_3);
 return x_5;
 }
 }
-lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; 
-x_6 = l_Lean_Parser_categoryParserOfStackFn(x_1, x_2, x_4, x_5);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParserOfStack___elambda__1___rarg___boxed), 5, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_categoryParserOfStack(uint8_t 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_alloc_closure((void*)(l_Lean_Parser_categoryParserOfStack___elambda__1___rarg___boxed), 5, 2);
-lean_closure_set(x_4, 0, x_2);
-lean_closure_set(x_4, 1, x_3);
-x_5 = l_Lean_Parser_Parser_inhabited___closed__1;
-x_6 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_6, 0, x_5);
-lean_ctor_set(x_6, 1, x_4);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_categoryParserOfStack___elambda__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_Parser_categoryParserOfStack___elambda__1___rarg(x_1, x_2, x_3, x_4, x_5);
-lean_dec(x_3);
+lean_object* x_5; 
+x_5 = l_Lean_Parser_categoryParserOfStack___elambda__1(x_1, x_2, x_3, x_4);
 lean_dec(x_1);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_categoryParserOfStack___elambda__1(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_categoryParserOfStack___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_Parser_categoryParserOfStack(x_4, x_2, x_3);
 return x_5;
 }
 }
@@ -30673,19 +29534,19 @@ return x_17;
 }
 }
 }
-lean_object* l_Lean_Parser_addParser(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_addParser(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5) {
 _start:
 {
-if (x_1 == 0)
+if (x_4 == 0)
 {
 lean_object* x_6; 
-x_6 = l_Lean_Parser_addLeadingParser(x_2, x_3, x_4, x_5);
+x_6 = l_Lean_Parser_addTrailingParser(x_1, x_2, x_5);
 return x_6;
 }
 else
 {
 lean_object* x_7; 
-x_7 = l_Lean_Parser_addTrailingParser(x_2, x_3, x_5);
+x_7 = l_Lean_Parser_addLeadingParser(x_1, x_2, x_3, x_5);
 return x_7;
 }
 }
@@ -30694,10 +29555,10 @@ lean_object* l_Lean_Parser_addParser___boxed(lean_object* x_1, lean_object* x_2,
 _start:
 {
 uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l_Lean_Parser_addParser(x_6, x_2, x_3, x_4, x_5);
+x_6 = lean_unbox(x_4);
 lean_dec(x_4);
+x_7 = l_Lean_Parser_addParser(x_1, x_2, x_3, x_6, x_5);
+lean_dec(x_3);
 return x_7;
 }
 }
@@ -30893,7 +29754,7 @@ return x_40;
 }
 }
 }
-lean_object* l_Lean_Parser_addBuiltinParser(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_addBuiltinParser(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 lean_object* x_6; lean_object* x_7; 
@@ -30908,7 +29769,7 @@ x_9 = lean_ctor_get(x_7, 1);
 lean_inc(x_9);
 lean_dec(x_7);
 lean_inc(x_4);
-x_10 = l_Lean_Parser_addParser(x_1, x_8, x_2, x_3, x_4);
+x_10 = l_Lean_Parser_addParser(x_8, x_1, x_2, x_3, x_4);
 x_11 = l_IO_ofExcept___at___private_Init_Lean_Parser_Parser_18__addBuiltinParserCategory___spec__1(x_10, x_9);
 lean_dec(x_10);
 if (lean_obj_tag(x_11) == 0)
@@ -30956,14 +29817,14 @@ lean_object* x_26; lean_object* x_27;
 x_26 = lean_ctor_get(x_25, 1);
 lean_inc(x_26);
 lean_dec(x_25);
-x_27 = l___private_Init_Lean_Parser_Parser_23__updateBuiltinTokens(x_16, x_3, x_26);
+x_27 = l___private_Init_Lean_Parser_Parser_23__updateBuiltinTokens(x_16, x_2, x_26);
 return x_27;
 }
 else
 {
 uint8_t x_28; 
 lean_dec(x_16);
-lean_dec(x_3);
+lean_dec(x_2);
 x_28 = !lean_is_exclusive(x_25);
 if (x_28 == 0)
 {
@@ -30990,7 +29851,7 @@ uint8_t x_32;
 lean_dec(x_20);
 lean_dec(x_17);
 lean_dec(x_16);
-lean_dec(x_3);
+lean_dec(x_2);
 x_32 = !lean_is_exclusive(x_22);
 if (x_32 == 0)
 {
@@ -31016,7 +29877,7 @@ else
 uint8_t x_36; 
 lean_dec(x_17);
 lean_dec(x_16);
-lean_dec(x_3);
+lean_dec(x_2);
 x_36 = !lean_is_exclusive(x_19);
 if (x_36 == 0)
 {
@@ -31041,7 +29902,7 @@ else
 {
 uint8_t x_40; 
 lean_dec(x_4);
-lean_dec(x_3);
+lean_dec(x_2);
 x_40 = !lean_is_exclusive(x_14);
 if (x_40 == 0)
 {
@@ -31066,7 +29927,7 @@ else
 {
 uint8_t x_44; 
 lean_dec(x_4);
-lean_dec(x_3);
+lean_dec(x_2);
 x_44 = !lean_is_exclusive(x_11);
 if (x_44 == 0)
 {
@@ -31091,8 +29952,8 @@ else
 {
 uint8_t x_48; 
 lean_dec(x_4);
-lean_dec(x_3);
 lean_dec(x_2);
+lean_dec(x_1);
 x_48 = !lean_is_exclusive(x_7);
 if (x_48 == 0)
 {
@@ -31118,9 +29979,9 @@ lean_object* l_Lean_Parser_addBuiltinParser___boxed(lean_object* x_1, lean_objec
 _start:
 {
 uint8_t x_6; lean_object* x_7; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = l_Lean_Parser_addBuiltinParser(x_6, x_2, x_3, x_4, x_5);
+x_6 = lean_unbox(x_3);
+lean_dec(x_3);
+x_7 = l_Lean_Parser_addBuiltinParser(x_1, x_2, x_6, x_4, x_5);
 return x_7;
 }
 }
@@ -31128,8 +29989,8 @@ lean_object* l_Lean_Parser_addBuiltinLeadingParser(lean_object* x_1, lean_object
 _start:
 {
 uint8_t x_5; lean_object* x_6; 
-x_5 = 0;
-x_6 = l_Lean_Parser_addBuiltinParser(x_5, x_1, x_2, x_3, x_4);
+x_5 = 1;
+x_6 = l_Lean_Parser_addBuiltinParser(x_1, x_2, x_5, x_3, x_4);
 return x_6;
 }
 }
@@ -31137,8 +29998,8 @@ lean_object* l_Lean_Parser_addBuiltinTrailingParser(lean_object* x_1, lean_objec
 _start:
 {
 uint8_t x_5; lean_object* x_6; 
-x_5 = 1;
-x_6 = l_Lean_Parser_addBuiltinParser(x_5, x_1, x_2, x_3, x_4);
+x_5 = 0;
+x_6 = l_Lean_Parser_addBuiltinParser(x_1, x_2, x_5, x_3, x_4);
 return x_6;
 }
 }
@@ -31391,7 +30252,7 @@ x_72 = lean_ctor_get(x_1, 1);
 x_73 = lean_ctor_get(x_1, 2);
 x_74 = lean_ctor_get(x_1, 3);
 lean_inc(x_66);
-x_75 = l_Lean_Parser_addParser(x_68, x_73, x_66, x_67, x_69);
+x_75 = l_Lean_Parser_addParser(x_73, x_66, x_67, x_68, x_69);
 if (lean_obj_tag(x_75) == 0)
 {
 lean_object* x_76; lean_object* x_77; 
@@ -31436,7 +30297,7 @@ lean_inc(x_82);
 lean_inc(x_81);
 lean_dec(x_1);
 lean_inc(x_66);
-x_85 = l_Lean_Parser_addParser(x_68, x_83, x_66, x_67, x_69);
+x_85 = l_Lean_Parser_addParser(x_83, x_66, x_67, x_68, x_69);
 if (lean_obj_tag(x_85) == 0)
 {
 lean_object* x_86; lean_object* x_87; 
@@ -31474,2374 +30335,1242 @@ return x_91;
 }
 }
 }
-lean_object* l_Lean_Parser_compileParserDescr___main(lean_object* x_1, uint8_t x_2, lean_object* x_3) {
+lean_object* _init_l_Lean_Parser_compileParserDescr___main___closed__1() {
 _start:
 {
-if (x_2 == 0)
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Parser_numLit;
+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_compileParserDescr___main___closed__2() {
+_start:
 {
-switch (lean_obj_tag(x_3)) {
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Parser_strLit;
+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_compileParserDescr___main___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Parser_charLit;
+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_compileParserDescr___main___closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Parser_nameLit;
+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_compileParserDescr___main___closed__5() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Parser_ident;
+x_2 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* l_Lean_Parser_compileParserDescr___main(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+switch (lean_obj_tag(x_2)) {
 case 0:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_4 = lean_ctor_get(x_3, 0);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_ctor_get(x_2, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_2, 1);
 lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 1);
-lean_inc(x_5);
-lean_dec(x_3);
+lean_dec(x_2);
 lean_inc(x_1);
-x_6 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_4);
-if (lean_obj_tag(x_6) == 0)
+x_5 = l_Lean_Parser_compileParserDescr___main(x_1, x_3);
+if (lean_obj_tag(x_5) == 0)
 {
-uint8_t x_7; 
-lean_dec(x_5);
+uint8_t x_6; 
+lean_dec(x_4);
 lean_dec(x_1);
-x_7 = !lean_is_exclusive(x_6);
-if (x_7 == 0)
+x_6 = !lean_is_exclusive(x_5);
+if (x_6 == 0)
 {
-return x_6;
+return x_5;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; 
-x_8 = lean_ctor_get(x_6, 0);
-lean_inc(x_8);
-lean_dec(x_6);
-x_9 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_9, 0, x_8);
-return x_9;
+lean_object* x_7; lean_object* x_8; 
+x_7 = lean_ctor_get(x_5, 0);
+lean_inc(x_7);
+lean_dec(x_5);
+x_8 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_8, 0, x_7);
+return x_8;
 }
 }
 else
 {
-lean_object* x_10; lean_object* x_11; 
-x_10 = lean_ctor_get(x_6, 0);
-lean_inc(x_10);
-lean_dec(x_6);
-x_11 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_5);
-if (lean_obj_tag(x_11) == 0)
+lean_object* x_9; lean_object* x_10; 
+x_9 = lean_ctor_get(x_5, 0);
+lean_inc(x_9);
+lean_dec(x_5);
+x_10 = l_Lean_Parser_compileParserDescr___main(x_1, x_4);
+if (lean_obj_tag(x_10) == 0)
 {
-uint8_t x_12; 
+uint8_t x_11; 
+lean_dec(x_9);
+x_11 = !lean_is_exclusive(x_10);
+if (x_11 == 0)
+{
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; 
+x_12 = lean_ctor_get(x_10, 0);
+lean_inc(x_12);
 lean_dec(x_10);
-x_12 = !lean_is_exclusive(x_11);
-if (x_12 == 0)
-{
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_11, 0);
-lean_inc(x_13);
-lean_dec(x_11);
-x_14 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_14, 0, x_13);
-return x_14;
+x_13 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_13, 0, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_15; 
-x_15 = !lean_is_exclusive(x_11);
-if (x_15 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_10);
+if (x_14 == 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; lean_object* x_22; lean_object* x_23; 
-x_16 = lean_ctor_get(x_11, 0);
-x_17 = lean_ctor_get(x_10, 0);
+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; 
+x_15 = lean_ctor_get(x_10, 0);
+x_16 = lean_ctor_get(x_9, 0);
+lean_inc(x_16);
+x_17 = lean_ctor_get(x_15, 0);
 lean_inc(x_17);
-x_18 = lean_ctor_get(x_16, 0);
-lean_inc(x_18);
-x_19 = l_Lean_Parser_andthenInfo(x_17, x_18);
-x_20 = lean_ctor_get(x_10, 1);
+x_18 = l_Lean_Parser_andthenInfo(x_16, x_17);
+x_19 = lean_ctor_get(x_9, 1);
+lean_inc(x_19);
+lean_dec(x_9);
+x_20 = lean_ctor_get(x_15, 1);
 lean_inc(x_20);
-lean_dec(x_10);
-x_21 = lean_ctor_get(x_16, 1);
-lean_inc(x_21);
-lean_dec(x_16);
-x_22 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_22, 0, x_20);
-lean_closure_set(x_22, 1, x_21);
-x_23 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_23, 0, x_19);
-lean_ctor_set(x_23, 1, x_22);
-lean_ctor_set(x_11, 0, x_23);
-return x_11;
+lean_dec(x_15);
+x_21 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_21, 0, x_19);
+lean_closure_set(x_21, 1, x_20);
+x_22 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_22, 0, x_18);
+lean_ctor_set(x_22, 1, x_21);
+lean_ctor_set(x_10, 0, x_22);
+return x_10;
 }
 else
 {
-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; 
-x_24 = lean_ctor_get(x_11, 0);
-lean_inc(x_24);
-lean_dec(x_11);
-x_25 = lean_ctor_get(x_10, 0);
-lean_inc(x_25);
-x_26 = lean_ctor_get(x_24, 0);
-lean_inc(x_26);
-x_27 = l_Lean_Parser_andthenInfo(x_25, x_26);
-x_28 = lean_ctor_get(x_10, 1);
-lean_inc(x_28);
+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; 
+x_23 = lean_ctor_get(x_10, 0);
+lean_inc(x_23);
 lean_dec(x_10);
-x_29 = lean_ctor_get(x_24, 1);
-lean_inc(x_29);
-lean_dec(x_24);
-x_30 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_30, 0, x_28);
-lean_closure_set(x_30, 1, x_29);
-x_31 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_31, 0, x_27);
-lean_ctor_set(x_31, 1, x_30);
-x_32 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_32, 0, x_31);
-return x_32;
+x_24 = lean_ctor_get(x_9, 0);
+lean_inc(x_24);
+x_25 = lean_ctor_get(x_23, 0);
+lean_inc(x_25);
+x_26 = l_Lean_Parser_andthenInfo(x_24, x_25);
+x_27 = lean_ctor_get(x_9, 1);
+lean_inc(x_27);
+lean_dec(x_9);
+x_28 = lean_ctor_get(x_23, 1);
+lean_inc(x_28);
+lean_dec(x_23);
+x_29 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_29, 0, x_27);
+lean_closure_set(x_29, 1, x_28);
+x_30 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_30, 0, x_26);
+lean_ctor_set(x_30, 1, x_29);
+x_31 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_31, 0, x_30);
+return x_31;
 }
 }
 }
 }
 case 1:
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_33 = lean_ctor_get(x_3, 0);
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_32 = lean_ctor_get(x_2, 0);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_2, 1);
 lean_inc(x_33);
-x_34 = lean_ctor_get(x_3, 1);
-lean_inc(x_34);
-lean_dec(x_3);
+lean_dec(x_2);
 lean_inc(x_1);
-x_35 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_33);
-if (lean_obj_tag(x_35) == 0)
+x_34 = l_Lean_Parser_compileParserDescr___main(x_1, x_32);
+if (lean_obj_tag(x_34) == 0)
 {
-uint8_t x_36; 
-lean_dec(x_34);
+uint8_t x_35; 
+lean_dec(x_33);
 lean_dec(x_1);
-x_36 = !lean_is_exclusive(x_35);
-if (x_36 == 0)
+x_35 = !lean_is_exclusive(x_34);
+if (x_35 == 0)
 {
-return x_35;
+return x_34;
 }
 else
 {
-lean_object* x_37; lean_object* x_38; 
-x_37 = lean_ctor_get(x_35, 0);
-lean_inc(x_37);
-lean_dec(x_35);
-x_38 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_38, 0, x_37);
-return x_38;
+lean_object* x_36; lean_object* x_37; 
+x_36 = lean_ctor_get(x_34, 0);
+lean_inc(x_36);
+lean_dec(x_34);
+x_37 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_37, 0, x_36);
+return x_37;
 }
 }
 else
 {
-lean_object* x_39; lean_object* x_40; 
-x_39 = lean_ctor_get(x_35, 0);
-lean_inc(x_39);
-lean_dec(x_35);
-x_40 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_34);
-if (lean_obj_tag(x_40) == 0)
+lean_object* x_38; lean_object* x_39; 
+x_38 = lean_ctor_get(x_34, 0);
+lean_inc(x_38);
+lean_dec(x_34);
+x_39 = l_Lean_Parser_compileParserDescr___main(x_1, x_33);
+if (lean_obj_tag(x_39) == 0)
 {
-uint8_t x_41; 
+uint8_t x_40; 
+lean_dec(x_38);
+x_40 = !lean_is_exclusive(x_39);
+if (x_40 == 0)
+{
+return x_39;
+}
+else
+{
+lean_object* x_41; lean_object* x_42; 
+x_41 = lean_ctor_get(x_39, 0);
+lean_inc(x_41);
 lean_dec(x_39);
-x_41 = !lean_is_exclusive(x_40);
-if (x_41 == 0)
-{
-return x_40;
-}
-else
-{
-lean_object* x_42; lean_object* x_43; 
-x_42 = lean_ctor_get(x_40, 0);
-lean_inc(x_42);
-lean_dec(x_40);
-x_43 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_43, 0, x_42);
-return x_43;
+x_42 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_42, 0, x_41);
+return x_42;
 }
 }
 else
 {
-uint8_t x_44; 
-x_44 = !lean_is_exclusive(x_40);
-if (x_44 == 0)
+uint8_t x_43; 
+x_43 = !lean_is_exclusive(x_39);
+if (x_43 == 0)
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_45 = lean_ctor_get(x_40, 0);
-x_46 = lean_ctor_get(x_39, 0);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+x_44 = lean_ctor_get(x_39, 0);
+x_45 = lean_ctor_get(x_38, 0);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_44, 0);
 lean_inc(x_46);
-x_47 = lean_ctor_get(x_45, 0);
-lean_inc(x_47);
-x_48 = l_Lean_Parser_orelseInfo(x_46, x_47);
-x_49 = lean_ctor_get(x_39, 1);
+x_47 = l_Lean_Parser_orelseInfo(x_45, x_46);
+x_48 = lean_ctor_get(x_38, 1);
+lean_inc(x_48);
+lean_dec(x_38);
+x_49 = lean_ctor_get(x_44, 1);
 lean_inc(x_49);
-lean_dec(x_39);
-x_50 = lean_ctor_get(x_45, 1);
-lean_inc(x_50);
-lean_dec(x_45);
-x_51 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 2);
-lean_closure_set(x_51, 0, x_49);
-lean_closure_set(x_51, 1, x_50);
-x_52 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_52, 0, x_48);
-lean_ctor_set(x_52, 1, x_51);
-lean_ctor_set(x_40, 0, x_52);
-return x_40;
+lean_dec(x_44);
+x_50 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn), 4, 2);
+lean_closure_set(x_50, 0, x_48);
+lean_closure_set(x_50, 1, x_49);
+x_51 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_51, 0, x_47);
+lean_ctor_set(x_51, 1, x_50);
+lean_ctor_set(x_39, 0, x_51);
+return x_39;
 }
 else
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-x_53 = lean_ctor_get(x_40, 0);
-lean_inc(x_53);
-lean_dec(x_40);
-x_54 = lean_ctor_get(x_39, 0);
-lean_inc(x_54);
-x_55 = lean_ctor_get(x_53, 0);
-lean_inc(x_55);
-x_56 = l_Lean_Parser_orelseInfo(x_54, x_55);
-x_57 = lean_ctor_get(x_39, 1);
-lean_inc(x_57);
+lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_52 = lean_ctor_get(x_39, 0);
+lean_inc(x_52);
 lean_dec(x_39);
-x_58 = lean_ctor_get(x_53, 1);
-lean_inc(x_58);
-lean_dec(x_53);
-x_59 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 2);
-lean_closure_set(x_59, 0, x_57);
-lean_closure_set(x_59, 1, x_58);
-x_60 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_60, 0, x_56);
-lean_ctor_set(x_60, 1, x_59);
-x_61 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_61, 0, x_60);
-return x_61;
+x_53 = lean_ctor_get(x_38, 0);
+lean_inc(x_53);
+x_54 = lean_ctor_get(x_52, 0);
+lean_inc(x_54);
+x_55 = l_Lean_Parser_orelseInfo(x_53, x_54);
+x_56 = lean_ctor_get(x_38, 1);
+lean_inc(x_56);
+lean_dec(x_38);
+x_57 = lean_ctor_get(x_52, 1);
+lean_inc(x_57);
+lean_dec(x_52);
+x_58 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn), 4, 2);
+lean_closure_set(x_58, 0, x_56);
+lean_closure_set(x_58, 1, x_57);
+x_59 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_59, 0, x_55);
+lean_ctor_set(x_59, 1, x_58);
+x_60 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_60, 0, x_59);
+return x_60;
 }
 }
 }
 }
 case 2:
 {
-lean_object* x_62; lean_object* x_63; 
-x_62 = lean_ctor_get(x_3, 0);
-lean_inc(x_62);
-lean_dec(x_3);
-x_63 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_62);
-if (lean_obj_tag(x_63) == 0)
+lean_object* x_61; lean_object* x_62; 
+x_61 = lean_ctor_get(x_2, 0);
+lean_inc(x_61);
+lean_dec(x_2);
+x_62 = l_Lean_Parser_compileParserDescr___main(x_1, x_61);
+if (lean_obj_tag(x_62) == 0)
 {
-uint8_t x_64; 
-x_64 = !lean_is_exclusive(x_63);
-if (x_64 == 0)
+uint8_t x_63; 
+x_63 = !lean_is_exclusive(x_62);
+if (x_63 == 0)
 {
-return x_63;
+return x_62;
 }
 else
 {
-lean_object* x_65; lean_object* x_66; 
-x_65 = lean_ctor_get(x_63, 0);
-lean_inc(x_65);
-lean_dec(x_63);
-x_66 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_66, 0, x_65);
-return x_66;
+lean_object* x_64; lean_object* x_65; 
+x_64 = lean_ctor_get(x_62, 0);
+lean_inc(x_64);
+lean_dec(x_62);
+x_65 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_65, 0, x_64);
+return x_65;
 }
 }
 else
 {
-uint8_t x_67; 
-x_67 = !lean_is_exclusive(x_63);
-if (x_67 == 0)
+uint8_t x_66; 
+x_66 = !lean_is_exclusive(x_62);
+if (x_66 == 0)
 {
-lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-x_68 = lean_ctor_get(x_63, 0);
-x_69 = lean_ctor_get(x_68, 0);
-lean_inc(x_69);
-x_70 = l_Lean_Parser_optionaInfo(x_69);
-x_71 = lean_ctor_get(x_68, 1);
-lean_inc(x_71);
-lean_dec(x_68);
-x_72 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn___rarg), 4, 1);
-lean_closure_set(x_72, 0, x_71);
-x_73 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_73, 0, x_70);
-lean_ctor_set(x_73, 1, x_72);
-lean_ctor_set(x_63, 0, x_73);
-return x_63;
+lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_67 = lean_ctor_get(x_62, 0);
+x_68 = lean_ctor_get(x_67, 0);
+lean_inc(x_68);
+x_69 = l_Lean_Parser_optionaInfo(x_68);
+x_70 = lean_ctor_get(x_67, 1);
+lean_inc(x_70);
+lean_dec(x_67);
+x_71 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn), 3, 1);
+lean_closure_set(x_71, 0, x_70);
+x_72 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_72, 0, x_69);
+lean_ctor_set(x_72, 1, x_71);
+lean_ctor_set(x_62, 0, x_72);
+return x_62;
 }
 else
 {
-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; 
-x_74 = lean_ctor_get(x_63, 0);
+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; 
+x_73 = lean_ctor_get(x_62, 0);
+lean_inc(x_73);
+lean_dec(x_62);
+x_74 = lean_ctor_get(x_73, 0);
 lean_inc(x_74);
-lean_dec(x_63);
-x_75 = lean_ctor_get(x_74, 0);
-lean_inc(x_75);
-x_76 = l_Lean_Parser_optionaInfo(x_75);
-x_77 = lean_ctor_get(x_74, 1);
-lean_inc(x_77);
-lean_dec(x_74);
-x_78 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn___rarg), 4, 1);
-lean_closure_set(x_78, 0, x_77);
-x_79 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_79, 0, x_76);
-lean_ctor_set(x_79, 1, x_78);
-x_80 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_80, 0, x_79);
-return x_80;
+x_75 = l_Lean_Parser_optionaInfo(x_74);
+x_76 = lean_ctor_get(x_73, 1);
+lean_inc(x_76);
+lean_dec(x_73);
+x_77 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn), 3, 1);
+lean_closure_set(x_77, 0, x_76);
+x_78 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_78, 0, x_75);
+lean_ctor_set(x_78, 1, x_77);
+x_79 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_79, 0, x_78);
+return x_79;
 }
 }
 }
 case 3:
 {
-lean_object* x_81; lean_object* x_82; 
-x_81 = lean_ctor_get(x_3, 0);
-lean_inc(x_81);
-lean_dec(x_3);
-x_82 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_81);
-if (lean_obj_tag(x_82) == 0)
+lean_object* x_80; lean_object* x_81; 
+x_80 = lean_ctor_get(x_2, 0);
+lean_inc(x_80);
+lean_dec(x_2);
+x_81 = l_Lean_Parser_compileParserDescr___main(x_1, x_80);
+if (lean_obj_tag(x_81) == 0)
 {
-uint8_t x_83; 
-x_83 = !lean_is_exclusive(x_82);
-if (x_83 == 0)
+uint8_t x_82; 
+x_82 = !lean_is_exclusive(x_81);
+if (x_82 == 0)
 {
-return x_82;
+return x_81;
 }
 else
 {
-lean_object* x_84; lean_object* x_85; 
-x_84 = lean_ctor_get(x_82, 0);
-lean_inc(x_84);
-lean_dec(x_82);
-x_85 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_85, 0, x_84);
-return x_85;
+lean_object* x_83; lean_object* x_84; 
+x_83 = lean_ctor_get(x_81, 0);
+lean_inc(x_83);
+lean_dec(x_81);
+x_84 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_84, 0, x_83);
+return x_84;
 }
 }
 else
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_82);
-if (x_86 == 0)
+uint8_t x_85; 
+x_85 = !lean_is_exclusive(x_81);
+if (x_85 == 0)
 {
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_82, 0);
-x_88 = !lean_is_exclusive(x_87);
-if (x_88 == 0)
+lean_object* x_86; uint8_t x_87; 
+x_86 = lean_ctor_get(x_81, 0);
+x_87 = !lean_is_exclusive(x_86);
+if (x_87 == 0)
 {
-lean_object* x_89; lean_object* x_90; 
-x_89 = lean_ctor_get(x_87, 1);
-x_90 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn___rarg), 4, 1);
-lean_closure_set(x_90, 0, x_89);
-lean_ctor_set(x_87, 1, x_90);
-return x_82;
+lean_object* x_88; lean_object* x_89; 
+x_88 = lean_ctor_get(x_86, 1);
+x_89 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn), 3, 1);
+lean_closure_set(x_89, 0, x_88);
+lean_ctor_set(x_86, 1, x_89);
+return x_81;
 }
 else
 {
-lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; 
-x_91 = lean_ctor_get(x_87, 0);
-x_92 = lean_ctor_get(x_87, 1);
-lean_inc(x_92);
+lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; 
+x_90 = lean_ctor_get(x_86, 0);
+x_91 = lean_ctor_get(x_86, 1);
 lean_inc(x_91);
-lean_dec(x_87);
-x_93 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn___rarg), 4, 1);
-lean_closure_set(x_93, 0, x_92);
-x_94 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_94, 0, x_91);
-lean_ctor_set(x_94, 1, x_93);
-lean_ctor_set(x_82, 0, x_94);
-return x_82;
+lean_inc(x_90);
+lean_dec(x_86);
+x_92 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn), 3, 1);
+lean_closure_set(x_92, 0, x_91);
+x_93 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_93, 0, x_90);
+lean_ctor_set(x_93, 1, x_92);
+lean_ctor_set(x_81, 0, x_93);
+return x_81;
 }
 }
 else
 {
-lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; 
-x_95 = lean_ctor_get(x_82, 0);
+lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; 
+x_94 = lean_ctor_get(x_81, 0);
+lean_inc(x_94);
+lean_dec(x_81);
+x_95 = lean_ctor_get(x_94, 0);
 lean_inc(x_95);
-lean_dec(x_82);
-x_96 = lean_ctor_get(x_95, 0);
+x_96 = lean_ctor_get(x_94, 1);
 lean_inc(x_96);
-x_97 = lean_ctor_get(x_95, 1);
-lean_inc(x_97);
-if (lean_is_exclusive(x_95)) {
- lean_ctor_release(x_95, 0);
- lean_ctor_release(x_95, 1);
- x_98 = x_95;
+if (lean_is_exclusive(x_94)) {
+ lean_ctor_release(x_94, 0);
+ lean_ctor_release(x_94, 1);
+ x_97 = x_94;
 } else {
- lean_dec_ref(x_95);
- x_98 = lean_box(0);
+ lean_dec_ref(x_94);
+ x_97 = lean_box(0);
 }
-x_99 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn___rarg), 4, 1);
-lean_closure_set(x_99, 0, x_97);
-if (lean_is_scalar(x_98)) {
- x_100 = lean_alloc_ctor(0, 2, 0);
+x_98 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn), 3, 1);
+lean_closure_set(x_98, 0, x_96);
+if (lean_is_scalar(x_97)) {
+ x_99 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_100 = x_98;
+ x_99 = x_97;
 }
-lean_ctor_set(x_100, 0, x_96);
-lean_ctor_set(x_100, 1, x_99);
-x_101 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_101, 0, x_100);
-return x_101;
+lean_ctor_set(x_99, 0, x_95);
+lean_ctor_set(x_99, 1, x_98);
+x_100 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_100, 0, x_99);
+return x_100;
 }
 }
 }
 case 4:
 {
-lean_object* x_102; lean_object* x_103; 
-x_102 = lean_ctor_get(x_3, 0);
-lean_inc(x_102);
-lean_dec(x_3);
-x_103 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_102);
-if (lean_obj_tag(x_103) == 0)
+lean_object* x_101; lean_object* x_102; 
+x_101 = lean_ctor_get(x_2, 0);
+lean_inc(x_101);
+lean_dec(x_2);
+x_102 = l_Lean_Parser_compileParserDescr___main(x_1, x_101);
+if (lean_obj_tag(x_102) == 0)
 {
-uint8_t x_104; 
-x_104 = !lean_is_exclusive(x_103);
-if (x_104 == 0)
+uint8_t x_103; 
+x_103 = !lean_is_exclusive(x_102);
+if (x_103 == 0)
 {
-return x_103;
+return x_102;
 }
 else
 {
-lean_object* x_105; lean_object* x_106; 
-x_105 = lean_ctor_get(x_103, 0);
-lean_inc(x_105);
-lean_dec(x_103);
-x_106 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_106, 0, x_105);
-return x_106;
+lean_object* x_104; lean_object* x_105; 
+x_104 = lean_ctor_get(x_102, 0);
+lean_inc(x_104);
+lean_dec(x_102);
+x_105 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_105, 0, x_104);
+return x_105;
 }
 }
 else
 {
-uint8_t x_107; 
-x_107 = !lean_is_exclusive(x_103);
-if (x_107 == 0)
+uint8_t x_106; 
+x_106 = !lean_is_exclusive(x_102);
+if (x_106 == 0)
 {
-lean_object* x_108; uint8_t x_109; 
-x_108 = lean_ctor_get(x_103, 0);
-x_109 = !lean_is_exclusive(x_108);
-if (x_109 == 0)
+lean_object* x_107; uint8_t x_108; 
+x_107 = lean_ctor_get(x_102, 0);
+x_108 = !lean_is_exclusive(x_107);
+if (x_108 == 0)
 {
-lean_object* x_110; lean_object* x_111; 
-x_110 = lean_ctor_get(x_108, 1);
-x_111 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
-lean_closure_set(x_111, 0, x_110);
-lean_ctor_set(x_108, 1, x_111);
-return x_103;
+lean_object* x_109; lean_object* x_110; 
+x_109 = lean_ctor_get(x_107, 1);
+x_110 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn), 3, 1);
+lean_closure_set(x_110, 0, x_109);
+lean_ctor_set(x_107, 1, x_110);
+return x_102;
 }
 else
 {
-lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; 
-x_112 = lean_ctor_get(x_108, 0);
-x_113 = lean_ctor_get(x_108, 1);
-lean_inc(x_113);
+lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; 
+x_111 = lean_ctor_get(x_107, 0);
+x_112 = lean_ctor_get(x_107, 1);
 lean_inc(x_112);
-lean_dec(x_108);
-x_114 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
-lean_closure_set(x_114, 0, x_113);
-x_115 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_115, 0, x_112);
-lean_ctor_set(x_115, 1, x_114);
-lean_ctor_set(x_103, 0, x_115);
-return x_103;
+lean_inc(x_111);
+lean_dec(x_107);
+x_113 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn), 3, 1);
+lean_closure_set(x_113, 0, x_112);
+x_114 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_114, 0, x_111);
+lean_ctor_set(x_114, 1, x_113);
+lean_ctor_set(x_102, 0, x_114);
+return x_102;
 }
 }
 else
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; 
-x_116 = lean_ctor_get(x_103, 0);
+lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
+x_115 = lean_ctor_get(x_102, 0);
+lean_inc(x_115);
+lean_dec(x_102);
+x_116 = lean_ctor_get(x_115, 0);
 lean_inc(x_116);
-lean_dec(x_103);
-x_117 = lean_ctor_get(x_116, 0);
+x_117 = lean_ctor_get(x_115, 1);
 lean_inc(x_117);
-x_118 = lean_ctor_get(x_116, 1);
-lean_inc(x_118);
-if (lean_is_exclusive(x_116)) {
- lean_ctor_release(x_116, 0);
- lean_ctor_release(x_116, 1);
- x_119 = x_116;
+if (lean_is_exclusive(x_115)) {
+ lean_ctor_release(x_115, 0);
+ lean_ctor_release(x_115, 1);
+ x_118 = x_115;
 } else {
- lean_dec_ref(x_116);
- x_119 = lean_box(0);
+ lean_dec_ref(x_115);
+ x_118 = lean_box(0);
 }
-x_120 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
-lean_closure_set(x_120, 0, x_118);
-if (lean_is_scalar(x_119)) {
- x_121 = lean_alloc_ctor(0, 2, 0);
+x_119 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn), 3, 1);
+lean_closure_set(x_119, 0, x_117);
+if (lean_is_scalar(x_118)) {
+ x_120 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_121 = x_119;
+ x_120 = x_118;
 }
-lean_ctor_set(x_121, 0, x_117);
-lean_ctor_set(x_121, 1, x_120);
-x_122 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_122, 0, x_121);
-return x_122;
+lean_ctor_set(x_120, 0, x_116);
+lean_ctor_set(x_120, 1, x_119);
+x_121 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_121, 0, x_120);
+return x_121;
 }
 }
 }
 case 5:
 {
-lean_object* x_123; lean_object* x_124; 
-x_123 = lean_ctor_get(x_3, 0);
-lean_inc(x_123);
-lean_dec(x_3);
-x_124 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_123);
-if (lean_obj_tag(x_124) == 0)
+lean_object* x_122; lean_object* x_123; 
+x_122 = lean_ctor_get(x_2, 0);
+lean_inc(x_122);
+lean_dec(x_2);
+x_123 = l_Lean_Parser_compileParserDescr___main(x_1, x_122);
+if (lean_obj_tag(x_123) == 0)
 {
-uint8_t x_125; 
-x_125 = !lean_is_exclusive(x_124);
-if (x_125 == 0)
+uint8_t x_124; 
+x_124 = !lean_is_exclusive(x_123);
+if (x_124 == 0)
 {
-return x_124;
+return x_123;
 }
 else
 {
-lean_object* x_126; lean_object* x_127; 
-x_126 = lean_ctor_get(x_124, 0);
-lean_inc(x_126);
-lean_dec(x_124);
-x_127 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_127, 0, x_126);
-return x_127;
+lean_object* x_125; lean_object* x_126; 
+x_125 = lean_ctor_get(x_123, 0);
+lean_inc(x_125);
+lean_dec(x_123);
+x_126 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_126, 0, x_125);
+return x_126;
 }
 }
 else
 {
-uint8_t x_128; 
-x_128 = !lean_is_exclusive(x_124);
-if (x_128 == 0)
+uint8_t x_127; 
+x_127 = !lean_is_exclusive(x_123);
+if (x_127 == 0)
 {
-lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; 
-x_129 = lean_ctor_get(x_124, 0);
-x_130 = lean_ctor_get(x_129, 0);
-lean_inc(x_130);
-x_131 = l_Lean_Parser_noFirstTokenInfo(x_130);
-x_132 = lean_ctor_get(x_129, 1);
-lean_inc(x_132);
-lean_dec(x_129);
-x_133 = lean_box(x_2);
-x_134 = lean_alloc_closure((void*)(l_Lean_Parser_manyFn___boxed), 5, 2);
-lean_closure_set(x_134, 0, x_133);
-lean_closure_set(x_134, 1, x_132);
-x_135 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_135, 0, x_131);
-lean_ctor_set(x_135, 1, x_134);
-lean_ctor_set(x_124, 0, x_135);
-return x_124;
+lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
+x_128 = lean_ctor_get(x_123, 0);
+x_129 = lean_ctor_get(x_128, 0);
+lean_inc(x_129);
+x_130 = l_Lean_Parser_noFirstTokenInfo(x_129);
+x_131 = lean_ctor_get(x_128, 1);
+lean_inc(x_131);
+lean_dec(x_128);
+x_132 = lean_alloc_closure((void*)(l_Lean_Parser_manyFn), 3, 1);
+lean_closure_set(x_132, 0, x_131);
+x_133 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_133, 0, x_130);
+lean_ctor_set(x_133, 1, x_132);
+lean_ctor_set(x_123, 0, x_133);
+return x_123;
 }
 else
 {
-lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-x_136 = lean_ctor_get(x_124, 0);
-lean_inc(x_136);
-lean_dec(x_124);
-x_137 = lean_ctor_get(x_136, 0);
+lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
+x_134 = lean_ctor_get(x_123, 0);
+lean_inc(x_134);
+lean_dec(x_123);
+x_135 = lean_ctor_get(x_134, 0);
+lean_inc(x_135);
+x_136 = l_Lean_Parser_noFirstTokenInfo(x_135);
+x_137 = lean_ctor_get(x_134, 1);
 lean_inc(x_137);
-x_138 = l_Lean_Parser_noFirstTokenInfo(x_137);
-x_139 = lean_ctor_get(x_136, 1);
-lean_inc(x_139);
-lean_dec(x_136);
-x_140 = lean_box(x_2);
-x_141 = lean_alloc_closure((void*)(l_Lean_Parser_manyFn___boxed), 5, 2);
-lean_closure_set(x_141, 0, x_140);
-lean_closure_set(x_141, 1, x_139);
-x_142 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_142, 0, x_138);
-lean_ctor_set(x_142, 1, x_141);
-x_143 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_143, 0, x_142);
-return x_143;
+lean_dec(x_134);
+x_138 = lean_alloc_closure((void*)(l_Lean_Parser_manyFn), 3, 1);
+lean_closure_set(x_138, 0, x_137);
+x_139 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_139, 0, x_136);
+lean_ctor_set(x_139, 1, x_138);
+x_140 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_140, 0, x_139);
+return x_140;
 }
 }
 }
 case 6:
 {
+lean_object* x_141; lean_object* x_142; 
+x_141 = lean_ctor_get(x_2, 0);
+lean_inc(x_141);
+lean_dec(x_2);
+x_142 = l_Lean_Parser_compileParserDescr___main(x_1, x_141);
+if (lean_obj_tag(x_142) == 0)
+{
+uint8_t x_143; 
+x_143 = !lean_is_exclusive(x_142);
+if (x_143 == 0)
+{
+return x_142;
+}
+else
+{
 lean_object* x_144; lean_object* x_145; 
-x_144 = lean_ctor_get(x_3, 0);
+x_144 = lean_ctor_get(x_142, 0);
 lean_inc(x_144);
-lean_dec(x_3);
-x_145 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_144);
-if (lean_obj_tag(x_145) == 0)
+lean_dec(x_142);
+x_145 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_145, 0, x_144);
+return x_145;
+}
+}
+else
 {
 uint8_t x_146; 
-x_146 = !lean_is_exclusive(x_145);
+x_146 = !lean_is_exclusive(x_142);
 if (x_146 == 0)
 {
-return x_145;
+lean_object* x_147; uint8_t x_148; 
+x_147 = lean_ctor_get(x_142, 0);
+x_148 = !lean_is_exclusive(x_147);
+if (x_148 == 0)
+{
+lean_object* x_149; uint8_t x_150; lean_object* x_151; lean_object* x_152; 
+x_149 = lean_ctor_get(x_147, 1);
+x_150 = 0;
+x_151 = lean_box(x_150);
+x_152 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 4, 2);
+lean_closure_set(x_152, 0, x_149);
+lean_closure_set(x_152, 1, x_151);
+lean_ctor_set(x_147, 1, x_152);
+return x_142;
 }
 else
 {
-lean_object* x_147; lean_object* x_148; 
-x_147 = lean_ctor_get(x_145, 0);
-lean_inc(x_147);
-lean_dec(x_145);
-x_148 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_148, 0, x_147);
-return x_148;
+lean_object* x_153; lean_object* x_154; uint8_t x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; 
+x_153 = lean_ctor_get(x_147, 0);
+x_154 = lean_ctor_get(x_147, 1);
+lean_inc(x_154);
+lean_inc(x_153);
+lean_dec(x_147);
+x_155 = 0;
+x_156 = lean_box(x_155);
+x_157 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 4, 2);
+lean_closure_set(x_157, 0, x_154);
+lean_closure_set(x_157, 1, x_156);
+x_158 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_158, 0, x_153);
+lean_ctor_set(x_158, 1, x_157);
+lean_ctor_set(x_142, 0, x_158);
+return x_142;
 }
 }
 else
 {
-uint8_t x_149; 
-x_149 = !lean_is_exclusive(x_145);
-if (x_149 == 0)
-{
-lean_object* x_150; uint8_t x_151; 
-x_150 = lean_ctor_get(x_145, 0);
-x_151 = !lean_is_exclusive(x_150);
-if (x_151 == 0)
-{
-lean_object* x_152; uint8_t x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; 
-x_152 = lean_ctor_get(x_150, 1);
-x_153 = 0;
-x_154 = lean_box(x_2);
-x_155 = lean_box(x_153);
-x_156 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 6, 3);
-lean_closure_set(x_156, 0, x_154);
-lean_closure_set(x_156, 1, x_152);
-lean_closure_set(x_156, 2, x_155);
-lean_ctor_set(x_150, 1, x_156);
-return x_145;
-}
-else
-{
-lean_object* x_157; lean_object* x_158; uint8_t x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; 
-x_157 = lean_ctor_get(x_150, 0);
-x_158 = lean_ctor_get(x_150, 1);
-lean_inc(x_158);
-lean_inc(x_157);
-lean_dec(x_150);
-x_159 = 0;
-x_160 = lean_box(x_2);
-x_161 = lean_box(x_159);
-x_162 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 6, 3);
-lean_closure_set(x_162, 0, x_160);
-lean_closure_set(x_162, 1, x_158);
-lean_closure_set(x_162, 2, x_161);
-x_163 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_163, 0, x_157);
-lean_ctor_set(x_163, 1, x_162);
-lean_ctor_set(x_145, 0, x_163);
-return x_145;
-}
-}
-else
-{
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; uint8_t x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_145, 0);
-lean_inc(x_164);
-lean_dec(x_145);
-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;
+lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; 
+x_159 = lean_ctor_get(x_142, 0);
+lean_inc(x_159);
+lean_dec(x_142);
+x_160 = lean_ctor_get(x_159, 0);
+lean_inc(x_160);
+x_161 = lean_ctor_get(x_159, 1);
+lean_inc(x_161);
+if (lean_is_exclusive(x_159)) {
+ lean_ctor_release(x_159, 0);
+ lean_ctor_release(x_159, 1);
+ x_162 = x_159;
 } else {
- lean_dec_ref(x_164);
- x_167 = lean_box(0);
+ lean_dec_ref(x_159);
+ x_162 = lean_box(0);
 }
-x_168 = 0;
-x_169 = lean_box(x_2);
-x_170 = lean_box(x_168);
-x_171 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 6, 3);
-lean_closure_set(x_171, 0, x_169);
-lean_closure_set(x_171, 1, x_166);
-lean_closure_set(x_171, 2, x_170);
-if (lean_is_scalar(x_167)) {
- x_172 = lean_alloc_ctor(0, 2, 0);
+x_163 = 0;
+x_164 = lean_box(x_163);
+x_165 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 4, 2);
+lean_closure_set(x_165, 0, x_161);
+lean_closure_set(x_165, 1, x_164);
+if (lean_is_scalar(x_162)) {
+ x_166 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_172 = x_167;
+ x_166 = x_162;
 }
-lean_ctor_set(x_172, 0, x_165);
-lean_ctor_set(x_172, 1, x_171);
-x_173 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_166, 0, x_160);
+lean_ctor_set(x_166, 1, x_165);
+x_167 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_167, 0, x_166);
+return x_167;
+}
+}
+}
+case 7:
+{
+lean_object* x_168; lean_object* x_169; lean_object* x_170; 
+x_168 = lean_ctor_get(x_2, 0);
+lean_inc(x_168);
+x_169 = lean_ctor_get(x_2, 1);
+lean_inc(x_169);
+lean_dec(x_2);
+lean_inc(x_1);
+x_170 = l_Lean_Parser_compileParserDescr___main(x_1, x_168);
+if (lean_obj_tag(x_170) == 0)
+{
+uint8_t x_171; 
+lean_dec(x_169);
+lean_dec(x_1);
+x_171 = !lean_is_exclusive(x_170);
+if (x_171 == 0)
+{
+return x_170;
+}
+else
+{
+lean_object* x_172; lean_object* x_173; 
+x_172 = lean_ctor_get(x_170, 0);
+lean_inc(x_172);
+lean_dec(x_170);
+x_173 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_173, 0, x_172);
 return x_173;
 }
 }
-}
-case 7:
+else
 {
-lean_object* x_174; lean_object* x_175; lean_object* x_176; 
-x_174 = lean_ctor_get(x_3, 0);
+lean_object* x_174; lean_object* x_175; 
+x_174 = lean_ctor_get(x_170, 0);
 lean_inc(x_174);
-x_175 = lean_ctor_get(x_3, 1);
-lean_inc(x_175);
-lean_dec(x_3);
-lean_inc(x_1);
-x_176 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_174);
-if (lean_obj_tag(x_176) == 0)
+lean_dec(x_170);
+x_175 = l_Lean_Parser_compileParserDescr___main(x_1, x_169);
+if (lean_obj_tag(x_175) == 0)
 {
-uint8_t x_177; 
+uint8_t x_176; 
+lean_dec(x_174);
+x_176 = !lean_is_exclusive(x_175);
+if (x_176 == 0)
+{
+return x_175;
+}
+else
+{
+lean_object* x_177; lean_object* x_178; 
+x_177 = lean_ctor_get(x_175, 0);
+lean_inc(x_177);
 lean_dec(x_175);
-lean_dec(x_1);
-x_177 = !lean_is_exclusive(x_176);
-if (x_177 == 0)
-{
-return x_176;
-}
-else
-{
-lean_object* x_178; lean_object* x_179; 
-x_178 = lean_ctor_get(x_176, 0);
-lean_inc(x_178);
-lean_dec(x_176);
-x_179 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_179, 0, x_178);
-return x_179;
+x_178 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_178, 0, x_177);
+return x_178;
 }
 }
 else
 {
-lean_object* x_180; lean_object* x_181; 
-x_180 = lean_ctor_get(x_176, 0);
-lean_inc(x_180);
-lean_dec(x_176);
-x_181 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_175);
-if (lean_obj_tag(x_181) == 0)
+uint8_t x_179; 
+x_179 = !lean_is_exclusive(x_175);
+if (x_179 == 0)
 {
-uint8_t x_182; 
+lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; 
+x_180 = lean_ctor_get(x_175, 0);
+x_181 = lean_ctor_get(x_174, 0);
+lean_inc(x_181);
+x_182 = lean_ctor_get(x_180, 0);
+lean_inc(x_182);
+x_183 = l_Lean_Parser_sepByInfo(x_181, x_182);
+x_184 = lean_ctor_get(x_174, 1);
+lean_inc(x_184);
+lean_dec(x_174);
+x_185 = lean_ctor_get(x_180, 1);
+lean_inc(x_185);
 lean_dec(x_180);
-x_182 = !lean_is_exclusive(x_181);
-if (x_182 == 0)
-{
-return x_181;
+x_186 = 0;
+x_187 = lean_box(x_186);
+x_188 = lean_alloc_closure((void*)(l_Lean_Parser_sepByFn___boxed), 5, 3);
+lean_closure_set(x_188, 0, x_187);
+lean_closure_set(x_188, 1, x_184);
+lean_closure_set(x_188, 2, x_185);
+x_189 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_189, 0, x_183);
+lean_ctor_set(x_189, 1, x_188);
+lean_ctor_set(x_175, 0, x_189);
+return x_175;
 }
 else
 {
-lean_object* x_183; lean_object* x_184; 
-x_183 = lean_ctor_get(x_181, 0);
-lean_inc(x_183);
-lean_dec(x_181);
-x_184 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_184, 0, x_183);
-return x_184;
-}
-}
-else
-{
-uint8_t x_185; 
-x_185 = !lean_is_exclusive(x_181);
-if (x_185 == 0)
-{
-lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; uint8_t x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; 
-x_186 = lean_ctor_get(x_181, 0);
-x_187 = lean_ctor_get(x_180, 0);
-lean_inc(x_187);
-x_188 = lean_ctor_get(x_186, 0);
-lean_inc(x_188);
-x_189 = l_Lean_Parser_sepByInfo(x_187, x_188);
-x_190 = lean_ctor_get(x_180, 1);
+lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; uint8_t x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; 
+x_190 = lean_ctor_get(x_175, 0);
 lean_inc(x_190);
-lean_dec(x_180);
-x_191 = lean_ctor_get(x_186, 1);
+lean_dec(x_175);
+x_191 = lean_ctor_get(x_174, 0);
 lean_inc(x_191);
-lean_dec(x_186);
-x_192 = 0;
-x_193 = lean_box(x_2);
-x_194 = lean_box(x_192);
-x_195 = lean_alloc_closure((void*)(l_Lean_Parser_sepByFn___boxed), 7, 4);
-lean_closure_set(x_195, 0, x_193);
-lean_closure_set(x_195, 1, x_194);
-lean_closure_set(x_195, 2, x_190);
-lean_closure_set(x_195, 3, x_191);
-x_196 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_196, 0, x_189);
-lean_ctor_set(x_196, 1, x_195);
-lean_ctor_set(x_181, 0, x_196);
-return x_181;
+x_192 = lean_ctor_get(x_190, 0);
+lean_inc(x_192);
+x_193 = l_Lean_Parser_sepByInfo(x_191, x_192);
+x_194 = lean_ctor_get(x_174, 1);
+lean_inc(x_194);
+lean_dec(x_174);
+x_195 = lean_ctor_get(x_190, 1);
+lean_inc(x_195);
+lean_dec(x_190);
+x_196 = 0;
+x_197 = lean_box(x_196);
+x_198 = lean_alloc_closure((void*)(l_Lean_Parser_sepByFn___boxed), 5, 3);
+lean_closure_set(x_198, 0, x_197);
+lean_closure_set(x_198, 1, x_194);
+lean_closure_set(x_198, 2, x_195);
+x_199 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_199, 0, x_193);
+lean_ctor_set(x_199, 1, x_198);
+x_200 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_200, 0, x_199);
+return x_200;
+}
+}
+}
+}
+case 8:
+{
+lean_object* x_201; lean_object* x_202; lean_object* x_203; 
+x_201 = lean_ctor_get(x_2, 0);
+lean_inc(x_201);
+x_202 = lean_ctor_get(x_2, 1);
+lean_inc(x_202);
+lean_dec(x_2);
+lean_inc(x_1);
+x_203 = l_Lean_Parser_compileParserDescr___main(x_1, x_201);
+if (lean_obj_tag(x_203) == 0)
+{
+uint8_t x_204; 
+lean_dec(x_202);
+lean_dec(x_1);
+x_204 = !lean_is_exclusive(x_203);
+if (x_204 == 0)
+{
+return x_203;
 }
 else
 {
-lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; uint8_t x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; 
-x_197 = lean_ctor_get(x_181, 0);
-lean_inc(x_197);
-lean_dec(x_181);
-x_198 = lean_ctor_get(x_180, 0);
-lean_inc(x_198);
-x_199 = lean_ctor_get(x_197, 0);
-lean_inc(x_199);
-x_200 = l_Lean_Parser_sepByInfo(x_198, x_199);
-x_201 = lean_ctor_get(x_180, 1);
-lean_inc(x_201);
-lean_dec(x_180);
-x_202 = lean_ctor_get(x_197, 1);
-lean_inc(x_202);
-lean_dec(x_197);
-x_203 = 0;
-x_204 = lean_box(x_2);
-x_205 = lean_box(x_203);
-x_206 = lean_alloc_closure((void*)(l_Lean_Parser_sepByFn___boxed), 7, 4);
-lean_closure_set(x_206, 0, x_204);
-lean_closure_set(x_206, 1, x_205);
-lean_closure_set(x_206, 2, x_201);
-lean_closure_set(x_206, 3, x_202);
-x_207 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_207, 0, x_200);
-lean_ctor_set(x_207, 1, x_206);
-x_208 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_208, 0, x_207);
+lean_object* x_205; lean_object* x_206; 
+x_205 = lean_ctor_get(x_203, 0);
+lean_inc(x_205);
+lean_dec(x_203);
+x_206 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_206, 0, x_205);
+return x_206;
+}
+}
+else
+{
+lean_object* x_207; lean_object* x_208; 
+x_207 = lean_ctor_get(x_203, 0);
+lean_inc(x_207);
+lean_dec(x_203);
+x_208 = l_Lean_Parser_compileParserDescr___main(x_1, x_202);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+lean_dec(x_207);
+x_209 = !lean_is_exclusive(x_208);
+if (x_209 == 0)
+{
 return x_208;
 }
-}
-}
-}
-case 8:
+else
 {
-lean_object* x_209; lean_object* x_210; lean_object* x_211; 
-x_209 = lean_ctor_get(x_3, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_3, 1);
+lean_object* x_210; lean_object* x_211; 
+x_210 = lean_ctor_get(x_208, 0);
 lean_inc(x_210);
-lean_dec(x_3);
-lean_inc(x_1);
-x_211 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_209);
-if (lean_obj_tag(x_211) == 0)
-{
-uint8_t x_212; 
-lean_dec(x_210);
-lean_dec(x_1);
-x_212 = !lean_is_exclusive(x_211);
-if (x_212 == 0)
-{
+lean_dec(x_208);
+x_211 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_211, 0, x_210);
 return x_211;
 }
-else
-{
-lean_object* x_213; lean_object* x_214; 
-x_213 = lean_ctor_get(x_211, 0);
-lean_inc(x_213);
-lean_dec(x_211);
-x_214 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_214, 0, x_213);
-return x_214;
-}
 }
 else
 {
-lean_object* x_215; lean_object* x_216; 
-x_215 = lean_ctor_get(x_211, 0);
+uint8_t x_212; 
+x_212 = !lean_is_exclusive(x_208);
+if (x_212 == 0)
+{
+lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; uint8_t x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; 
+x_213 = lean_ctor_get(x_208, 0);
+x_214 = lean_ctor_get(x_207, 0);
+lean_inc(x_214);
+x_215 = lean_ctor_get(x_213, 0);
 lean_inc(x_215);
-lean_dec(x_211);
-x_216 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_210);
-if (lean_obj_tag(x_216) == 0)
-{
-uint8_t x_217; 
-lean_dec(x_215);
-x_217 = !lean_is_exclusive(x_216);
-if (x_217 == 0)
-{
-return x_216;
-}
-else
-{
-lean_object* x_218; lean_object* x_219; 
-x_218 = lean_ctor_get(x_216, 0);
+x_216 = l_Lean_Parser_sepBy1Info(x_214, x_215);
+x_217 = lean_ctor_get(x_207, 1);
+lean_inc(x_217);
+lean_dec(x_207);
+x_218 = lean_ctor_get(x_213, 1);
 lean_inc(x_218);
-lean_dec(x_216);
-x_219 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_219, 0, x_218);
-return x_219;
-}
+lean_dec(x_213);
+x_219 = 0;
+x_220 = lean_box(x_219);
+x_221 = lean_box(x_219);
+x_222 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___boxed), 6, 4);
+lean_closure_set(x_222, 0, x_220);
+lean_closure_set(x_222, 1, x_217);
+lean_closure_set(x_222, 2, x_218);
+lean_closure_set(x_222, 3, x_221);
+x_223 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_223, 0, x_216);
+lean_ctor_set(x_223, 1, x_222);
+lean_ctor_set(x_208, 0, x_223);
+return x_208;
 }
 else
 {
-uint8_t x_220; 
-x_220 = !lean_is_exclusive(x_216);
-if (x_220 == 0)
-{
-lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; uint8_t x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; 
-x_221 = lean_ctor_get(x_216, 0);
-x_222 = lean_ctor_get(x_215, 0);
-lean_inc(x_222);
-x_223 = lean_ctor_get(x_221, 0);
-lean_inc(x_223);
-x_224 = l_Lean_Parser_sepBy1Info(x_222, x_223);
-x_225 = lean_ctor_get(x_215, 1);
+lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; 
+x_224 = lean_ctor_get(x_208, 0);
+lean_inc(x_224);
+lean_dec(x_208);
+x_225 = lean_ctor_get(x_207, 0);
 lean_inc(x_225);
-lean_dec(x_215);
-x_226 = lean_ctor_get(x_221, 1);
+x_226 = lean_ctor_get(x_224, 0);
 lean_inc(x_226);
-lean_dec(x_221);
-x_227 = 0;
-x_228 = lean_box(x_2);
-x_229 = lean_box(x_227);
-x_230 = lean_box(x_227);
-x_231 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___boxed), 8, 5);
-lean_closure_set(x_231, 0, x_228);
-lean_closure_set(x_231, 1, x_229);
-lean_closure_set(x_231, 2, x_225);
-lean_closure_set(x_231, 3, x_226);
-lean_closure_set(x_231, 4, x_230);
-x_232 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_232, 0, x_224);
-lean_ctor_set(x_232, 1, x_231);
-lean_ctor_set(x_216, 0, x_232);
-return x_216;
+x_227 = l_Lean_Parser_sepBy1Info(x_225, x_226);
+x_228 = lean_ctor_get(x_207, 1);
+lean_inc(x_228);
+lean_dec(x_207);
+x_229 = lean_ctor_get(x_224, 1);
+lean_inc(x_229);
+lean_dec(x_224);
+x_230 = 0;
+x_231 = lean_box(x_230);
+x_232 = lean_box(x_230);
+x_233 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___boxed), 6, 4);
+lean_closure_set(x_233, 0, x_231);
+lean_closure_set(x_233, 1, x_228);
+lean_closure_set(x_233, 2, x_229);
+lean_closure_set(x_233, 3, x_232);
+x_234 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_234, 0, x_227);
+lean_ctor_set(x_234, 1, x_233);
+x_235 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_235, 0, x_234);
+return x_235;
 }
-else
+}
+}
+}
+case 9:
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; uint8_t x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; 
-x_233 = lean_ctor_get(x_216, 0);
-lean_inc(x_233);
-lean_dec(x_216);
-x_234 = lean_ctor_get(x_215, 0);
-lean_inc(x_234);
-x_235 = lean_ctor_get(x_233, 0);
-lean_inc(x_235);
-x_236 = l_Lean_Parser_sepBy1Info(x_234, x_235);
-x_237 = lean_ctor_get(x_215, 1);
+lean_object* x_236; lean_object* x_237; lean_object* x_238; 
+x_236 = lean_ctor_get(x_2, 0);
+lean_inc(x_236);
+x_237 = lean_ctor_get(x_2, 1);
 lean_inc(x_237);
-lean_dec(x_215);
-x_238 = lean_ctor_get(x_233, 1);
-lean_inc(x_238);
-lean_dec(x_233);
-x_239 = 0;
-x_240 = lean_box(x_2);
-x_241 = lean_box(x_239);
-x_242 = lean_box(x_239);
-x_243 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___boxed), 8, 5);
-lean_closure_set(x_243, 0, x_240);
-lean_closure_set(x_243, 1, x_241);
-lean_closure_set(x_243, 2, x_237);
-lean_closure_set(x_243, 3, x_238);
-lean_closure_set(x_243, 4, x_242);
-x_244 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_244, 0, x_236);
-lean_ctor_set(x_244, 1, x_243);
-x_245 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_245, 0, x_244);
-return x_245;
-}
-}
-}
-}
-case 9:
+lean_dec(x_2);
+x_238 = l_Lean_Parser_compileParserDescr___main(x_1, x_237);
+if (lean_obj_tag(x_238) == 0)
 {
-lean_object* x_246; lean_object* x_247; lean_object* x_248; 
-x_246 = lean_ctor_get(x_3, 0);
-lean_inc(x_246);
-x_247 = lean_ctor_get(x_3, 1);
-lean_inc(x_247);
-lean_dec(x_3);
-x_248 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_247);
-if (lean_obj_tag(x_248) == 0)
+uint8_t x_239; 
+lean_dec(x_236);
+x_239 = !lean_is_exclusive(x_238);
+if (x_239 == 0)
 {
-uint8_t x_249; 
-lean_dec(x_246);
-x_249 = !lean_is_exclusive(x_248);
-if (x_249 == 0)
-{
-return x_248;
+return x_238;
 }
 else
 {
-lean_object* x_250; lean_object* x_251; 
-x_250 = lean_ctor_get(x_248, 0);
+lean_object* x_240; lean_object* x_241; 
+x_240 = lean_ctor_get(x_238, 0);
+lean_inc(x_240);
+lean_dec(x_238);
+x_241 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_241, 0, x_240);
+return x_241;
+}
+}
+else
+{
+uint8_t x_242; 
+x_242 = !lean_is_exclusive(x_238);
+if (x_242 == 0)
+{
+lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; 
+x_243 = lean_ctor_get(x_238, 0);
+x_244 = lean_ctor_get(x_243, 0);
+lean_inc(x_244);
+lean_inc(x_236);
+x_245 = l_Lean_Parser_nodeInfo(x_236, x_244);
+x_246 = lean_ctor_get(x_243, 1);
+lean_inc(x_246);
+lean_dec(x_243);
+x_247 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+lean_closure_set(x_247, 0, x_236);
+lean_closure_set(x_247, 1, x_246);
+x_248 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_248, 0, x_245);
+lean_ctor_set(x_248, 1, x_247);
+lean_ctor_set(x_238, 0, x_248);
+return x_238;
+}
+else
+{
+lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; 
+x_249 = lean_ctor_get(x_238, 0);
+lean_inc(x_249);
+lean_dec(x_238);
+x_250 = lean_ctor_get(x_249, 0);
 lean_inc(x_250);
-lean_dec(x_248);
-x_251 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_251, 0, x_250);
-return x_251;
-}
-}
-else
-{
-uint8_t x_252; 
-x_252 = !lean_is_exclusive(x_248);
-if (x_252 == 0)
-{
-lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; 
-x_253 = lean_ctor_get(x_248, 0);
-x_254 = lean_ctor_get(x_253, 0);
-lean_inc(x_254);
-lean_inc(x_246);
-x_255 = l_Lean_Parser_nodeInfo(x_246, x_254);
-x_256 = lean_ctor_get(x_253, 1);
-lean_inc(x_256);
-lean_dec(x_253);
-x_257 = lean_box(x_2);
-x_258 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_258, 0, x_257);
-lean_closure_set(x_258, 1, x_246);
-lean_closure_set(x_258, 2, x_256);
-x_259 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_259, 0, x_255);
-lean_ctor_set(x_259, 1, x_258);
-lean_ctor_set(x_248, 0, x_259);
-return x_248;
-}
-else
-{
-lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; 
-x_260 = lean_ctor_get(x_248, 0);
-lean_inc(x_260);
-lean_dec(x_248);
-x_261 = lean_ctor_get(x_260, 0);
-lean_inc(x_261);
-lean_inc(x_246);
-x_262 = l_Lean_Parser_nodeInfo(x_246, x_261);
-x_263 = lean_ctor_get(x_260, 1);
-lean_inc(x_263);
-lean_dec(x_260);
-x_264 = lean_box(x_2);
-x_265 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_265, 0, x_264);
-lean_closure_set(x_265, 1, x_246);
-lean_closure_set(x_265, 2, x_263);
-x_266 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_266, 0, x_262);
-lean_ctor_set(x_266, 1, x_265);
-x_267 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_267, 0, x_266);
-return x_267;
-}
-}
-}
-case 11:
-{
-lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-lean_dec(x_1);
-x_268 = lean_ctor_get(x_3, 0);
-lean_inc(x_268);
-x_269 = lean_ctor_get(x_3, 1);
-lean_inc(x_269);
-lean_dec(x_3);
-x_270 = l_String_trim(x_268);
-lean_dec(x_268);
-lean_inc(x_270);
-x_271 = l_Lean_Parser_symbolInfo(x_270, x_269);
-x_272 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
-lean_closure_set(x_272, 0, x_270);
-x_273 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_273, 0, x_271);
-lean_ctor_set(x_273, 1, x_272);
-x_274 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_274, 0, x_273);
-return x_274;
-}
-case 12:
-{
-lean_object* x_275; uint8_t x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; 
-lean_dec(x_1);
-x_275 = lean_ctor_get(x_3, 0);
-lean_inc(x_275);
-x_276 = lean_ctor_get_uint8(x_3, sizeof(void*)*1);
-lean_dec(x_3);
-x_277 = l_String_trim(x_275);
-lean_dec(x_275);
-lean_inc(x_277);
-x_278 = l_Lean_Parser_nonReservedSymbolInfo(x_277, x_276);
-x_279 = lean_alloc_closure((void*)(l_Lean_Parser_nonReservedSymbol___lambda__1___boxed), 4, 1);
-lean_closure_set(x_279, 0, x_277);
-x_280 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_280, 0, x_278);
-lean_ctor_set(x_280, 1, x_279);
-x_281 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_281, 0, x_280);
-return x_281;
-}
-case 13:
-{
-lean_object* x_282; lean_object* x_283; 
-lean_dec(x_3);
-lean_dec(x_1);
-x_282 = l_Lean_Parser_numLit(x_2);
-x_283 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_283, 0, x_282);
-return x_283;
-}
-case 14:
-{
-lean_object* x_284; lean_object* x_285; 
-lean_dec(x_3);
-lean_dec(x_1);
-x_284 = l_Lean_Parser_strLit(x_2);
-x_285 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_285, 0, x_284);
-return x_285;
-}
-case 15:
-{
-lean_object* x_286; lean_object* x_287; 
-lean_dec(x_3);
-lean_dec(x_1);
-x_286 = l_Lean_Parser_charLit(x_2);
-x_287 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_287, 0, x_286);
-return x_287;
-}
-case 16:
-{
-lean_object* x_288; lean_object* x_289; 
-lean_dec(x_3);
-lean_dec(x_1);
-x_288 = l_Lean_Parser_nameLit(x_2);
-x_289 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_289, 0, x_288);
-return x_289;
-}
-case 17:
-{
-lean_object* x_290; lean_object* x_291; 
-lean_dec(x_3);
-lean_dec(x_1);
-x_290 = l_Lean_Parser_ident(x_2);
-x_291 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_291, 0, x_290);
-return x_291;
-}
-default: 
-{
-lean_object* x_292; lean_object* x_293; lean_object* x_294; 
-x_292 = lean_ctor_get(x_3, 0);
-lean_inc(x_292);
-x_293 = lean_ctor_get(x_3, 1);
-lean_inc(x_293);
-lean_dec(x_3);
-x_294 = l_PersistentHashMap_find_x3f___at_Lean_Parser_addLeadingParser___spec__1(x_1, x_292);
-if (lean_obj_tag(x_294) == 0)
-{
-lean_object* x_295; 
-lean_dec(x_293);
-x_295 = l_Lean_Parser_throwUnknownParserCategory___rarg(x_292);
-return x_295;
-}
-else
-{
-lean_object* x_296; lean_object* x_297; 
-lean_dec(x_294);
-x_296 = l_Lean_Parser_categoryParser(x_2, x_292, x_293);
-x_297 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_297, 0, x_296);
-return x_297;
-}
-}
-}
-}
-else
-{
-switch (lean_obj_tag(x_3)) {
-case 0:
-{
-lean_object* x_298; lean_object* x_299; lean_object* x_300; 
-x_298 = lean_ctor_get(x_3, 0);
-lean_inc(x_298);
-x_299 = lean_ctor_get(x_3, 1);
-lean_inc(x_299);
-lean_dec(x_3);
-lean_inc(x_1);
-x_300 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_298);
-if (lean_obj_tag(x_300) == 0)
-{
-uint8_t x_301; 
-lean_dec(x_299);
-lean_dec(x_1);
-x_301 = !lean_is_exclusive(x_300);
-if (x_301 == 0)
-{
-return x_300;
-}
-else
-{
-lean_object* x_302; lean_object* x_303; 
-x_302 = lean_ctor_get(x_300, 0);
-lean_inc(x_302);
-lean_dec(x_300);
-x_303 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_303, 0, x_302);
-return x_303;
-}
-}
-else
-{
-lean_object* x_304; lean_object* x_305; 
-x_304 = lean_ctor_get(x_300, 0);
-lean_inc(x_304);
-lean_dec(x_300);
-x_305 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_299);
-if (lean_obj_tag(x_305) == 0)
-{
-uint8_t x_306; 
-lean_dec(x_304);
-x_306 = !lean_is_exclusive(x_305);
-if (x_306 == 0)
-{
-return x_305;
-}
-else
-{
-lean_object* x_307; lean_object* x_308; 
-x_307 = lean_ctor_get(x_305, 0);
-lean_inc(x_307);
-lean_dec(x_305);
-x_308 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_308, 0, x_307);
-return x_308;
-}
-}
-else
-{
-uint8_t x_309; 
-x_309 = !lean_is_exclusive(x_305);
-if (x_309 == 0)
-{
-lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; 
-x_310 = lean_ctor_get(x_305, 0);
-x_311 = lean_ctor_get(x_304, 0);
-lean_inc(x_311);
-x_312 = lean_ctor_get(x_310, 0);
-lean_inc(x_312);
-x_313 = l_Lean_Parser_andthenInfo(x_311, x_312);
-x_314 = lean_ctor_get(x_304, 1);
-lean_inc(x_314);
-lean_dec(x_304);
-x_315 = lean_ctor_get(x_310, 1);
-lean_inc(x_315);
-lean_dec(x_310);
-x_316 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_316, 0, x_314);
-lean_closure_set(x_316, 1, x_315);
-x_317 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_317, 0, x_313);
-lean_ctor_set(x_317, 1, x_316);
-lean_ctor_set(x_305, 0, x_317);
-return x_305;
-}
-else
-{
-lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; 
-x_318 = lean_ctor_get(x_305, 0);
-lean_inc(x_318);
-lean_dec(x_305);
-x_319 = lean_ctor_get(x_304, 0);
-lean_inc(x_319);
-x_320 = lean_ctor_get(x_318, 0);
-lean_inc(x_320);
-x_321 = l_Lean_Parser_andthenInfo(x_319, x_320);
-x_322 = lean_ctor_get(x_304, 1);
-lean_inc(x_322);
-lean_dec(x_304);
-x_323 = lean_ctor_get(x_318, 1);
-lean_inc(x_323);
-lean_dec(x_318);
-x_324 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_324, 0, x_322);
-lean_closure_set(x_324, 1, x_323);
-x_325 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_325, 0, x_321);
-lean_ctor_set(x_325, 1, x_324);
-x_326 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_326, 0, x_325);
-return x_326;
-}
-}
-}
-}
-case 1:
-{
-lean_object* x_327; lean_object* x_328; lean_object* x_329; 
-x_327 = lean_ctor_get(x_3, 0);
-lean_inc(x_327);
-x_328 = lean_ctor_get(x_3, 1);
-lean_inc(x_328);
-lean_dec(x_3);
-lean_inc(x_1);
-x_329 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_327);
-if (lean_obj_tag(x_329) == 0)
-{
-uint8_t x_330; 
-lean_dec(x_328);
-lean_dec(x_1);
-x_330 = !lean_is_exclusive(x_329);
-if (x_330 == 0)
-{
-return x_329;
-}
-else
-{
-lean_object* x_331; lean_object* x_332; 
-x_331 = lean_ctor_get(x_329, 0);
-lean_inc(x_331);
-lean_dec(x_329);
-x_332 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_332, 0, x_331);
-return x_332;
-}
-}
-else
-{
-lean_object* x_333; lean_object* x_334; 
-x_333 = lean_ctor_get(x_329, 0);
-lean_inc(x_333);
-lean_dec(x_329);
-x_334 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_328);
-if (lean_obj_tag(x_334) == 0)
-{
-uint8_t x_335; 
-lean_dec(x_333);
-x_335 = !lean_is_exclusive(x_334);
-if (x_335 == 0)
-{
-return x_334;
-}
-else
-{
-lean_object* x_336; lean_object* x_337; 
-x_336 = lean_ctor_get(x_334, 0);
-lean_inc(x_336);
-lean_dec(x_334);
-x_337 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_337, 0, x_336);
-return x_337;
-}
-}
-else
-{
-uint8_t x_338; 
-x_338 = !lean_is_exclusive(x_334);
-if (x_338 == 0)
-{
-lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; 
-x_339 = lean_ctor_get(x_334, 0);
-x_340 = lean_ctor_get(x_333, 0);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_339, 0);
-lean_inc(x_341);
-x_342 = l_Lean_Parser_orelseInfo(x_340, x_341);
-x_343 = lean_ctor_get(x_333, 1);
-lean_inc(x_343);
-lean_dec(x_333);
-x_344 = lean_ctor_get(x_339, 1);
-lean_inc(x_344);
-lean_dec(x_339);
-x_345 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 2);
-lean_closure_set(x_345, 0, x_343);
-lean_closure_set(x_345, 1, x_344);
-x_346 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_346, 0, x_342);
-lean_ctor_set(x_346, 1, x_345);
-lean_ctor_set(x_334, 0, x_346);
-return x_334;
-}
-else
-{
-lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; 
-x_347 = lean_ctor_get(x_334, 0);
-lean_inc(x_347);
-lean_dec(x_334);
-x_348 = lean_ctor_get(x_333, 0);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_347, 0);
-lean_inc(x_349);
-x_350 = l_Lean_Parser_orelseInfo(x_348, x_349);
-x_351 = lean_ctor_get(x_333, 1);
-lean_inc(x_351);
-lean_dec(x_333);
-x_352 = lean_ctor_get(x_347, 1);
-lean_inc(x_352);
-lean_dec(x_347);
-x_353 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 2);
-lean_closure_set(x_353, 0, x_351);
-lean_closure_set(x_353, 1, x_352);
-x_354 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_354, 0, x_350);
-lean_ctor_set(x_354, 1, x_353);
-x_355 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_355, 0, x_354);
-return x_355;
-}
-}
-}
-}
-case 2:
-{
-lean_object* x_356; lean_object* x_357; 
-x_356 = lean_ctor_get(x_3, 0);
-lean_inc(x_356);
-lean_dec(x_3);
-x_357 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_356);
-if (lean_obj_tag(x_357) == 0)
-{
-uint8_t x_358; 
-x_358 = !lean_is_exclusive(x_357);
-if (x_358 == 0)
-{
-return x_357;
-}
-else
-{
-lean_object* x_359; lean_object* x_360; 
-x_359 = lean_ctor_get(x_357, 0);
-lean_inc(x_359);
-lean_dec(x_357);
-x_360 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_360, 0, x_359);
-return x_360;
-}
-}
-else
-{
-uint8_t x_361; 
-x_361 = !lean_is_exclusive(x_357);
-if (x_361 == 0)
-{
-lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_362 = lean_ctor_get(x_357, 0);
-x_363 = lean_ctor_get(x_362, 0);
-lean_inc(x_363);
-x_364 = l_Lean_Parser_optionaInfo(x_363);
-x_365 = lean_ctor_get(x_362, 1);
-lean_inc(x_365);
-lean_dec(x_362);
-x_366 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn___rarg), 4, 1);
-lean_closure_set(x_366, 0, x_365);
-x_367 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_367, 0, x_364);
-lean_ctor_set(x_367, 1, x_366);
-lean_ctor_set(x_357, 0, x_367);
-return x_357;
-}
-else
-{
-lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; 
-x_368 = lean_ctor_get(x_357, 0);
-lean_inc(x_368);
-lean_dec(x_357);
-x_369 = lean_ctor_get(x_368, 0);
-lean_inc(x_369);
-x_370 = l_Lean_Parser_optionaInfo(x_369);
-x_371 = lean_ctor_get(x_368, 1);
-lean_inc(x_371);
-lean_dec(x_368);
-x_372 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn___rarg), 4, 1);
-lean_closure_set(x_372, 0, x_371);
-x_373 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_373, 0, x_370);
-lean_ctor_set(x_373, 1, x_372);
-x_374 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_374, 0, x_373);
-return x_374;
-}
-}
-}
-case 3:
-{
-lean_object* x_375; lean_object* x_376; 
-x_375 = lean_ctor_get(x_3, 0);
-lean_inc(x_375);
-lean_dec(x_3);
-x_376 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_375);
-if (lean_obj_tag(x_376) == 0)
-{
-uint8_t x_377; 
-x_377 = !lean_is_exclusive(x_376);
-if (x_377 == 0)
-{
-return x_376;
-}
-else
-{
-lean_object* x_378; lean_object* x_379; 
-x_378 = lean_ctor_get(x_376, 0);
-lean_inc(x_378);
-lean_dec(x_376);
-x_379 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_379, 0, x_378);
-return x_379;
-}
-}
-else
-{
-uint8_t x_380; 
-x_380 = !lean_is_exclusive(x_376);
-if (x_380 == 0)
-{
-lean_object* x_381; uint8_t x_382; 
-x_381 = lean_ctor_get(x_376, 0);
-x_382 = !lean_is_exclusive(x_381);
-if (x_382 == 0)
-{
-lean_object* x_383; lean_object* x_384; 
-x_383 = lean_ctor_get(x_381, 1);
-x_384 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn___rarg), 4, 1);
-lean_closure_set(x_384, 0, x_383);
-lean_ctor_set(x_381, 1, x_384);
-return x_376;
-}
-else
-{
-lean_object* x_385; lean_object* x_386; lean_object* x_387; lean_object* x_388; 
-x_385 = lean_ctor_get(x_381, 0);
-x_386 = lean_ctor_get(x_381, 1);
-lean_inc(x_386);
-lean_inc(x_385);
-lean_dec(x_381);
-x_387 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn___rarg), 4, 1);
-lean_closure_set(x_387, 0, x_386);
-x_388 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_388, 0, x_385);
-lean_ctor_set(x_388, 1, x_387);
-lean_ctor_set(x_376, 0, x_388);
-return x_376;
-}
-}
-else
-{
-lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; 
-x_389 = lean_ctor_get(x_376, 0);
-lean_inc(x_389);
-lean_dec(x_376);
-x_390 = lean_ctor_get(x_389, 0);
-lean_inc(x_390);
-x_391 = lean_ctor_get(x_389, 1);
-lean_inc(x_391);
-if (lean_is_exclusive(x_389)) {
- lean_ctor_release(x_389, 0);
- lean_ctor_release(x_389, 1);
- x_392 = x_389;
-} else {
- lean_dec_ref(x_389);
- x_392 = lean_box(0);
-}
-x_393 = lean_alloc_closure((void*)(l_Lean_Parser_lookaheadFn___rarg), 4, 1);
-lean_closure_set(x_393, 0, x_391);
-if (lean_is_scalar(x_392)) {
- x_394 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_394 = x_392;
-}
-lean_ctor_set(x_394, 0, x_390);
-lean_ctor_set(x_394, 1, x_393);
-x_395 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_395, 0, x_394);
-return x_395;
-}
-}
-}
-case 4:
-{
-lean_object* x_396; lean_object* x_397; 
-x_396 = lean_ctor_get(x_3, 0);
-lean_inc(x_396);
-lean_dec(x_3);
-x_397 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_396);
-if (lean_obj_tag(x_397) == 0)
-{
-uint8_t x_398; 
-x_398 = !lean_is_exclusive(x_397);
-if (x_398 == 0)
-{
-return x_397;
-}
-else
-{
-lean_object* x_399; lean_object* x_400; 
-x_399 = lean_ctor_get(x_397, 0);
-lean_inc(x_399);
-lean_dec(x_397);
-x_400 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_400, 0, x_399);
-return x_400;
-}
-}
-else
-{
-uint8_t x_401; 
-x_401 = !lean_is_exclusive(x_397);
-if (x_401 == 0)
-{
-lean_object* x_402; uint8_t x_403; 
-x_402 = lean_ctor_get(x_397, 0);
-x_403 = !lean_is_exclusive(x_402);
-if (x_403 == 0)
-{
-lean_object* x_404; lean_object* x_405; 
-x_404 = lean_ctor_get(x_402, 1);
-x_405 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
-lean_closure_set(x_405, 0, x_404);
-lean_ctor_set(x_402, 1, x_405);
-return x_397;
-}
-else
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; 
-x_406 = lean_ctor_get(x_402, 0);
-x_407 = lean_ctor_get(x_402, 1);
-lean_inc(x_407);
-lean_inc(x_406);
-lean_dec(x_402);
-x_408 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
-lean_closure_set(x_408, 0, x_407);
-x_409 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_409, 0, x_406);
-lean_ctor_set(x_409, 1, x_408);
-lean_ctor_set(x_397, 0, x_409);
-return x_397;
-}
-}
-else
-{
-lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; 
-x_410 = lean_ctor_get(x_397, 0);
-lean_inc(x_410);
-lean_dec(x_397);
-x_411 = lean_ctor_get(x_410, 0);
-lean_inc(x_411);
-x_412 = lean_ctor_get(x_410, 1);
-lean_inc(x_412);
-if (lean_is_exclusive(x_410)) {
- lean_ctor_release(x_410, 0);
- lean_ctor_release(x_410, 1);
- x_413 = x_410;
-} else {
- lean_dec_ref(x_410);
- x_413 = lean_box(0);
-}
-x_414 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
-lean_closure_set(x_414, 0, x_412);
-if (lean_is_scalar(x_413)) {
- x_415 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_415 = x_413;
-}
-lean_ctor_set(x_415, 0, x_411);
-lean_ctor_set(x_415, 1, x_414);
-x_416 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_416, 0, x_415);
-return x_416;
-}
-}
-}
-case 5:
-{
-lean_object* x_417; lean_object* x_418; 
-x_417 = lean_ctor_get(x_3, 0);
-lean_inc(x_417);
-lean_dec(x_3);
-x_418 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_417);
-if (lean_obj_tag(x_418) == 0)
-{
-uint8_t x_419; 
-x_419 = !lean_is_exclusive(x_418);
-if (x_419 == 0)
-{
-return x_418;
-}
-else
-{
-lean_object* x_420; lean_object* x_421; 
-x_420 = lean_ctor_get(x_418, 0);
-lean_inc(x_420);
-lean_dec(x_418);
-x_421 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_421, 0, x_420);
-return x_421;
-}
-}
-else
-{
-uint8_t x_422; 
-x_422 = !lean_is_exclusive(x_418);
-if (x_422 == 0)
-{
-lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; 
-x_423 = lean_ctor_get(x_418, 0);
-x_424 = lean_ctor_get(x_423, 0);
-lean_inc(x_424);
-x_425 = l_Lean_Parser_noFirstTokenInfo(x_424);
-x_426 = lean_ctor_get(x_423, 1);
-lean_inc(x_426);
-lean_dec(x_423);
-x_427 = lean_box(x_2);
-x_428 = lean_alloc_closure((void*)(l_Lean_Parser_manyFn___boxed), 5, 2);
-lean_closure_set(x_428, 0, x_427);
-lean_closure_set(x_428, 1, x_426);
-x_429 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_429, 0, x_425);
-lean_ctor_set(x_429, 1, x_428);
-lean_ctor_set(x_418, 0, x_429);
-return x_418;
-}
-else
-{
-lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; 
-x_430 = lean_ctor_get(x_418, 0);
-lean_inc(x_430);
-lean_dec(x_418);
-x_431 = lean_ctor_get(x_430, 0);
-lean_inc(x_431);
-x_432 = l_Lean_Parser_noFirstTokenInfo(x_431);
-x_433 = lean_ctor_get(x_430, 1);
-lean_inc(x_433);
-lean_dec(x_430);
-x_434 = lean_box(x_2);
-x_435 = lean_alloc_closure((void*)(l_Lean_Parser_manyFn___boxed), 5, 2);
-lean_closure_set(x_435, 0, x_434);
-lean_closure_set(x_435, 1, x_433);
-x_436 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_436, 0, x_432);
-lean_ctor_set(x_436, 1, x_435);
-x_437 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_437, 0, x_436);
-return x_437;
-}
-}
-}
-case 6:
-{
-lean_object* x_438; lean_object* x_439; 
-x_438 = lean_ctor_get(x_3, 0);
-lean_inc(x_438);
-lean_dec(x_3);
-x_439 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_438);
-if (lean_obj_tag(x_439) == 0)
-{
-uint8_t x_440; 
-x_440 = !lean_is_exclusive(x_439);
-if (x_440 == 0)
-{
-return x_439;
-}
-else
-{
-lean_object* x_441; lean_object* x_442; 
-x_441 = lean_ctor_get(x_439, 0);
-lean_inc(x_441);
-lean_dec(x_439);
-x_442 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_442, 0, x_441);
-return x_442;
-}
-}
-else
-{
-uint8_t x_443; 
-x_443 = !lean_is_exclusive(x_439);
-if (x_443 == 0)
-{
-lean_object* x_444; uint8_t x_445; 
-x_444 = lean_ctor_get(x_439, 0);
-x_445 = !lean_is_exclusive(x_444);
-if (x_445 == 0)
-{
-lean_object* x_446; uint8_t x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; 
-x_446 = lean_ctor_get(x_444, 1);
-x_447 = 0;
-x_448 = lean_box(x_2);
-x_449 = lean_box(x_447);
-x_450 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 6, 3);
-lean_closure_set(x_450, 0, x_448);
-lean_closure_set(x_450, 1, x_446);
-lean_closure_set(x_450, 2, x_449);
-lean_ctor_set(x_444, 1, x_450);
-return x_439;
-}
-else
-{
-lean_object* x_451; lean_object* x_452; uint8_t x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; 
-x_451 = lean_ctor_get(x_444, 0);
-x_452 = lean_ctor_get(x_444, 1);
-lean_inc(x_452);
-lean_inc(x_451);
-lean_dec(x_444);
-x_453 = 0;
-x_454 = lean_box(x_2);
-x_455 = lean_box(x_453);
-x_456 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 6, 3);
-lean_closure_set(x_456, 0, x_454);
-lean_closure_set(x_456, 1, x_452);
-lean_closure_set(x_456, 2, x_455);
-x_457 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_457, 0, x_451);
-lean_ctor_set(x_457, 1, x_456);
-lean_ctor_set(x_439, 0, x_457);
-return x_439;
-}
-}
-else
-{
-lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; uint8_t x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; 
-x_458 = lean_ctor_get(x_439, 0);
-lean_inc(x_458);
-lean_dec(x_439);
-x_459 = lean_ctor_get(x_458, 0);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_458, 1);
-lean_inc(x_460);
-if (lean_is_exclusive(x_458)) {
- lean_ctor_release(x_458, 0);
- lean_ctor_release(x_458, 1);
- x_461 = x_458;
-} else {
- lean_dec_ref(x_458);
- x_461 = lean_box(0);
-}
-x_462 = 0;
-x_463 = lean_box(x_2);
-x_464 = lean_box(x_462);
-x_465 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 6, 3);
-lean_closure_set(x_465, 0, x_463);
-lean_closure_set(x_465, 1, x_460);
-lean_closure_set(x_465, 2, x_464);
-if (lean_is_scalar(x_461)) {
- x_466 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_466 = x_461;
-}
-lean_ctor_set(x_466, 0, x_459);
-lean_ctor_set(x_466, 1, x_465);
-x_467 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_467, 0, x_466);
-return x_467;
-}
-}
-}
-case 7:
-{
-lean_object* x_468; lean_object* x_469; lean_object* x_470; 
-x_468 = lean_ctor_get(x_3, 0);
-lean_inc(x_468);
-x_469 = lean_ctor_get(x_3, 1);
-lean_inc(x_469);
-lean_dec(x_3);
-lean_inc(x_1);
-x_470 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_468);
-if (lean_obj_tag(x_470) == 0)
-{
-uint8_t x_471; 
-lean_dec(x_469);
-lean_dec(x_1);
-x_471 = !lean_is_exclusive(x_470);
-if (x_471 == 0)
-{
-return x_470;
-}
-else
-{
-lean_object* x_472; lean_object* x_473; 
-x_472 = lean_ctor_get(x_470, 0);
-lean_inc(x_472);
-lean_dec(x_470);
-x_473 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_473, 0, x_472);
-return x_473;
-}
-}
-else
-{
-lean_object* x_474; lean_object* x_475; 
-x_474 = lean_ctor_get(x_470, 0);
-lean_inc(x_474);
-lean_dec(x_470);
-x_475 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_469);
-if (lean_obj_tag(x_475) == 0)
-{
-uint8_t x_476; 
-lean_dec(x_474);
-x_476 = !lean_is_exclusive(x_475);
-if (x_476 == 0)
-{
-return x_475;
-}
-else
-{
-lean_object* x_477; lean_object* x_478; 
-x_477 = lean_ctor_get(x_475, 0);
-lean_inc(x_477);
-lean_dec(x_475);
-x_478 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_478, 0, x_477);
-return x_478;
-}
-}
-else
-{
-uint8_t x_479; 
-x_479 = !lean_is_exclusive(x_475);
-if (x_479 == 0)
-{
-lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; uint8_t x_486; lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; 
-x_480 = lean_ctor_get(x_475, 0);
-x_481 = lean_ctor_get(x_474, 0);
-lean_inc(x_481);
-x_482 = lean_ctor_get(x_480, 0);
-lean_inc(x_482);
-x_483 = l_Lean_Parser_sepByInfo(x_481, x_482);
-x_484 = lean_ctor_get(x_474, 1);
-lean_inc(x_484);
-lean_dec(x_474);
-x_485 = lean_ctor_get(x_480, 1);
-lean_inc(x_485);
-lean_dec(x_480);
-x_486 = 0;
-x_487 = lean_box(x_2);
-x_488 = lean_box(x_486);
-x_489 = lean_alloc_closure((void*)(l_Lean_Parser_sepByFn___boxed), 7, 4);
-lean_closure_set(x_489, 0, x_487);
-lean_closure_set(x_489, 1, x_488);
-lean_closure_set(x_489, 2, x_484);
-lean_closure_set(x_489, 3, x_485);
-x_490 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_490, 0, x_483);
-lean_ctor_set(x_490, 1, x_489);
-lean_ctor_set(x_475, 0, x_490);
-return x_475;
-}
-else
-{
-lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; lean_object* x_495; lean_object* x_496; uint8_t x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; 
-x_491 = lean_ctor_get(x_475, 0);
-lean_inc(x_491);
-lean_dec(x_475);
-x_492 = lean_ctor_get(x_474, 0);
-lean_inc(x_492);
-x_493 = lean_ctor_get(x_491, 0);
-lean_inc(x_493);
-x_494 = l_Lean_Parser_sepByInfo(x_492, x_493);
-x_495 = lean_ctor_get(x_474, 1);
-lean_inc(x_495);
-lean_dec(x_474);
-x_496 = lean_ctor_get(x_491, 1);
-lean_inc(x_496);
-lean_dec(x_491);
-x_497 = 0;
-x_498 = lean_box(x_2);
-x_499 = lean_box(x_497);
-x_500 = lean_alloc_closure((void*)(l_Lean_Parser_sepByFn___boxed), 7, 4);
-lean_closure_set(x_500, 0, x_498);
-lean_closure_set(x_500, 1, x_499);
-lean_closure_set(x_500, 2, x_495);
-lean_closure_set(x_500, 3, x_496);
-x_501 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_501, 0, x_494);
-lean_ctor_set(x_501, 1, x_500);
-x_502 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_502, 0, x_501);
-return x_502;
-}
-}
-}
-}
-case 8:
-{
-lean_object* x_503; lean_object* x_504; lean_object* x_505; 
-x_503 = lean_ctor_get(x_3, 0);
-lean_inc(x_503);
-x_504 = lean_ctor_get(x_3, 1);
-lean_inc(x_504);
-lean_dec(x_3);
-lean_inc(x_1);
-x_505 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_503);
-if (lean_obj_tag(x_505) == 0)
-{
-uint8_t x_506; 
-lean_dec(x_504);
-lean_dec(x_1);
-x_506 = !lean_is_exclusive(x_505);
-if (x_506 == 0)
-{
-return x_505;
-}
-else
-{
-lean_object* x_507; lean_object* x_508; 
-x_507 = lean_ctor_get(x_505, 0);
-lean_inc(x_507);
-lean_dec(x_505);
-x_508 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_508, 0, x_507);
-return x_508;
-}
-}
-else
-{
-lean_object* x_509; lean_object* x_510; 
-x_509 = lean_ctor_get(x_505, 0);
-lean_inc(x_509);
-lean_dec(x_505);
-x_510 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_504);
-if (lean_obj_tag(x_510) == 0)
-{
-uint8_t x_511; 
-lean_dec(x_509);
-x_511 = !lean_is_exclusive(x_510);
-if (x_511 == 0)
-{
-return x_510;
-}
-else
-{
-lean_object* x_512; lean_object* x_513; 
-x_512 = lean_ctor_get(x_510, 0);
-lean_inc(x_512);
-lean_dec(x_510);
-x_513 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_513, 0, x_512);
-return x_513;
-}
-}
-else
-{
-uint8_t x_514; 
-x_514 = !lean_is_exclusive(x_510);
-if (x_514 == 0)
-{
-lean_object* x_515; lean_object* x_516; lean_object* x_517; lean_object* x_518; lean_object* x_519; lean_object* x_520; uint8_t x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; lean_object* x_526; 
-x_515 = lean_ctor_get(x_510, 0);
-x_516 = lean_ctor_get(x_509, 0);
-lean_inc(x_516);
-x_517 = lean_ctor_get(x_515, 0);
-lean_inc(x_517);
-x_518 = l_Lean_Parser_sepBy1Info(x_516, x_517);
-x_519 = lean_ctor_get(x_509, 1);
-lean_inc(x_519);
-lean_dec(x_509);
-x_520 = lean_ctor_get(x_515, 1);
-lean_inc(x_520);
-lean_dec(x_515);
-x_521 = 0;
-x_522 = lean_box(x_2);
-x_523 = lean_box(x_521);
-x_524 = lean_box(x_521);
-x_525 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___boxed), 8, 5);
-lean_closure_set(x_525, 0, x_522);
-lean_closure_set(x_525, 1, x_523);
-lean_closure_set(x_525, 2, x_519);
-lean_closure_set(x_525, 3, x_520);
-lean_closure_set(x_525, 4, x_524);
-x_526 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_526, 0, x_518);
-lean_ctor_set(x_526, 1, x_525);
-lean_ctor_set(x_510, 0, x_526);
-return x_510;
-}
-else
-{
-lean_object* x_527; lean_object* x_528; lean_object* x_529; lean_object* x_530; lean_object* x_531; lean_object* x_532; uint8_t x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; 
-x_527 = lean_ctor_get(x_510, 0);
-lean_inc(x_527);
-lean_dec(x_510);
-x_528 = lean_ctor_get(x_509, 0);
-lean_inc(x_528);
-x_529 = lean_ctor_get(x_527, 0);
-lean_inc(x_529);
-x_530 = l_Lean_Parser_sepBy1Info(x_528, x_529);
-x_531 = lean_ctor_get(x_509, 1);
-lean_inc(x_531);
-lean_dec(x_509);
-x_532 = lean_ctor_get(x_527, 1);
-lean_inc(x_532);
-lean_dec(x_527);
-x_533 = 0;
-x_534 = lean_box(x_2);
-x_535 = lean_box(x_533);
-x_536 = lean_box(x_533);
-x_537 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___boxed), 8, 5);
-lean_closure_set(x_537, 0, x_534);
-lean_closure_set(x_537, 1, x_535);
-lean_closure_set(x_537, 2, x_531);
-lean_closure_set(x_537, 3, x_532);
-lean_closure_set(x_537, 4, x_536);
-x_538 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_538, 0, x_530);
-lean_ctor_set(x_538, 1, x_537);
-x_539 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_539, 0, x_538);
-return x_539;
-}
-}
-}
-}
-case 9:
-{
-lean_object* x_540; lean_object* x_541; lean_object* x_542; 
-x_540 = lean_ctor_get(x_3, 0);
-lean_inc(x_540);
-x_541 = lean_ctor_get(x_3, 1);
-lean_inc(x_541);
-lean_dec(x_3);
-x_542 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_541);
-if (lean_obj_tag(x_542) == 0)
-{
-uint8_t x_543; 
-lean_dec(x_540);
-x_543 = !lean_is_exclusive(x_542);
-if (x_543 == 0)
-{
-return x_542;
-}
-else
-{
-lean_object* x_544; lean_object* x_545; 
-x_544 = lean_ctor_get(x_542, 0);
-lean_inc(x_544);
-lean_dec(x_542);
-x_545 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_545, 0, x_544);
-return x_545;
-}
-}
-else
-{
-uint8_t x_546; 
-x_546 = !lean_is_exclusive(x_542);
-if (x_546 == 0)
-{
-lean_object* x_547; lean_object* x_548; lean_object* x_549; lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; 
-x_547 = lean_ctor_get(x_542, 0);
-x_548 = lean_ctor_get(x_547, 0);
-lean_inc(x_548);
-lean_inc(x_540);
-x_549 = l_Lean_Parser_nodeInfo(x_540, x_548);
-x_550 = lean_ctor_get(x_547, 1);
-lean_inc(x_550);
-lean_dec(x_547);
-x_551 = lean_box(x_2);
-x_552 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_552, 0, x_551);
-lean_closure_set(x_552, 1, x_540);
-lean_closure_set(x_552, 2, x_550);
-x_553 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_553, 0, x_549);
-lean_ctor_set(x_553, 1, x_552);
-lean_ctor_set(x_542, 0, x_553);
-return x_542;
-}
-else
-{
-lean_object* x_554; lean_object* x_555; lean_object* x_556; lean_object* x_557; lean_object* x_558; lean_object* x_559; lean_object* x_560; lean_object* x_561; 
-x_554 = lean_ctor_get(x_542, 0);
-lean_inc(x_554);
-lean_dec(x_542);
-x_555 = lean_ctor_get(x_554, 0);
-lean_inc(x_555);
-lean_inc(x_540);
-x_556 = l_Lean_Parser_nodeInfo(x_540, x_555);
-x_557 = lean_ctor_get(x_554, 1);
-lean_inc(x_557);
-lean_dec(x_554);
-x_558 = lean_box(x_2);
-x_559 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_559, 0, x_558);
-lean_closure_set(x_559, 1, x_540);
-lean_closure_set(x_559, 2, x_557);
-x_560 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_560, 0, x_556);
-lean_ctor_set(x_560, 1, x_559);
-x_561 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_561, 0, x_560);
-return x_561;
+lean_inc(x_236);
+x_251 = l_Lean_Parser_nodeInfo(x_236, x_250);
+x_252 = lean_ctor_get(x_249, 1);
+lean_inc(x_252);
+lean_dec(x_249);
+x_253 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+lean_closure_set(x_253, 0, x_236);
+lean_closure_set(x_253, 1, x_252);
+x_254 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_254, 0, x_251);
+lean_ctor_set(x_254, 1, x_253);
+x_255 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_255, 0, x_254);
+return x_255;
 }
 }
 }
 case 10:
 {
-lean_object* x_562; lean_object* x_563; lean_object* x_564; 
-x_562 = lean_ctor_get(x_3, 0);
-lean_inc(x_562);
-x_563 = lean_ctor_get(x_3, 1);
-lean_inc(x_563);
-lean_dec(x_3);
-x_564 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_563);
-if (lean_obj_tag(x_564) == 0)
+lean_object* x_256; lean_object* x_257; lean_object* x_258; 
+x_256 = lean_ctor_get(x_2, 0);
+lean_inc(x_256);
+x_257 = lean_ctor_get(x_2, 1);
+lean_inc(x_257);
+lean_dec(x_2);
+x_258 = l_Lean_Parser_compileParserDescr___main(x_1, x_257);
+if (lean_obj_tag(x_258) == 0)
 {
-uint8_t x_565; 
-lean_dec(x_562);
-x_565 = !lean_is_exclusive(x_564);
-if (x_565 == 0)
+uint8_t x_259; 
+lean_dec(x_256);
+x_259 = !lean_is_exclusive(x_258);
+if (x_259 == 0)
 {
-return x_564;
+return x_258;
 }
 else
 {
-lean_object* x_566; lean_object* x_567; 
-x_566 = lean_ctor_get(x_564, 0);
-lean_inc(x_566);
-lean_dec(x_564);
-x_567 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_567, 0, x_566);
-return x_567;
+lean_object* x_260; lean_object* x_261; 
+x_260 = lean_ctor_get(x_258, 0);
+lean_inc(x_260);
+lean_dec(x_258);
+x_261 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_261, 0, x_260);
+return x_261;
 }
 }
 else
 {
-uint8_t x_568; 
-x_568 = !lean_is_exclusive(x_564);
-if (x_568 == 0)
+uint8_t x_262; 
+x_262 = !lean_is_exclusive(x_258);
+if (x_262 == 0)
 {
-lean_object* x_569; lean_object* x_570; lean_object* x_571; lean_object* x_572; uint8_t x_573; lean_object* x_574; lean_object* x_575; lean_object* x_576; 
-x_569 = lean_ctor_get(x_564, 0);
-x_570 = lean_ctor_get(x_569, 0);
-lean_inc(x_570);
-lean_inc(x_562);
-x_571 = l_Lean_Parser_nodeInfo(x_562, x_570);
-x_572 = lean_ctor_get(x_569, 1);
-lean_inc(x_572);
-lean_dec(x_569);
-x_573 = 1;
-x_574 = lean_box(x_573);
-x_575 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_575, 0, x_574);
-lean_closure_set(x_575, 1, x_562);
-lean_closure_set(x_575, 2, x_572);
-x_576 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_576, 0, x_571);
-lean_ctor_set(x_576, 1, x_575);
-lean_ctor_set(x_564, 0, x_576);
-return x_564;
+lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; 
+x_263 = lean_ctor_get(x_258, 0);
+x_264 = lean_ctor_get(x_263, 0);
+lean_inc(x_264);
+lean_inc(x_256);
+x_265 = l_Lean_Parser_nodeInfo(x_256, x_264);
+x_266 = lean_ctor_get(x_263, 1);
+lean_inc(x_266);
+lean_dec(x_263);
+x_267 = lean_alloc_closure((void*)(l_Lean_Parser_trailingNodeFn), 4, 2);
+lean_closure_set(x_267, 0, x_256);
+lean_closure_set(x_267, 1, x_266);
+x_268 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_268, 0, x_265);
+lean_ctor_set(x_268, 1, x_267);
+lean_ctor_set(x_258, 0, x_268);
+return x_258;
 }
 else
 {
-lean_object* x_577; lean_object* x_578; lean_object* x_579; lean_object* x_580; uint8_t x_581; lean_object* x_582; lean_object* x_583; lean_object* x_584; lean_object* x_585; 
-x_577 = lean_ctor_get(x_564, 0);
-lean_inc(x_577);
-lean_dec(x_564);
-x_578 = lean_ctor_get(x_577, 0);
-lean_inc(x_578);
-lean_inc(x_562);
-x_579 = l_Lean_Parser_nodeInfo(x_562, x_578);
-x_580 = lean_ctor_get(x_577, 1);
-lean_inc(x_580);
-lean_dec(x_577);
-x_581 = 1;
-x_582 = lean_box(x_581);
-x_583 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_583, 0, x_582);
-lean_closure_set(x_583, 1, x_562);
-lean_closure_set(x_583, 2, x_580);
-x_584 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_584, 0, x_579);
-lean_ctor_set(x_584, 1, x_583);
-x_585 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_585, 0, x_584);
-return x_585;
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; 
+x_269 = lean_ctor_get(x_258, 0);
+lean_inc(x_269);
+lean_dec(x_258);
+x_270 = lean_ctor_get(x_269, 0);
+lean_inc(x_270);
+lean_inc(x_256);
+x_271 = l_Lean_Parser_nodeInfo(x_256, x_270);
+x_272 = lean_ctor_get(x_269, 1);
+lean_inc(x_272);
+lean_dec(x_269);
+x_273 = lean_alloc_closure((void*)(l_Lean_Parser_trailingNodeFn), 4, 2);
+lean_closure_set(x_273, 0, x_256);
+lean_closure_set(x_273, 1, x_272);
+x_274 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_274, 0, x_271);
+lean_ctor_set(x_274, 1, x_273);
+x_275 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_275, 0, x_274);
+return x_275;
 }
 }
 }
 case 11:
 {
-lean_object* x_586; lean_object* x_587; lean_object* x_588; lean_object* x_589; lean_object* x_590; lean_object* x_591; lean_object* x_592; 
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
 lean_dec(x_1);
-x_586 = lean_ctor_get(x_3, 0);
-lean_inc(x_586);
-x_587 = lean_ctor_get(x_3, 1);
-lean_inc(x_587);
-lean_dec(x_3);
-x_588 = l_String_trim(x_586);
-lean_dec(x_586);
-lean_inc(x_588);
-x_589 = l_Lean_Parser_symbolInfo(x_588, x_587);
-x_590 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
-lean_closure_set(x_590, 0, x_588);
-x_591 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_591, 0, x_589);
-lean_ctor_set(x_591, 1, x_590);
-x_592 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_592, 0, x_591);
-return x_592;
+x_276 = lean_ctor_get(x_2, 0);
+lean_inc(x_276);
+x_277 = lean_ctor_get(x_2, 1);
+lean_inc(x_277);
+lean_dec(x_2);
+x_278 = l_String_trim(x_276);
+lean_dec(x_276);
+lean_inc(x_278);
+x_279 = l_Lean_Parser_symbolInfo(x_278, x_277);
+x_280 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
+lean_closure_set(x_280, 0, x_278);
+x_281 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_281, 0, x_279);
+lean_ctor_set(x_281, 1, x_280);
+x_282 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_282, 0, x_281);
+return x_282;
+}
+case 12:
+{
+lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; 
+lean_dec(x_1);
+x_283 = lean_ctor_get(x_2, 0);
+lean_inc(x_283);
+x_284 = lean_ctor_get_uint8(x_2, sizeof(void*)*1);
+lean_dec(x_2);
+x_285 = l_String_trim(x_283);
+lean_dec(x_283);
+lean_inc(x_285);
+x_286 = l_Lean_Parser_nonReservedSymbolInfo(x_285, x_284);
+x_287 = lean_alloc_closure((void*)(l_Lean_Parser_nonReservedSymbolFn), 3, 1);
+lean_closure_set(x_287, 0, x_285);
+x_288 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_288, 0, x_286);
+lean_ctor_set(x_288, 1, x_287);
+x_289 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_289, 0, x_288);
+return x_289;
 }
 case 13:
 {
-lean_object* x_593; lean_object* x_594; 
-lean_dec(x_3);
+lean_object* x_290; 
 lean_dec(x_1);
-x_593 = l_Lean_Parser_numLit(x_2);
-x_594 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_594, 0, x_593);
-return x_594;
+x_290 = l_Lean_Parser_compileParserDescr___main___closed__1;
+return x_290;
 }
 case 14:
 {
-lean_object* x_595; lean_object* x_596; 
-lean_dec(x_3);
+lean_object* x_291; 
 lean_dec(x_1);
-x_595 = l_Lean_Parser_strLit(x_2);
-x_596 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_596, 0, x_595);
-return x_596;
+x_291 = l_Lean_Parser_compileParserDescr___main___closed__2;
+return x_291;
 }
 case 15:
 {
-lean_object* x_597; lean_object* x_598; 
-lean_dec(x_3);
+lean_object* x_292; 
 lean_dec(x_1);
-x_597 = l_Lean_Parser_charLit(x_2);
-x_598 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_598, 0, x_597);
-return x_598;
+x_292 = l_Lean_Parser_compileParserDescr___main___closed__3;
+return x_292;
 }
 case 16:
 {
-lean_object* x_599; lean_object* x_600; 
-lean_dec(x_3);
+lean_object* x_293; 
 lean_dec(x_1);
-x_599 = l_Lean_Parser_nameLit(x_2);
-x_600 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_600, 0, x_599);
-return x_600;
+x_293 = l_Lean_Parser_compileParserDescr___main___closed__4;
+return x_293;
 }
 case 17:
 {
-lean_object* x_601; lean_object* x_602; 
-lean_dec(x_3);
+lean_object* x_294; 
 lean_dec(x_1);
-x_601 = l_Lean_Parser_ident(x_2);
-x_602 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_602, 0, x_601);
-return x_602;
+x_294 = l_Lean_Parser_compileParserDescr___main___closed__5;
+return x_294;
 }
 default: 
 {
-lean_object* x_603; lean_object* x_604; lean_object* x_605; 
-x_603 = lean_ctor_get(x_3, 0);
-lean_inc(x_603);
-x_604 = lean_ctor_get(x_3, 1);
-lean_inc(x_604);
-lean_dec(x_3);
-x_605 = l_PersistentHashMap_find_x3f___at_Lean_Parser_addLeadingParser___spec__1(x_1, x_603);
-if (lean_obj_tag(x_605) == 0)
+lean_object* x_295; lean_object* x_296; lean_object* x_297; 
+x_295 = lean_ctor_get(x_2, 0);
+lean_inc(x_295);
+x_296 = lean_ctor_get(x_2, 1);
+lean_inc(x_296);
+lean_dec(x_2);
+x_297 = l_PersistentHashMap_find_x3f___at_Lean_Parser_addLeadingParser___spec__1(x_1, x_295);
+if (lean_obj_tag(x_297) == 0)
 {
-lean_object* x_606; 
-lean_dec(x_604);
-x_606 = l_Lean_Parser_throwUnknownParserCategory___rarg(x_603);
-return x_606;
+lean_object* x_298; 
+lean_dec(x_296);
+x_298 = l_Lean_Parser_throwUnknownParserCategory___rarg(x_295);
+return x_298;
 }
 else
 {
-lean_object* x_607; lean_object* x_608; 
-lean_dec(x_605);
-x_607 = l_Lean_Parser_categoryParser(x_2, x_603, x_604);
-x_608 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_608, 0, x_607);
-return x_608;
+lean_object* x_299; lean_object* x_300; 
+lean_dec(x_297);
+x_299 = l_Lean_Parser_categoryParser(x_295, x_296);
+x_300 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_300, 0, x_299);
+return x_300;
 }
 }
 }
 }
 }
-}
-lean_object* l_Lean_Parser_compileParserDescr___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_compileParserDescr(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_2);
-lean_dec(x_2);
-x_5 = l_Lean_Parser_compileParserDescr___main(x_1, x_4, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_compileParserDescr(lean_object* x_1, uint8_t x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Lean_Parser_compileParserDescr___main(x_1, x_2, x_3);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_compileParserDescr___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_2);
-lean_dec(x_2);
-x_5 = l_Lean_Parser_compileParserDescr(x_1, x_4, x_3);
-return x_5;
+lean_object* x_3; 
+x_3 = l_Lean_Parser_compileParserDescr___main(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_mkParserOfConstantUnsafe___closed__1() {
@@ -33884,22 +31613,6 @@ x_1 = lean_mk_string("TrailingParser");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_mkParserOfConstantUnsafe___closed__6() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("ParserKind");
-return x_1;
-}
-}
-lean_object* _init_l_Lean_Parser_mkParserOfConstantUnsafe___closed__7() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("leading");
-return x_1;
-}
-}
 lean_object* l_Lean_Parser_mkParserOfConstantUnsafe(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -33931,8 +31644,7 @@ lean_inc(x_21);
 lean_dec(x_13);
 x_22 = l_Lean_ConstantInfo_type(x_21);
 lean_dec(x_21);
-switch (lean_obj_tag(x_22)) {
-case 4:
+if (lean_obj_tag(x_22) == 4)
 {
 lean_object* x_23; 
 x_23 = lean_ctor_get(x_22, 0);
@@ -34019,99 +31731,99 @@ return x_39;
 }
 else
 {
-lean_object* x_40; uint8_t x_41; lean_object* x_42; 
+lean_object* x_40; lean_object* x_41; 
 x_40 = lean_ctor_get(x_36, 0);
 lean_inc(x_40);
 lean_dec(x_36);
-x_41 = 1;
-x_42 = l_Lean_Parser_compileParserDescr___main(x_2, x_41, x_40);
-if (lean_obj_tag(x_42) == 0)
+x_41 = l_Lean_Parser_compileParserDescr___main(x_2, x_40);
+if (lean_obj_tag(x_41) == 0)
 {
-uint8_t x_43; 
-x_43 = !lean_is_exclusive(x_42);
-if (x_43 == 0)
+uint8_t x_42; 
+x_42 = !lean_is_exclusive(x_41);
+if (x_42 == 0)
 {
-return x_42;
+return x_41;
 }
 else
 {
-lean_object* x_44; lean_object* x_45; 
-x_44 = lean_ctor_get(x_42, 0);
-lean_inc(x_44);
-lean_dec(x_42);
-x_45 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_45, 0, x_44);
-return x_45;
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+lean_dec(x_41);
+x_44 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_44, 0, x_43);
+return x_44;
 }
 }
 else
 {
-uint8_t x_46; 
-x_46 = !lean_is_exclusive(x_42);
-if (x_46 == 0)
+uint8_t x_45; 
+x_45 = !lean_is_exclusive(x_41);
+if (x_45 == 0)
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_47 = lean_ctor_get(x_42, 0);
-x_48 = lean_box(x_41);
+lean_object* x_46; uint8_t x_47; lean_object* x_48; lean_object* x_49; 
+x_46 = lean_ctor_get(x_41, 0);
+x_47 = 0;
+x_48 = lean_box(x_47);
 x_49 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_49, 0, x_48);
-lean_ctor_set(x_49, 1, x_47);
-lean_ctor_set(x_42, 0, x_49);
-return x_42;
+lean_ctor_set(x_49, 1, x_46);
+lean_ctor_set(x_41, 0, x_49);
+return x_41;
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-x_50 = lean_ctor_get(x_42, 0);
+lean_object* x_50; uint8_t x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_50 = lean_ctor_get(x_41, 0);
 lean_inc(x_50);
-lean_dec(x_42);
-x_51 = lean_box(x_41);
-x_52 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_52, 0, x_51);
-lean_ctor_set(x_52, 1, x_50);
-x_53 = lean_alloc_ctor(1, 1, 0);
+lean_dec(x_41);
+x_51 = 0;
+x_52 = lean_box(x_51);
+x_53 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_53, 0, x_52);
-return x_53;
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_54; 
-lean_dec(x_26);
-x_54 = lean_eval_const(x_1, x_3);
-lean_dec(x_3);
-lean_dec(x_1);
-if (lean_obj_tag(x_54) == 0)
-{
-uint8_t x_55; 
-lean_dec(x_2);
-x_55 = !lean_is_exclusive(x_54);
-if (x_55 == 0)
-{
+lean_ctor_set(x_53, 1, x_50);
+x_54 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_54, 0, x_53);
 return x_54;
 }
-else
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = lean_ctor_get(x_54, 0);
-lean_inc(x_56);
-lean_dec(x_54);
-x_57 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_57, 0, x_56);
-return x_57;
+}
+}
 }
 }
 else
 {
-lean_object* x_58; uint8_t x_59; lean_object* x_60; 
-x_58 = lean_ctor_get(x_54, 0);
-lean_inc(x_58);
-lean_dec(x_54);
-x_59 = 0;
-x_60 = l_Lean_Parser_compileParserDescr___main(x_2, x_59, x_58);
+lean_object* x_55; 
+lean_dec(x_26);
+x_55 = lean_eval_const(x_1, x_3);
+lean_dec(x_3);
+lean_dec(x_1);
+if (lean_obj_tag(x_55) == 0)
+{
+uint8_t x_56; 
+lean_dec(x_2);
+x_56 = !lean_is_exclusive(x_55);
+if (x_56 == 0)
+{
+return x_55;
+}
+else
+{
+lean_object* x_57; lean_object* x_58; 
+x_57 = lean_ctor_get(x_55, 0);
+lean_inc(x_57);
+lean_dec(x_55);
+x_58 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_58, 0, x_57);
+return x_58;
+}
+}
+else
+{
+lean_object* x_59; lean_object* x_60; 
+x_59 = lean_ctor_get(x_55, 0);
+lean_inc(x_59);
+lean_dec(x_55);
+x_60 = l_Lean_Parser_compileParserDescr___main(x_2, x_59);
 if (lean_obj_tag(x_60) == 0)
 {
 uint8_t x_61; 
@@ -34137,28 +31849,30 @@ uint8_t x_64;
 x_64 = !lean_is_exclusive(x_60);
 if (x_64 == 0)
 {
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+lean_object* x_65; uint8_t x_66; lean_object* x_67; lean_object* x_68; 
 x_65 = lean_ctor_get(x_60, 0);
-x_66 = lean_box(x_59);
-x_67 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_67, 0, x_66);
-lean_ctor_set(x_67, 1, x_65);
-lean_ctor_set(x_60, 0, x_67);
+x_66 = 1;
+x_67 = lean_box(x_66);
+x_68 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_68, 0, x_67);
+lean_ctor_set(x_68, 1, x_65);
+lean_ctor_set(x_60, 0, x_68);
 return x_60;
 }
 else
 {
-lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-x_68 = lean_ctor_get(x_60, 0);
-lean_inc(x_68);
+lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+x_69 = lean_ctor_get(x_60, 0);
+lean_inc(x_69);
 lean_dec(x_60);
-x_69 = lean_box(x_59);
-x_70 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_70, 1, x_68);
-x_71 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_71, 0, x_70);
-return x_71;
+x_70 = 1;
+x_71 = lean_box(x_70);
+x_72 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_72, 0, x_71);
+lean_ctor_set(x_72, 1, x_69);
+x_73 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_73, 0, x_72);
+return x_73;
 }
 }
 }
@@ -34167,183 +31881,183 @@ return x_71;
 }
 case 1:
 {
-lean_object* x_72; 
+lean_object* x_74; 
 lean_dec(x_2);
-x_72 = lean_ctor_get(x_25, 0);
-lean_inc(x_72);
-if (lean_obj_tag(x_72) == 0)
-{
-lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; uint8_t x_77; 
-x_73 = lean_ctor_get(x_23, 1);
-lean_inc(x_73);
-lean_dec(x_23);
-x_74 = lean_ctor_get(x_24, 1);
+x_74 = lean_ctor_get(x_25, 0);
 lean_inc(x_74);
-lean_dec(x_24);
-x_75 = lean_ctor_get(x_25, 1);
+if (lean_obj_tag(x_74) == 0)
+{
+lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; 
+x_75 = lean_ctor_get(x_23, 1);
 lean_inc(x_75);
+lean_dec(x_23);
+x_76 = lean_ctor_get(x_24, 1);
+lean_inc(x_76);
+lean_dec(x_24);
+x_77 = lean_ctor_get(x_25, 1);
+lean_inc(x_77);
 lean_dec(x_25);
-x_76 = l_Lean_mkAppStx___closed__1;
-x_77 = lean_string_dec_eq(x_75, x_76);
+x_78 = l_Lean_mkAppStx___closed__1;
+x_79 = lean_string_dec_eq(x_77, x_78);
+lean_dec(x_77);
+if (x_79 == 0)
+{
+lean_object* x_80; 
+lean_dec(x_76);
 lean_dec(x_75);
-if (x_77 == 0)
-{
-lean_object* x_78; 
-lean_dec(x_74);
-lean_dec(x_73);
 lean_dec(x_1);
-x_78 = lean_box(0);
-x_4 = x_78;
+x_80 = lean_box(0);
+x_4 = x_80;
 goto block_12;
 }
 else
 {
-lean_object* x_79; uint8_t x_80; 
-x_79 = l_Lean_mkAppStx___closed__3;
-x_80 = lean_string_dec_eq(x_74, x_79);
-lean_dec(x_74);
-if (x_80 == 0)
+lean_object* x_81; uint8_t x_82; 
+x_81 = l_Lean_mkAppStx___closed__3;
+x_82 = lean_string_dec_eq(x_76, x_81);
+lean_dec(x_76);
+if (x_82 == 0)
 {
-lean_object* x_81; 
-lean_dec(x_73);
+lean_object* x_83; 
+lean_dec(x_75);
 lean_dec(x_1);
-x_81 = lean_box(0);
-x_4 = x_81;
+x_83 = lean_box(0);
+x_4 = x_83;
 goto block_12;
 }
 else
 {
-lean_object* x_82; uint8_t x_83; 
-x_82 = l_Lean_Parser_mkParserOfConstantUnsafe___closed__5;
-x_83 = lean_string_dec_eq(x_73, x_82);
-if (x_83 == 0)
+lean_object* x_84; uint8_t x_85; 
+x_84 = l_Lean_Parser_mkParserOfConstantUnsafe___closed__5;
+x_85 = lean_string_dec_eq(x_75, x_84);
+if (x_85 == 0)
 {
-uint8_t x_84; 
-x_84 = lean_string_dec_eq(x_73, x_79);
-lean_dec(x_73);
-if (x_84 == 0)
+uint8_t x_86; 
+x_86 = lean_string_dec_eq(x_75, x_81);
+lean_dec(x_75);
+if (x_86 == 0)
 {
-lean_object* x_85; 
+lean_object* x_87; 
 lean_dec(x_1);
-x_85 = lean_box(0);
-x_4 = x_85;
+x_87 = lean_box(0);
+x_4 = x_87;
 goto block_12;
 }
 else
 {
-lean_object* x_86; 
-x_86 = lean_eval_const(x_1, x_3);
+lean_object* x_88; 
+x_88 = lean_eval_const(x_1, x_3);
 lean_dec(x_3);
 lean_dec(x_1);
-if (lean_obj_tag(x_86) == 0)
+if (lean_obj_tag(x_88) == 0)
 {
-uint8_t x_87; 
-x_87 = !lean_is_exclusive(x_86);
-if (x_87 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_88);
+if (x_89 == 0)
 {
-return x_86;
+return x_88;
 }
 else
 {
-lean_object* x_88; lean_object* x_89; 
-x_88 = lean_ctor_get(x_86, 0);
-lean_inc(x_88);
-lean_dec(x_86);
-x_89 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_89, 0, x_88);
-return x_89;
+lean_object* x_90; lean_object* x_91; 
+x_90 = lean_ctor_get(x_88, 0);
+lean_inc(x_90);
+lean_dec(x_88);
+x_91 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_91, 0, x_90);
+return x_91;
 }
 }
 else
 {
-uint8_t x_90; 
-x_90 = !lean_is_exclusive(x_86);
-if (x_90 == 0)
+uint8_t x_92; 
+x_92 = !lean_is_exclusive(x_88);
+if (x_92 == 0)
 {
-lean_object* x_91; uint8_t x_92; lean_object* x_93; lean_object* x_94; 
-x_91 = lean_ctor_get(x_86, 0);
-x_92 = 0;
-x_93 = lean_box(x_92);
-x_94 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_94, 0, x_93);
-lean_ctor_set(x_94, 1, x_91);
-lean_ctor_set(x_86, 0, x_94);
-return x_86;
+lean_object* x_93; uint8_t x_94; lean_object* x_95; lean_object* x_96; 
+x_93 = lean_ctor_get(x_88, 0);
+x_94 = 1;
+x_95 = lean_box(x_94);
+x_96 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_96, 0, x_95);
+lean_ctor_set(x_96, 1, x_93);
+lean_ctor_set(x_88, 0, x_96);
+return x_88;
 }
 else
 {
-lean_object* x_95; uint8_t x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; 
-x_95 = lean_ctor_get(x_86, 0);
-lean_inc(x_95);
-lean_dec(x_86);
-x_96 = 0;
-x_97 = lean_box(x_96);
-x_98 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_98, 0, x_97);
-lean_ctor_set(x_98, 1, x_95);
-x_99 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_99, 0, x_98);
-return x_99;
+lean_object* x_97; uint8_t x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; 
+x_97 = lean_ctor_get(x_88, 0);
+lean_inc(x_97);
+lean_dec(x_88);
+x_98 = 1;
+x_99 = lean_box(x_98);
+x_100 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_100, 0, x_99);
+lean_ctor_set(x_100, 1, x_97);
+x_101 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_101, 0, x_100);
+return x_101;
 }
 }
 }
 }
 else
 {
-lean_object* x_100; 
-lean_dec(x_73);
-x_100 = lean_eval_const(x_1, x_3);
+lean_object* x_102; 
+lean_dec(x_75);
+x_102 = lean_eval_const(x_1, x_3);
 lean_dec(x_3);
 lean_dec(x_1);
-if (lean_obj_tag(x_100) == 0)
+if (lean_obj_tag(x_102) == 0)
 {
-uint8_t x_101; 
-x_101 = !lean_is_exclusive(x_100);
-if (x_101 == 0)
+uint8_t x_103; 
+x_103 = !lean_is_exclusive(x_102);
+if (x_103 == 0)
 {
-return x_100;
+return x_102;
 }
 else
 {
-lean_object* x_102; lean_object* x_103; 
-x_102 = lean_ctor_get(x_100, 0);
-lean_inc(x_102);
-lean_dec(x_100);
-x_103 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_103, 0, x_102);
-return x_103;
+lean_object* x_104; lean_object* x_105; 
+x_104 = lean_ctor_get(x_102, 0);
+lean_inc(x_104);
+lean_dec(x_102);
+x_105 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_105, 0, x_104);
+return x_105;
 }
 }
 else
 {
-uint8_t x_104; 
-x_104 = !lean_is_exclusive(x_100);
-if (x_104 == 0)
+uint8_t x_106; 
+x_106 = !lean_is_exclusive(x_102);
+if (x_106 == 0)
 {
-lean_object* x_105; uint8_t x_106; lean_object* x_107; lean_object* x_108; 
-x_105 = lean_ctor_get(x_100, 0);
-x_106 = 1;
-x_107 = lean_box(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_105);
-lean_ctor_set(x_100, 0, x_108);
-return x_100;
+lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
+x_107 = lean_ctor_get(x_102, 0);
+x_108 = 0;
+x_109 = lean_box(x_108);
+x_110 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_110, 0, x_109);
+lean_ctor_set(x_110, 1, x_107);
+lean_ctor_set(x_102, 0, x_110);
+return x_102;
 }
 else
 {
-lean_object* x_109; uint8_t x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; 
-x_109 = lean_ctor_get(x_100, 0);
-lean_inc(x_109);
-lean_dec(x_100);
-x_110 = 1;
-x_111 = lean_box(x_110);
-x_112 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_112, 0, x_111);
-lean_ctor_set(x_112, 1, x_109);
-x_113 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_113, 0, x_112);
-return x_113;
+lean_object* x_111; uint8_t x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; 
+x_111 = lean_ctor_get(x_102, 0);
+lean_inc(x_111);
+lean_dec(x_102);
+x_112 = 0;
+x_113 = lean_box(x_112);
+x_114 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_114, 0, x_113);
+lean_ctor_set(x_114, 1, x_111);
+x_115 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_115, 0, x_114);
+return x_115;
 }
 }
 }
@@ -34352,46 +32066,22 @@ return x_113;
 }
 else
 {
-lean_object* x_114; 
-lean_dec(x_72);
-lean_dec(x_25);
-lean_dec(x_24);
-lean_dec(x_23);
-lean_dec(x_1);
-x_114 = lean_box(0);
-x_4 = x_114;
-goto block_12;
-}
-}
-default: 
-{
-lean_object* x_115; 
-lean_dec(x_25);
-lean_dec(x_24);
-lean_dec(x_23);
-lean_dec(x_2);
-lean_dec(x_1);
-x_115 = lean_box(0);
-x_4 = x_115;
-goto block_12;
-}
-}
-}
-else
-{
 lean_object* x_116; 
+lean_dec(x_74);
+lean_dec(x_25);
 lean_dec(x_24);
 lean_dec(x_23);
-lean_dec(x_2);
 lean_dec(x_1);
 x_116 = lean_box(0);
 x_4 = x_116;
 goto block_12;
 }
 }
-else
+default: 
 {
 lean_object* x_117; 
+lean_dec(x_25);
+lean_dec(x_24);
 lean_dec(x_23);
 lean_dec(x_2);
 lean_dec(x_1);
@@ -34400,361 +32090,41 @@ x_4 = x_117;
 goto block_12;
 }
 }
-case 5:
+}
+else
 {
 lean_object* x_118; 
+lean_dec(x_24);
+lean_dec(x_23);
 lean_dec(x_2);
-x_118 = lean_ctor_get(x_22, 0);
-lean_inc(x_118);
-if (lean_obj_tag(x_118) == 4)
+lean_dec(x_1);
+x_118 = lean_box(0);
+x_4 = x_118;
+goto block_12;
+}
+}
+else
 {
 lean_object* x_119; 
-x_119 = lean_ctor_get(x_118, 0);
-lean_inc(x_119);
-lean_dec(x_118);
-if (lean_obj_tag(x_119) == 1)
+lean_dec(x_23);
+lean_dec(x_2);
+lean_dec(x_1);
+x_119 = lean_box(0);
+x_4 = x_119;
+goto block_12;
+}
+}
+else
 {
 lean_object* x_120; 
-x_120 = lean_ctor_get(x_119, 0);
-lean_inc(x_120);
-if (lean_obj_tag(x_120) == 1)
-{
-lean_object* x_121; 
-x_121 = lean_ctor_get(x_120, 0);
-lean_inc(x_121);
-if (lean_obj_tag(x_121) == 1)
-{
-lean_object* x_122; 
-x_122 = lean_ctor_get(x_121, 0);
-lean_inc(x_122);
-if (lean_obj_tag(x_122) == 0)
-{
-lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; uint8_t x_128; 
-x_123 = lean_ctor_get(x_22, 1);
-lean_inc(x_123);
-lean_dec(x_22);
-x_124 = lean_ctor_get(x_119, 1);
-lean_inc(x_124);
-lean_dec(x_119);
-x_125 = lean_ctor_get(x_120, 1);
-lean_inc(x_125);
-lean_dec(x_120);
-x_126 = lean_ctor_get(x_121, 1);
-lean_inc(x_126);
-lean_dec(x_121);
-x_127 = l_Lean_mkAppStx___closed__1;
-x_128 = lean_string_dec_eq(x_126, x_127);
-lean_dec(x_126);
-if (x_128 == 0)
-{
-lean_object* x_129; 
-lean_dec(x_125);
-lean_dec(x_124);
-lean_dec(x_123);
-lean_dec(x_1);
-x_129 = lean_box(0);
-x_4 = x_129;
-goto block_12;
-}
-else
-{
-lean_object* x_130; uint8_t x_131; 
-x_130 = l_Lean_mkAppStx___closed__3;
-x_131 = lean_string_dec_eq(x_125, x_130);
-lean_dec(x_125);
-if (x_131 == 0)
-{
-lean_object* x_132; 
-lean_dec(x_124);
-lean_dec(x_123);
-lean_dec(x_1);
-x_132 = lean_box(0);
-x_4 = x_132;
-goto block_12;
-}
-else
-{
-uint8_t x_133; 
-x_133 = lean_string_dec_eq(x_124, x_130);
-lean_dec(x_124);
-if (x_133 == 0)
-{
-lean_object* x_134; 
-lean_dec(x_123);
-lean_dec(x_1);
-x_134 = lean_box(0);
-x_4 = x_134;
-goto block_12;
-}
-else
-{
-if (lean_obj_tag(x_123) == 4)
-{
-lean_object* x_135; 
-x_135 = lean_ctor_get(x_123, 0);
-lean_inc(x_135);
-lean_dec(x_123);
-if (lean_obj_tag(x_135) == 1)
-{
-lean_object* x_136; 
-x_136 = lean_ctor_get(x_135, 0);
-lean_inc(x_136);
-if (lean_obj_tag(x_136) == 1)
-{
-lean_object* x_137; 
-x_137 = lean_ctor_get(x_136, 0);
-lean_inc(x_137);
-if (lean_obj_tag(x_137) == 1)
-{
-lean_object* x_138; 
-x_138 = lean_ctor_get(x_137, 0);
-lean_inc(x_138);
-if (lean_obj_tag(x_138) == 0)
-{
-lean_object* x_139; lean_object* x_140; lean_object* x_141; uint8_t x_142; 
-x_139 = lean_ctor_get(x_135, 1);
-lean_inc(x_139);
-lean_dec(x_135);
-x_140 = lean_ctor_get(x_136, 1);
-lean_inc(x_140);
-lean_dec(x_136);
-x_141 = lean_ctor_get(x_137, 1);
-lean_inc(x_141);
-lean_dec(x_137);
-x_142 = lean_string_dec_eq(x_141, x_127);
-lean_dec(x_141);
-if (x_142 == 0)
-{
-lean_object* x_143; 
-lean_dec(x_140);
-lean_dec(x_139);
-lean_dec(x_1);
-x_143 = lean_box(0);
-x_4 = x_143;
-goto block_12;
-}
-else
-{
-lean_object* x_144; uint8_t x_145; 
-x_144 = l_Lean_Parser_mkParserOfConstantUnsafe___closed__6;
-x_145 = lean_string_dec_eq(x_140, x_144);
-lean_dec(x_140);
-if (x_145 == 0)
-{
-lean_object* x_146; 
-lean_dec(x_139);
-lean_dec(x_1);
-x_146 = lean_box(0);
-x_4 = x_146;
-goto block_12;
-}
-else
-{
-lean_object* x_147; uint8_t x_148; 
-x_147 = l_Lean_Parser_mkParserOfConstantUnsafe___closed__7;
-x_148 = lean_string_dec_eq(x_139, x_147);
-lean_dec(x_139);
-if (x_148 == 0)
-{
-lean_object* x_149; 
-lean_dec(x_1);
-x_149 = lean_box(0);
-x_4 = x_149;
-goto block_12;
-}
-else
-{
-lean_object* x_150; 
-x_150 = lean_eval_const(x_1, x_3);
-lean_dec(x_3);
-lean_dec(x_1);
-if (lean_obj_tag(x_150) == 0)
-{
-uint8_t x_151; 
-x_151 = !lean_is_exclusive(x_150);
-if (x_151 == 0)
-{
-return x_150;
-}
-else
-{
-lean_object* x_152; lean_object* x_153; 
-x_152 = lean_ctor_get(x_150, 0);
-lean_inc(x_152);
-lean_dec(x_150);
-x_153 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_153, 0, x_152);
-return x_153;
-}
-}
-else
-{
-uint8_t x_154; 
-x_154 = !lean_is_exclusive(x_150);
-if (x_154 == 0)
-{
-lean_object* x_155; uint8_t x_156; lean_object* x_157; lean_object* x_158; 
-x_155 = lean_ctor_get(x_150, 0);
-x_156 = 0;
-x_157 = lean_box(x_156);
-x_158 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_158, 0, x_157);
-lean_ctor_set(x_158, 1, x_155);
-lean_ctor_set(x_150, 0, x_158);
-return x_150;
-}
-else
-{
-lean_object* x_159; uint8_t x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; 
-x_159 = lean_ctor_get(x_150, 0);
-lean_inc(x_159);
-lean_dec(x_150);
-x_160 = 0;
-x_161 = lean_box(x_160);
-x_162 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_162, 0, x_161);
-lean_ctor_set(x_162, 1, x_159);
-x_163 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_163, 0, x_162);
-return x_163;
-}
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_164; 
-lean_dec(x_138);
-lean_dec(x_137);
-lean_dec(x_136);
-lean_dec(x_135);
-lean_dec(x_1);
-x_164 = lean_box(0);
-x_4 = x_164;
-goto block_12;
-}
-}
-else
-{
-lean_object* x_165; 
-lean_dec(x_137);
-lean_dec(x_136);
-lean_dec(x_135);
-lean_dec(x_1);
-x_165 = lean_box(0);
-x_4 = x_165;
-goto block_12;
-}
-}
-else
-{
-lean_object* x_166; 
-lean_dec(x_136);
-lean_dec(x_135);
-lean_dec(x_1);
-x_166 = lean_box(0);
-x_4 = x_166;
-goto block_12;
-}
-}
-else
-{
-lean_object* x_167; 
-lean_dec(x_135);
-lean_dec(x_1);
-x_167 = lean_box(0);
-x_4 = x_167;
-goto block_12;
-}
-}
-else
-{
-lean_object* x_168; 
-lean_dec(x_123);
-lean_dec(x_1);
-x_168 = lean_box(0);
-x_4 = x_168;
-goto block_12;
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_169; 
-lean_dec(x_122);
-lean_dec(x_121);
-lean_dec(x_120);
-lean_dec(x_119);
-lean_dec(x_22);
-lean_dec(x_1);
-x_169 = lean_box(0);
-x_4 = x_169;
-goto block_12;
-}
-}
-else
-{
-lean_object* x_170; 
-lean_dec(x_121);
-lean_dec(x_120);
-lean_dec(x_119);
-lean_dec(x_22);
-lean_dec(x_1);
-x_170 = lean_box(0);
-x_4 = x_170;
-goto block_12;
-}
-}
-else
-{
-lean_object* x_171; 
-lean_dec(x_120);
-lean_dec(x_119);
-lean_dec(x_22);
-lean_dec(x_1);
-x_171 = lean_box(0);
-x_4 = x_171;
-goto block_12;
-}
-}
-else
-{
-lean_object* x_172; 
-lean_dec(x_119);
-lean_dec(x_22);
-lean_dec(x_1);
-x_172 = lean_box(0);
-x_4 = x_172;
-goto block_12;
-}
-}
-else
-{
-lean_object* x_173; 
-lean_dec(x_118);
-lean_dec(x_22);
-lean_dec(x_1);
-x_173 = lean_box(0);
-x_4 = x_173;
-goto block_12;
-}
-}
-default: 
-{
-lean_object* x_174; 
 lean_dec(x_22);
 lean_dec(x_2);
 lean_dec(x_1);
-x_174 = lean_box(0);
-x_4 = x_174;
+x_120 = lean_box(0);
+x_4 = x_120;
 goto block_12;
 }
 }
-}
 block_12:
 {
 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; 
@@ -35194,7 +32564,7 @@ lean_inc(x_103);
 lean_dec(x_101);
 x_104 = lean_unbox(x_102);
 lean_dec(x_102);
-x_105 = l_Lean_Parser_addParser(x_104, x_95, x_90, x_91, x_103);
+x_105 = l_Lean_Parser_addParser(x_95, x_90, x_91, x_104, x_103);
 lean_dec(x_91);
 if (lean_obj_tag(x_105) == 0)
 {
@@ -35277,7 +32647,7 @@ lean_inc(x_121);
 lean_dec(x_119);
 x_122 = lean_unbox(x_120);
 lean_dec(x_120);
-x_123 = l_Lean_Parser_addParser(x_122, x_113, x_90, x_91, x_121);
+x_123 = l_Lean_Parser_addParser(x_113, x_90, x_91, x_122, x_121);
 lean_dec(x_91);
 if (lean_obj_tag(x_123) == 0)
 {
@@ -36608,46 +33978,45 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_categoryParserFnImplAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_categoryParserFnImplAux(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_3, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_parserExtension;
-x_7 = l_Lean_PersistentEnvExtension_getState___rarg(x_6, x_5);
-lean_dec(x_5);
-x_8 = lean_ctor_get(x_7, 2);
-lean_inc(x_8);
-lean_dec(x_7);
-x_9 = l_PersistentHashMap_find_x3f___at_Lean_Parser_addLeadingParser___spec__1(x_8, x_1);
-if (lean_obj_tag(x_9) == 0)
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_4 = lean_ctor_get(x_2, 2);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_parserExtension;
+x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_4);
+lean_dec(x_4);
+x_7 = lean_ctor_get(x_6, 2);
+lean_inc(x_7);
+lean_dec(x_6);
+x_8 = l_PersistentHashMap_find_x3f___at_Lean_Parser_addLeadingParser___spec__1(x_7, x_1);
+if (lean_obj_tag(x_8) == 0)
 {
-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_dec(x_3);
+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_dec(x_2);
-x_10 = l_Lean_Name_toString___closed__1;
-x_11 = l_Lean_Name_toStringWithSep___main(x_10, x_1);
-x_12 = l_Lean_Parser_throwUnknownParserCategory___rarg___closed__1;
-x_13 = lean_string_append(x_12, x_11);
-lean_dec(x_11);
-x_14 = l_Char_HasRepr___closed__1;
-x_15 = lean_string_append(x_13, x_14);
-x_16 = l_Lean_Parser_ParserState_mkUnexpectedError(x_4, x_15);
-return x_16;
+x_9 = l_Lean_Name_toString___closed__1;
+x_10 = l_Lean_Name_toStringWithSep___main(x_9, x_1);
+x_11 = l_Lean_Parser_throwUnknownParserCategory___rarg___closed__1;
+x_12 = lean_string_append(x_11, x_10);
+lean_dec(x_10);
+x_13 = l_Char_HasRepr___closed__1;
+x_14 = lean_string_append(x_12, x_13);
+x_15 = l_Lean_Parser_ParserState_mkUnexpectedError(x_3, x_14);
+return x_15;
 }
 else
 {
-lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; 
-x_17 = lean_ctor_get(x_9, 0);
+lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; 
+x_16 = lean_ctor_get(x_8, 0);
+lean_inc(x_16);
+lean_dec(x_8);
+x_17 = lean_ctor_get(x_16, 0);
 lean_inc(x_17);
-lean_dec(x_9);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_ctor_get_uint8(x_17, sizeof(void*)*1);
-lean_dec(x_17);
-x_20 = l_Lean_Parser_prattParser(x_1, x_18, x_19, x_2, x_3, x_4);
-return x_20;
+x_18 = lean_ctor_get_uint8(x_16, sizeof(void*)*1);
+lean_dec(x_16);
+x_19 = l_Lean_Parser_prattParser(x_1, x_17, x_18, x_2, x_3);
+return x_19;
 }
 }
 }
@@ -36685,83 +34054,79 @@ return x_7;
 }
 }
 }
-lean_object* l_Lean_Parser_categoryParserFnImpl(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_categoryParserFnImpl(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_5; uint8_t x_6; 
-x_5 = l_Lean_Parser_termParser___closed__2;
-x_6 = lean_name_eq(x_1, x_5);
-if (x_6 == 0)
+lean_object* x_4; uint8_t x_5; 
+x_4 = l_Lean_Parser_termParser___closed__2;
+x_5 = lean_name_eq(x_1, x_4);
+if (x_5 == 0)
 {
-lean_object* x_7; lean_object* x_8; uint8_t x_9; uint8_t 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_6; lean_object* x_7; uint8_t 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_inc(x_1);
-x_7 = l___private_Init_Lean_Parser_Parser_26__catNameToString(x_1);
-x_8 = lean_box(0);
-x_9 = 0;
-x_10 = 0;
-x_11 = l_Lean_Parser_mkAntiquot(x_9, x_7, x_8, x_10);
-lean_dec(x_7);
-x_12 = lean_ctor_get(x_11, 1);
-lean_inc(x_12);
+x_6 = l___private_Init_Lean_Parser_Parser_26__catNameToString(x_1);
+x_7 = lean_box(0);
+x_8 = 0;
+x_9 = l_Lean_Parser_mkAntiquot(x_6, x_7, x_8);
+lean_dec(x_6);
+x_10 = lean_ctor_get(x_9, 1);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_3, 0);
+lean_inc(x_11);
+x_12 = lean_array_get_size(x_11);
 lean_dec(x_11);
-x_13 = lean_ctor_get(x_4, 0);
+x_13 = lean_ctor_get(x_3, 1);
 lean_inc(x_13);
-x_14 = lean_array_get_size(x_13);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_4, 1);
-lean_inc(x_15);
-lean_inc(x_3);
 lean_inc(x_2);
-x_16 = lean_apply_3(x_12, x_2, x_3, x_4);
-x_17 = lean_ctor_get(x_16, 3);
-lean_inc(x_17);
-if (lean_obj_tag(x_17) == 0)
-{
-lean_dec(x_15);
-lean_dec(x_14);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_16;
-}
-else
-{
-lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-lean_dec(x_17);
-x_19 = lean_ctor_get(x_16, 1);
-lean_inc(x_19);
-x_20 = lean_nat_dec_eq(x_19, x_15);
-lean_dec(x_19);
-if (x_20 == 0)
-{
-lean_dec(x_18);
-lean_dec(x_15);
-lean_dec(x_14);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_16;
-}
-else
-{
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_14 = lean_apply_2(x_10, x_2, x_3);
+x_15 = lean_ctor_get(x_14, 3);
 lean_inc(x_15);
-x_21 = l_Lean_Parser_ParserState_restore(x_16, x_14, x_15);
-lean_dec(x_14);
-x_22 = l_Lean_Parser_categoryParserFnImplAux(x_1, x_2, x_3, x_21);
-x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_18, x_15);
+if (lean_obj_tag(x_15) == 0)
+{
+lean_dec(x_13);
+lean_dec(x_12);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_14;
+}
+else
+{
+lean_object* x_16; lean_object* x_17; uint8_t x_18; 
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
 lean_dec(x_15);
-return x_23;
+x_17 = lean_ctor_get(x_14, 1);
+lean_inc(x_17);
+x_18 = lean_nat_dec_eq(x_17, x_13);
+lean_dec(x_17);
+if (x_18 == 0)
+{
+lean_dec(x_16);
+lean_dec(x_13);
+lean_dec(x_12);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_14;
+}
+else
+{
+lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+lean_inc(x_13);
+x_19 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13);
+lean_dec(x_12);
+x_20 = l_Lean_Parser_categoryParserFnImplAux(x_1, x_2, x_19);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_16, x_13);
+lean_dec(x_13);
+return x_21;
 }
 }
 }
 else
 {
-lean_object* x_24; 
-x_24 = l_Lean_Parser_categoryParserFnImplAux(x_1, x_2, x_3, x_4);
-return x_24;
+lean_object* x_22; 
+x_22 = l_Lean_Parser_categoryParserFnImplAux(x_1, x_2, x_3);
+return x_22;
 }
 }
 }
@@ -36769,7 +34134,7 @@ lean_object* _init_l_Lean_Parser_setCategoryParserFnRef___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParserFnImpl), 4, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParserFnImpl), 3, 0);
 return x_1;
 }
 }
@@ -37269,13 +34634,15 @@ return x_4;
 lean_object* l_Lean_Parser_mkParserContext(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; 
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_3 = l_Lean_Parser_getTokenTable(x_1);
-x_4 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_1);
-lean_ctor_set(x_4, 2, x_3);
-return x_4;
+x_4 = lean_unsigned_to_nat(0u);
+x_5 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_5, 0, x_2);
+lean_ctor_set(x_5, 1, x_4);
+lean_ctor_set(x_5, 2, x_1);
+lean_ctor_set(x_5, 3, x_3);
+return x_5;
 }
 }
 lean_object* l_Lean_Parser_mkParserState(lean_object* x_1) {
@@ -37324,7 +34691,7 @@ return x_9;
 }
 else
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; 
 x_10 = lean_ctor_get(x_8, 0);
 lean_inc(x_10);
 lean_dec(x_8);
@@ -37338,32 +34705,31 @@ x_15 = lean_ctor_get(x_10, 0);
 lean_inc(x_15);
 x_16 = lean_ctor_get_uint8(x_10, sizeof(void*)*1);
 lean_dec(x_10);
-x_17 = lean_unsigned_to_nat(0u);
 lean_inc(x_12);
-x_18 = l_Lean_Parser_prattParser(x_2, x_15, x_16, x_17, x_12, x_14);
-x_19 = lean_ctor_get(x_18, 3);
-lean_inc(x_19);
-if (lean_obj_tag(x_19) == 0)
+x_17 = l_Lean_Parser_prattParser(x_2, x_15, x_16, x_12, x_14);
+x_18 = lean_ctor_get(x_17, 3);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+lean_object* x_19; lean_object* x_20; lean_object* x_21; 
 lean_dec(x_12);
-x_20 = lean_ctor_get(x_18, 0);
-lean_inc(x_20);
-lean_dec(x_18);
-x_21 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_20);
-lean_dec(x_20);
-x_22 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_22, 0, x_21);
-return x_22;
+x_19 = lean_ctor_get(x_17, 0);
+lean_inc(x_19);
+lean_dec(x_17);
+x_20 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_19);
+lean_dec(x_19);
+x_21 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_21, 0, x_20);
+return x_21;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-lean_dec(x_19);
-x_23 = l_Lean_Parser_ParserState_toErrorMsg(x_12, x_18);
-x_24 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_24, 0, x_23);
-return x_24;
+lean_object* x_22; lean_object* x_23; 
+lean_dec(x_18);
+x_22 = l_Lean_Parser_ParserState_toErrorMsg(x_12, x_17);
+x_23 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_23, 0, x_22);
+return x_23;
 }
 }
 }
@@ -37689,8 +35055,7 @@ lean_inc(x_30);
 lean_dec(x_27);
 x_31 = l_Lean_ConstantInfo_type(x_30);
 lean_dec(x_30);
-switch (lean_obj_tag(x_31)) {
-case 4:
+if (lean_obj_tag(x_31) == 4)
 {
 lean_object* x_32; 
 x_32 = lean_ctor_get(x_31, 0);
@@ -37839,324 +35204,17 @@ x_17 = x_54;
 goto block_26;
 }
 }
-case 5:
+else
 {
 lean_object* x_55; 
-x_55 = lean_ctor_get(x_31, 0);
-lean_inc(x_55);
-if (lean_obj_tag(x_55) == 4)
-{
-lean_object* x_56; 
-x_56 = lean_ctor_get(x_55, 0);
-lean_inc(x_56);
-lean_dec(x_55);
-if (lean_obj_tag(x_56) == 1)
-{
-lean_object* x_57; 
-x_57 = lean_ctor_get(x_56, 0);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 1)
-{
-lean_object* x_58; 
-x_58 = lean_ctor_get(x_57, 0);
-lean_inc(x_58);
-if (lean_obj_tag(x_58) == 1)
-{
-lean_object* x_59; 
-x_59 = lean_ctor_get(x_58, 0);
-lean_inc(x_59);
-if (lean_obj_tag(x_59) == 0)
-{
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; 
-x_60 = lean_ctor_get(x_31, 1);
-lean_inc(x_60);
-lean_dec(x_31);
-x_61 = lean_ctor_get(x_56, 1);
-lean_inc(x_61);
-lean_dec(x_56);
-x_62 = lean_ctor_get(x_57, 1);
-lean_inc(x_62);
-lean_dec(x_57);
-x_63 = lean_ctor_get(x_58, 1);
-lean_inc(x_63);
-lean_dec(x_58);
-x_64 = l_Lean_mkAppStx___closed__1;
-x_65 = lean_string_dec_eq(x_63, x_64);
-lean_dec(x_63);
-if (x_65 == 0)
-{
-lean_object* x_66; 
-lean_dec(x_62);
-lean_dec(x_61);
-lean_dec(x_60);
-lean_dec(x_3);
-lean_dec(x_2);
-x_66 = lean_box(0);
-x_17 = x_66;
-goto block_26;
-}
-else
-{
-lean_object* x_67; uint8_t x_68; 
-x_67 = l_Lean_mkAppStx___closed__3;
-x_68 = lean_string_dec_eq(x_62, x_67);
-lean_dec(x_62);
-if (x_68 == 0)
-{
-lean_object* x_69; 
-lean_dec(x_61);
-lean_dec(x_60);
-lean_dec(x_3);
-lean_dec(x_2);
-x_69 = lean_box(0);
-x_17 = x_69;
-goto block_26;
-}
-else
-{
-uint8_t x_70; 
-x_70 = lean_string_dec_eq(x_61, x_67);
-lean_dec(x_61);
-if (x_70 == 0)
-{
-lean_object* x_71; 
-lean_dec(x_60);
-lean_dec(x_3);
-lean_dec(x_2);
-x_71 = lean_box(0);
-x_17 = x_71;
-goto block_26;
-}
-else
-{
-if (lean_obj_tag(x_60) == 4)
-{
-lean_object* x_72; 
-x_72 = lean_ctor_get(x_60, 0);
-lean_inc(x_72);
-lean_dec(x_60);
-if (lean_obj_tag(x_72) == 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_74; 
-x_74 = lean_ctor_get(x_73, 0);
-lean_inc(x_74);
-if (lean_obj_tag(x_74) == 1)
-{
-lean_object* x_75; 
-x_75 = lean_ctor_get(x_74, 0);
-lean_inc(x_75);
-if (lean_obj_tag(x_75) == 0)
-{
-lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; 
-x_76 = lean_ctor_get(x_72, 1);
-lean_inc(x_76);
-lean_dec(x_72);
-x_77 = lean_ctor_get(x_73, 1);
-lean_inc(x_77);
-lean_dec(x_73);
-x_78 = lean_ctor_get(x_74, 1);
-lean_inc(x_78);
-lean_dec(x_74);
-x_79 = lean_string_dec_eq(x_78, x_64);
-lean_dec(x_78);
-if (x_79 == 0)
-{
-lean_object* x_80; 
-lean_dec(x_77);
-lean_dec(x_76);
-lean_dec(x_3);
-lean_dec(x_2);
-x_80 = lean_box(0);
-x_17 = x_80;
-goto block_26;
-}
-else
-{
-lean_object* x_81; uint8_t x_82; 
-x_81 = l_Lean_Parser_mkParserOfConstantUnsafe___closed__6;
-x_82 = lean_string_dec_eq(x_77, x_81);
-lean_dec(x_77);
-if (x_82 == 0)
-{
-lean_object* x_83; 
-lean_dec(x_76);
-lean_dec(x_3);
-lean_dec(x_2);
-x_83 = lean_box(0);
-x_17 = x_83;
-goto block_26;
-}
-else
-{
-lean_object* x_84; uint8_t x_85; 
-x_84 = l_Lean_Parser_mkParserOfConstantUnsafe___closed__7;
-x_85 = lean_string_dec_eq(x_76, x_84);
-lean_dec(x_76);
-if (x_85 == 0)
-{
-lean_object* x_86; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_86 = lean_box(0);
-x_17 = x_86;
-goto block_26;
-}
-else
-{
-lean_object* x_87; 
-x_87 = l_Lean_Parser_declareLeadingBuiltinParser(x_3, x_2, x_4, x_7);
-return x_87;
-}
-}
-}
-}
-else
-{
-lean_object* x_88; 
-lean_dec(x_75);
-lean_dec(x_74);
-lean_dec(x_73);
-lean_dec(x_72);
-lean_dec(x_3);
-lean_dec(x_2);
-x_88 = lean_box(0);
-x_17 = x_88;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_89; 
-lean_dec(x_74);
-lean_dec(x_73);
-lean_dec(x_72);
-lean_dec(x_3);
-lean_dec(x_2);
-x_89 = lean_box(0);
-x_17 = x_89;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_90; 
-lean_dec(x_73);
-lean_dec(x_72);
-lean_dec(x_3);
-lean_dec(x_2);
-x_90 = lean_box(0);
-x_17 = x_90;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_91; 
-lean_dec(x_72);
-lean_dec(x_3);
-lean_dec(x_2);
-x_91 = lean_box(0);
-x_17 = x_91;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_92; 
-lean_dec(x_60);
-lean_dec(x_3);
-lean_dec(x_2);
-x_92 = lean_box(0);
-x_17 = x_92;
-goto block_26;
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_93; 
-lean_dec(x_59);
-lean_dec(x_58);
-lean_dec(x_57);
-lean_dec(x_56);
 lean_dec(x_31);
 lean_dec(x_3);
 lean_dec(x_2);
-x_93 = lean_box(0);
-x_17 = x_93;
+x_55 = lean_box(0);
+x_17 = x_55;
 goto block_26;
 }
 }
-else
-{
-lean_object* x_94; 
-lean_dec(x_58);
-lean_dec(x_57);
-lean_dec(x_56);
-lean_dec(x_31);
-lean_dec(x_3);
-lean_dec(x_2);
-x_94 = lean_box(0);
-x_17 = x_94;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_95; 
-lean_dec(x_57);
-lean_dec(x_56);
-lean_dec(x_31);
-lean_dec(x_3);
-lean_dec(x_2);
-x_95 = lean_box(0);
-x_17 = x_95;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_96; 
-lean_dec(x_56);
-lean_dec(x_31);
-lean_dec(x_3);
-lean_dec(x_2);
-x_96 = lean_box(0);
-x_17 = x_96;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_97; 
-lean_dec(x_55);
-lean_dec(x_31);
-lean_dec(x_3);
-lean_dec(x_2);
-x_97 = lean_box(0);
-x_17 = x_97;
-goto block_26;
-}
-}
-default: 
-{
-lean_object* x_98; 
-lean_dec(x_31);
-lean_dec(x_3);
-lean_dec(x_2);
-x_98 = lean_box(0);
-x_17 = x_98;
-goto block_26;
-}
-}
-}
 block_26:
 {
 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; 
@@ -38179,23 +35237,23 @@ return x_25;
 }
 else
 {
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; 
+lean_object* x_56; lean_object* x_57; 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_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_99 = l_Lean_Name_toString___closed__1;
-x_100 = l_Lean_Name_toStringWithSep___main(x_99, x_1);
-x_101 = l_Lean_registerTagAttribute___lambda__4___closed__1;
-x_102 = lean_string_append(x_101, x_100);
-lean_dec(x_100);
-x_103 = l_Lean_registerTagAttribute___lambda__4___closed__5;
-x_104 = lean_string_append(x_102, x_103);
-x_105 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_105, 0, x_104);
-x_106 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_106, 0, x_105);
-lean_ctor_set(x_106, 1, x_7);
-return x_106;
+x_56 = l_Lean_Name_toString___closed__1;
+x_57 = l_Lean_Name_toStringWithSep___main(x_56, x_1);
+x_58 = l_Lean_registerTagAttribute___lambda__4___closed__1;
+x_59 = lean_string_append(x_58, x_57);
+lean_dec(x_57);
+x_60 = l_Lean_registerTagAttribute___lambda__4___closed__5;
+x_61 = lean_string_append(x_59, x_60);
+x_62 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_62, 0, x_61);
+x_63 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_63, 0, x_62);
+lean_ctor_set(x_63, 1, x_7);
+return x_63;
 }
 }
 }
@@ -38525,7 +35583,7 @@ lean_dec(x_28);
 x_30 = lean_unbox(x_17);
 lean_inc(x_18);
 lean_inc(x_2);
-x_31 = l_Lean_Parser_addParser(x_30, x_11, x_2, x_4, x_18);
+x_31 = l_Lean_Parser_addParser(x_11, x_2, x_4, x_30, x_18);
 if (lean_obj_tag(x_31) == 0)
 {
 lean_object* x_32; lean_object* x_33; 
@@ -38577,7 +35635,7 @@ lean_dec(x_41);
 x_43 = lean_unbox(x_17);
 lean_inc(x_18);
 lean_inc(x_2);
-x_44 = l_Lean_Parser_addParser(x_43, x_11, x_2, x_4, x_18);
+x_44 = l_Lean_Parser_addParser(x_11, x_2, x_4, x_43, x_18);
 if (lean_obj_tag(x_44) == 0)
 {
 lean_object* x_45; lean_object* x_46; lean_object* x_47; 
@@ -39089,14 +36147,6 @@ lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_fieldIdx___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Lean_Parser_fieldIdxFn(x_2, x_3);
-return x_4;
-}
-}
 lean_object* _init_l_Lean_Parser_fieldIdx___closed__1() {
 _start:
 {
@@ -39110,65 +36160,77 @@ return x_2;
 lean_object* _init_l_Lean_Parser_fieldIdx___closed__2() {
 _start:
 {
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_fieldIdxKind___closed__1;
+x_2 = l_Lean_Parser_fieldIdx___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
+}
+}
+lean_object* _init_l_Lean_Parser_fieldIdx___closed__3() {
+_start:
+{
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_fieldIdxKind___closed__1;
 x_2 = l_Lean_Parser_mkAtomicInfo(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_fieldIdx___closed__3() {
+lean_object* _init_l_Lean_Parser_fieldIdx___closed__4() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_fieldIdx___lambda__1___boxed), 3, 0);
-return x_1;
-}
-}
-lean_object* l_Lean_Parser_fieldIdx(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; lean_object* x_3; uint8_t 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; 
-x_2 = l_Lean_fieldIdxKind___closed__1;
-x_3 = l_Lean_Parser_fieldIdx___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = l_Lean_Parser_fieldIdx___closed__2;
-x_8 = l_Lean_Parser_orelseInfo(x_6, x_7);
-x_9 = lean_ctor_get(x_5, 1);
-lean_inc(x_9);
-lean_dec(x_5);
-x_10 = l_Lean_Parser_fieldIdx___closed__3;
-x_11 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 2);
-lean_closure_set(x_11, 0, x_9);
-lean_closure_set(x_11, 1, x_10);
-x_12 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_12, 0, x_8);
-lean_ctor_set(x_12, 1, x_11);
-return x_12;
-}
-}
-lean_object* l_Lean_Parser_fieldIdx___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Lean_Parser_fieldIdx___lambda__1(x_1, x_2, x_3);
-lean_dec(x_2);
-lean_dec(x_1);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_fieldIdx___closed__2;
+x_2 = lean_ctor_get(x_1, 0);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_fieldIdx___closed__3;
+x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_fieldIdx___boxed(lean_object* x_1) {
+lean_object* _init_l_Lean_Parser_fieldIdx___closed__5() {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_fieldIdx(x_2);
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_fieldIdxFn___boxed), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_fieldIdx___closed__6() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_fieldIdx___closed__2;
+x_2 = lean_ctor_get(x_1, 1);
+lean_inc(x_2);
+x_3 = l_Lean_Parser_fieldIdx___closed__5;
+x_4 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn), 4, 2);
+lean_closure_set(x_4, 0, x_2);
+lean_closure_set(x_4, 1, x_3);
+return x_4;
+}
+}
+lean_object* _init_l_Lean_Parser_fieldIdx___closed__7() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_fieldIdx___closed__4;
+x_2 = l_Lean_Parser_fieldIdx___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);
 return x_3;
 }
 }
+lean_object* _init_l_Lean_Parser_fieldIdx() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Parser_fieldIdx___closed__7;
+return x_1;
+}
+}
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_foldArgsM___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
@@ -40224,6 +37286,10 @@ l_Lean_Parser_Parser_inhabited___closed__1 = _init_l_Lean_Parser_Parser_inhabite
 lean_mark_persistent(l_Lean_Parser_Parser_inhabited___closed__1);
 l_Lean_Parser_Parser_inhabited___closed__2 = _init_l_Lean_Parser_Parser_inhabited___closed__2();
 lean_mark_persistent(l_Lean_Parser_Parser_inhabited___closed__2);
+l_Lean_Parser_Parser_inhabited___closed__3 = _init_l_Lean_Parser_Parser_inhabited___closed__3();
+lean_mark_persistent(l_Lean_Parser_Parser_inhabited___closed__3);
+l_Lean_Parser_Parser_inhabited = _init_l_Lean_Parser_Parser_inhabited();
+lean_mark_persistent(l_Lean_Parser_Parser_inhabited);
 l_Lean_Parser_epsilonInfo___closed__1 = _init_l_Lean_Parser_epsilonInfo___closed__1();
 lean_mark_persistent(l_Lean_Parser_epsilonInfo___closed__1);
 l_Lean_Parser_epsilonInfo___closed__2 = _init_l_Lean_Parser_epsilonInfo___closed__2();
@@ -40232,8 +37298,16 @@ l_Lean_Parser_epsilonInfo___closed__3 = _init_l_Lean_Parser_epsilonInfo___closed
 lean_mark_persistent(l_Lean_Parser_epsilonInfo___closed__3);
 l_Lean_Parser_epsilonInfo = _init_l_Lean_Parser_epsilonInfo();
 lean_mark_persistent(l_Lean_Parser_epsilonInfo);
-l_Lean_Parser_checkLeadingFn___closed__1 = _init_l_Lean_Parser_checkLeadingFn___closed__1();
-lean_mark_persistent(l_Lean_Parser_checkLeadingFn___closed__1);
+l_Lean_Parser_checkStackTopFn___closed__1 = _init_l_Lean_Parser_checkStackTopFn___closed__1();
+lean_mark_persistent(l_Lean_Parser_checkStackTopFn___closed__1);
+l_Lean_Parser_hashAndthen___closed__1 = _init_l_Lean_Parser_hashAndthen___closed__1();
+lean_mark_persistent(l_Lean_Parser_hashAndthen___closed__1);
+l_Lean_Parser_hashAndthen = _init_l_Lean_Parser_hashAndthen();
+lean_mark_persistent(l_Lean_Parser_hashAndthen);
+l_Lean_Parser_hashOrelse___closed__1 = _init_l_Lean_Parser_hashOrelse___closed__1();
+lean_mark_persistent(l_Lean_Parser_hashOrelse___closed__1);
+l_Lean_Parser_hashOrelse = _init_l_Lean_Parser_hashOrelse();
+lean_mark_persistent(l_Lean_Parser_hashOrelse);
 l_Lean_Parser_manyAux___main___closed__1 = _init_l_Lean_Parser_manyAux___main___closed__1();
 lean_mark_persistent(l_Lean_Parser_manyAux___main___closed__1);
 l_Lean_Parser_hexDigitFn___closed__1 = _init_l_Lean_Parser_hexDigitFn___closed__1();
@@ -40272,8 +37346,8 @@ l_Lean_Parser_symbolNoWsFn___closed__1 = _init_l_Lean_Parser_symbolNoWsFn___clos
 lean_mark_persistent(l_Lean_Parser_symbolNoWsFn___closed__1);
 l_Lean_Parser_unicodeSymbolInfo___closed__1 = _init_l_Lean_Parser_unicodeSymbolInfo___closed__1();
 lean_mark_persistent(l_Lean_Parser_unicodeSymbolInfo___closed__1);
-l_Lean_Parser_unicodeSymbolFn___rarg___closed__1 = _init_l_Lean_Parser_unicodeSymbolFn___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_unicodeSymbolFn___rarg___closed__1);
+l_Lean_Parser_unicodeSymbolFn___closed__1 = _init_l_Lean_Parser_unicodeSymbolFn___closed__1();
+lean_mark_persistent(l_Lean_Parser_unicodeSymbolFn___closed__1);
 l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__1 = _init_l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__1();
 lean_mark_persistent(l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__1);
 l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__2 = _init_l_Lean_Parser_unicodeSymbolCheckPrecFn___closed__2();
@@ -40284,26 +37358,60 @@ l_Lean_Parser_mkAtomicInfo___closed__2 = _init_l_Lean_Parser_mkAtomicInfo___clos
 lean_mark_persistent(l_Lean_Parser_mkAtomicInfo___closed__2);
 l_Lean_Parser_numLitNoAntiquot___closed__1 = _init_l_Lean_Parser_numLitNoAntiquot___closed__1();
 lean_mark_persistent(l_Lean_Parser_numLitNoAntiquot___closed__1);
-l_Lean_Parser_strLitFn___rarg___closed__1 = _init_l_Lean_Parser_strLitFn___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_strLitFn___rarg___closed__1);
+l_Lean_Parser_numLitNoAntiquot___closed__2 = _init_l_Lean_Parser_numLitNoAntiquot___closed__2();
+lean_mark_persistent(l_Lean_Parser_numLitNoAntiquot___closed__2);
+l_Lean_Parser_numLitNoAntiquot___closed__3 = _init_l_Lean_Parser_numLitNoAntiquot___closed__3();
+lean_mark_persistent(l_Lean_Parser_numLitNoAntiquot___closed__3);
+l_Lean_Parser_numLitNoAntiquot = _init_l_Lean_Parser_numLitNoAntiquot();
+lean_mark_persistent(l_Lean_Parser_numLitNoAntiquot);
+l_Lean_Parser_strLitFn___closed__1 = _init_l_Lean_Parser_strLitFn___closed__1();
+lean_mark_persistent(l_Lean_Parser_strLitFn___closed__1);
 l_Lean_Parser_strLitNoAntiquot___closed__1 = _init_l_Lean_Parser_strLitNoAntiquot___closed__1();
 lean_mark_persistent(l_Lean_Parser_strLitNoAntiquot___closed__1);
-l_Lean_Parser_charLitFn___rarg___closed__1 = _init_l_Lean_Parser_charLitFn___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_charLitFn___rarg___closed__1);
+l_Lean_Parser_strLitNoAntiquot___closed__2 = _init_l_Lean_Parser_strLitNoAntiquot___closed__2();
+lean_mark_persistent(l_Lean_Parser_strLitNoAntiquot___closed__2);
+l_Lean_Parser_strLitNoAntiquot___closed__3 = _init_l_Lean_Parser_strLitNoAntiquot___closed__3();
+lean_mark_persistent(l_Lean_Parser_strLitNoAntiquot___closed__3);
+l_Lean_Parser_strLitNoAntiquot = _init_l_Lean_Parser_strLitNoAntiquot();
+lean_mark_persistent(l_Lean_Parser_strLitNoAntiquot);
+l_Lean_Parser_charLitFn___closed__1 = _init_l_Lean_Parser_charLitFn___closed__1();
+lean_mark_persistent(l_Lean_Parser_charLitFn___closed__1);
 l_Lean_Parser_charLitNoAntiquot___closed__1 = _init_l_Lean_Parser_charLitNoAntiquot___closed__1();
 lean_mark_persistent(l_Lean_Parser_charLitNoAntiquot___closed__1);
-l_Lean_Parser_nameLitFn___rarg___closed__1 = _init_l_Lean_Parser_nameLitFn___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_nameLitFn___rarg___closed__1);
+l_Lean_Parser_charLitNoAntiquot___closed__2 = _init_l_Lean_Parser_charLitNoAntiquot___closed__2();
+lean_mark_persistent(l_Lean_Parser_charLitNoAntiquot___closed__2);
+l_Lean_Parser_charLitNoAntiquot___closed__3 = _init_l_Lean_Parser_charLitNoAntiquot___closed__3();
+lean_mark_persistent(l_Lean_Parser_charLitNoAntiquot___closed__3);
+l_Lean_Parser_charLitNoAntiquot = _init_l_Lean_Parser_charLitNoAntiquot();
+lean_mark_persistent(l_Lean_Parser_charLitNoAntiquot);
+l_Lean_Parser_nameLitFn___closed__1 = _init_l_Lean_Parser_nameLitFn___closed__1();
+lean_mark_persistent(l_Lean_Parser_nameLitFn___closed__1);
 l_Lean_Parser_nameLitNoAntiquot___closed__1 = _init_l_Lean_Parser_nameLitNoAntiquot___closed__1();
 lean_mark_persistent(l_Lean_Parser_nameLitNoAntiquot___closed__1);
-l_Lean_Parser_identFn___rarg___closed__1 = _init_l_Lean_Parser_identFn___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_identFn___rarg___closed__1);
+l_Lean_Parser_nameLitNoAntiquot___closed__2 = _init_l_Lean_Parser_nameLitNoAntiquot___closed__2();
+lean_mark_persistent(l_Lean_Parser_nameLitNoAntiquot___closed__2);
+l_Lean_Parser_nameLitNoAntiquot___closed__3 = _init_l_Lean_Parser_nameLitNoAntiquot___closed__3();
+lean_mark_persistent(l_Lean_Parser_nameLitNoAntiquot___closed__3);
+l_Lean_Parser_nameLitNoAntiquot = _init_l_Lean_Parser_nameLitNoAntiquot();
+lean_mark_persistent(l_Lean_Parser_nameLitNoAntiquot);
+l_Lean_Parser_identFn___closed__1 = _init_l_Lean_Parser_identFn___closed__1();
+lean_mark_persistent(l_Lean_Parser_identFn___closed__1);
 l_Lean_Parser_identNoAntiquot___closed__1 = _init_l_Lean_Parser_identNoAntiquot___closed__1();
 lean_mark_persistent(l_Lean_Parser_identNoAntiquot___closed__1);
+l_Lean_Parser_identNoAntiquot___closed__2 = _init_l_Lean_Parser_identNoAntiquot___closed__2();
+lean_mark_persistent(l_Lean_Parser_identNoAntiquot___closed__2);
+l_Lean_Parser_identNoAntiquot___closed__3 = _init_l_Lean_Parser_identNoAntiquot___closed__3();
+lean_mark_persistent(l_Lean_Parser_identNoAntiquot___closed__3);
+l_Lean_Parser_identNoAntiquot = _init_l_Lean_Parser_identNoAntiquot();
+lean_mark_persistent(l_Lean_Parser_identNoAntiquot);
 l_Lean_Parser_rawIdentNoAntiquot___closed__1 = _init_l_Lean_Parser_rawIdentNoAntiquot___closed__1();
 lean_mark_persistent(l_Lean_Parser_rawIdentNoAntiquot___closed__1);
-l_Lean_Parser_identEqFn___rarg___closed__1 = _init_l_Lean_Parser_identEqFn___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_identEqFn___rarg___closed__1);
+l_Lean_Parser_rawIdentNoAntiquot___closed__2 = _init_l_Lean_Parser_rawIdentNoAntiquot___closed__2();
+lean_mark_persistent(l_Lean_Parser_rawIdentNoAntiquot___closed__2);
+l_Lean_Parser_rawIdentNoAntiquot = _init_l_Lean_Parser_rawIdentNoAntiquot();
+lean_mark_persistent(l_Lean_Parser_rawIdentNoAntiquot);
+l_Lean_Parser_identEqFn___closed__1 = _init_l_Lean_Parser_identEqFn___closed__1();
+lean_mark_persistent(l_Lean_Parser_identEqFn___closed__1);
 l_Lean_Parser_quotedSymbolFn___closed__1 = _init_l_Lean_Parser_quotedSymbolFn___closed__1();
 lean_mark_persistent(l_Lean_Parser_quotedSymbolFn___closed__1);
 l_Lean_Parser_quotedSymbolFn___closed__2 = _init_l_Lean_Parser_quotedSymbolFn___closed__2();
@@ -40314,8 +37422,20 @@ l_Lean_Parser_quotedSymbolFn___closed__4 = _init_l_Lean_Parser_quotedSymbolFn___
 lean_mark_persistent(l_Lean_Parser_quotedSymbolFn___closed__4);
 l_Lean_Parser_quotedSymbolFn___closed__5 = _init_l_Lean_Parser_quotedSymbolFn___closed__5();
 lean_mark_persistent(l_Lean_Parser_quotedSymbolFn___closed__5);
-l_Lean_Parser_unquotedSymbolFn___rarg___closed__1 = _init_l_Lean_Parser_unquotedSymbolFn___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_unquotedSymbolFn___rarg___closed__1);
+l_Lean_Parser_quotedSymbol___closed__1 = _init_l_Lean_Parser_quotedSymbol___closed__1();
+lean_mark_persistent(l_Lean_Parser_quotedSymbol___closed__1);
+l_Lean_Parser_quotedSymbol___closed__2 = _init_l_Lean_Parser_quotedSymbol___closed__2();
+lean_mark_persistent(l_Lean_Parser_quotedSymbol___closed__2);
+l_Lean_Parser_quotedSymbol = _init_l_Lean_Parser_quotedSymbol();
+lean_mark_persistent(l_Lean_Parser_quotedSymbol);
+l_Lean_Parser_unquotedSymbolFn___closed__1 = _init_l_Lean_Parser_unquotedSymbolFn___closed__1();
+lean_mark_persistent(l_Lean_Parser_unquotedSymbolFn___closed__1);
+l_Lean_Parser_unquotedSymbol___closed__1 = _init_l_Lean_Parser_unquotedSymbol___closed__1();
+lean_mark_persistent(l_Lean_Parser_unquotedSymbol___closed__1);
+l_Lean_Parser_unquotedSymbol___closed__2 = _init_l_Lean_Parser_unquotedSymbol___closed__2();
+lean_mark_persistent(l_Lean_Parser_unquotedSymbol___closed__2);
+l_Lean_Parser_unquotedSymbol = _init_l_Lean_Parser_unquotedSymbol();
+lean_mark_persistent(l_Lean_Parser_unquotedSymbol);
 l_Lean_Parser_longestMatchFn___closed__1 = _init_l_Lean_Parser_longestMatchFn___closed__1();
 lean_mark_persistent(l_Lean_Parser_longestMatchFn___closed__1);
 l_Lean_Parser_anyOfFn___main___closed__1 = _init_l_Lean_Parser_anyOfFn___main___closed__1();
@@ -40354,24 +37474,68 @@ l_Lean_Parser_termParser___closed__1 = _init_l_Lean_Parser_termParser___closed__
 lean_mark_persistent(l_Lean_Parser_termParser___closed__1);
 l_Lean_Parser_termParser___closed__2 = _init_l_Lean_Parser_termParser___closed__2();
 lean_mark_persistent(l_Lean_Parser_termParser___closed__2);
-l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__1);
-l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__2);
-l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__3 = _init_l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__3();
-lean_mark_persistent(l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__3);
-l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__4 = _init_l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__4();
-lean_mark_persistent(l_Lean_Parser_dollarSymbol___elambda__1___rarg___closed__4);
+l_Lean_Parser_dollarSymbol___elambda__1___closed__1 = _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_dollarSymbol___elambda__1___closed__1);
+l_Lean_Parser_dollarSymbol___elambda__1___closed__2 = _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_dollarSymbol___elambda__1___closed__2);
+l_Lean_Parser_dollarSymbol___elambda__1___closed__3 = _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__3();
+lean_mark_persistent(l_Lean_Parser_dollarSymbol___elambda__1___closed__3);
+l_Lean_Parser_dollarSymbol___elambda__1___closed__4 = _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__4();
+lean_mark_persistent(l_Lean_Parser_dollarSymbol___elambda__1___closed__4);
 l_Lean_Parser_dollarSymbol___closed__1 = _init_l_Lean_Parser_dollarSymbol___closed__1();
 lean_mark_persistent(l_Lean_Parser_dollarSymbol___closed__1);
 l_Lean_Parser_dollarSymbol___closed__2 = _init_l_Lean_Parser_dollarSymbol___closed__2();
 lean_mark_persistent(l_Lean_Parser_dollarSymbol___closed__2);
-l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg___closed__1 = _init_l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg___closed__1();
-lean_mark_persistent(l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___rarg___closed__1);
+l_Lean_Parser_dollarSymbol___closed__3 = _init_l_Lean_Parser_dollarSymbol___closed__3();
+lean_mark_persistent(l_Lean_Parser_dollarSymbol___closed__3);
+l_Lean_Parser_dollarSymbol___closed__4 = _init_l_Lean_Parser_dollarSymbol___closed__4();
+lean_mark_persistent(l_Lean_Parser_dollarSymbol___closed__4);
+l_Lean_Parser_dollarSymbol = _init_l_Lean_Parser_dollarSymbol();
+lean_mark_persistent(l_Lean_Parser_dollarSymbol);
+l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___closed__1 = _init_l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___closed__1();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_12__noImmediateColon___elambda__1___closed__1);
+l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__1 = _init_l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__1();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__1);
+l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__2 = _init_l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__2();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_12__noImmediateColon___closed__2);
+l___private_Init_Lean_Parser_Parser_12__noImmediateColon = _init_l___private_Init_Lean_Parser_Parser_12__noImmediateColon();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_12__noImmediateColon);
+l_Lean_Parser_pushNone___closed__1 = _init_l_Lean_Parser_pushNone___closed__1();
+lean_mark_persistent(l_Lean_Parser_pushNone___closed__1);
+l_Lean_Parser_pushNone___closed__2 = _init_l_Lean_Parser_pushNone___closed__2();
+lean_mark_persistent(l_Lean_Parser_pushNone___closed__2);
+l_Lean_Parser_pushNone = _init_l_Lean_Parser_pushNone();
+lean_mark_persistent(l_Lean_Parser_pushNone);
+l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__1 = _init_l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__1();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__1);
+l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__2 = _init_l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__2();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__2);
+l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__3 = _init_l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__3();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__3);
+l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__4 = _init_l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__4();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_13__antiquotId___closed__4);
+l___private_Init_Lean_Parser_Parser_13__antiquotId = _init_l___private_Init_Lean_Parser_Parser_13__antiquotId();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_13__antiquotId);
 l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1();
 lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1);
 l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2();
 lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__5 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__5();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__5);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__6 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__6();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__6);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__8 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__8();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__8);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__9 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__9();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__9);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10);
 l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1();
 lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1);
 l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2();
@@ -40386,70 +37550,132 @@ l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6 = _init_l
 lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6);
 l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__7 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__7();
 lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__7);
-l_Lean_Parser_mkAntiquotAux___closed__1 = _init_l_Lean_Parser_mkAntiquotAux___closed__1();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__1);
-l_Lean_Parser_mkAntiquotAux___closed__2 = _init_l_Lean_Parser_mkAntiquotAux___closed__2();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__2);
-l_Lean_Parser_mkAntiquotAux___closed__3 = _init_l_Lean_Parser_mkAntiquotAux___closed__3();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__3);
-l_Lean_Parser_mkAntiquotAux___closed__4 = _init_l_Lean_Parser_mkAntiquotAux___closed__4();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__4);
-l_Lean_Parser_mkAntiquotAux___closed__5 = _init_l_Lean_Parser_mkAntiquotAux___closed__5();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__5);
-l_Lean_Parser_mkAntiquotAux___closed__6 = _init_l_Lean_Parser_mkAntiquotAux___closed__6();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__6);
-l_Lean_Parser_mkAntiquotAux___closed__7 = _init_l_Lean_Parser_mkAntiquotAux___closed__7();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__7);
-l_Lean_Parser_mkAntiquotAux___closed__8 = _init_l_Lean_Parser_mkAntiquotAux___closed__8();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__8);
-l_Lean_Parser_mkAntiquotAux___closed__9 = _init_l_Lean_Parser_mkAntiquotAux___closed__9();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__9);
-l_Lean_Parser_mkAntiquotAux___closed__10 = _init_l_Lean_Parser_mkAntiquotAux___closed__10();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__10);
-l_Lean_Parser_mkAntiquotAux___closed__11 = _init_l_Lean_Parser_mkAntiquotAux___closed__11();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__11);
-l_Lean_Parser_mkAntiquotAux___closed__12 = _init_l_Lean_Parser_mkAntiquotAux___closed__12();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__12);
-l_Lean_Parser_mkAntiquotAux___closed__13 = _init_l_Lean_Parser_mkAntiquotAux___closed__13();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__13);
-l_Lean_Parser_mkAntiquotAux___closed__14 = _init_l_Lean_Parser_mkAntiquotAux___closed__14();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__14);
-l_Lean_Parser_mkAntiquotAux___closed__15 = _init_l_Lean_Parser_mkAntiquotAux___closed__15();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__15);
-l_Lean_Parser_mkAntiquotAux___closed__16 = _init_l_Lean_Parser_mkAntiquotAux___closed__16();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__16);
-l_Lean_Parser_mkAntiquotAux___closed__17 = _init_l_Lean_Parser_mkAntiquotAux___closed__17();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__17);
-l_Lean_Parser_mkAntiquotAux___closed__18 = _init_l_Lean_Parser_mkAntiquotAux___closed__18();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__18);
-l_Lean_Parser_mkAntiquotAux___closed__19 = _init_l_Lean_Parser_mkAntiquotAux___closed__19();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__19);
-l_Lean_Parser_mkAntiquotAux___closed__20 = _init_l_Lean_Parser_mkAntiquotAux___closed__20();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__20);
-l_Lean_Parser_mkAntiquotAux___closed__21 = _init_l_Lean_Parser_mkAntiquotAux___closed__21();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__21);
-l_Lean_Parser_mkAntiquotAux___closed__22 = _init_l_Lean_Parser_mkAntiquotAux___closed__22();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__22);
-l_Lean_Parser_mkAntiquotAux___closed__23 = _init_l_Lean_Parser_mkAntiquotAux___closed__23();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__23);
-l_Lean_Parser_mkAntiquotAux___closed__24 = _init_l_Lean_Parser_mkAntiquotAux___closed__24();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__24);
-l_Lean_Parser_mkAntiquotAux___closed__25 = _init_l_Lean_Parser_mkAntiquotAux___closed__25();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__25);
-l_Lean_Parser_mkAntiquotAux___closed__26 = _init_l_Lean_Parser_mkAntiquotAux___closed__26();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__26);
-l_Lean_Parser_mkAntiquotAux___closed__27 = _init_l_Lean_Parser_mkAntiquotAux___closed__27();
-lean_mark_persistent(l_Lean_Parser_mkAntiquotAux___closed__27);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__8 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__8();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__8);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__9 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__9();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__9);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__10 = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__10();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__10);
+l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr = _init_l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr);
+l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__1 = _init_l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__1();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__1);
+l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__2 = _init_l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__2();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__2);
+l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__3 = _init_l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__3();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_15__antiquotExpr___closed__3);
+l___private_Init_Lean_Parser_Parser_15__antiquotExpr = _init_l___private_Init_Lean_Parser_Parser_15__antiquotExpr();
+lean_mark_persistent(l___private_Init_Lean_Parser_Parser_15__antiquotExpr);
+l_Lean_Parser_mkAntiquot___closed__1 = _init_l_Lean_Parser_mkAntiquot___closed__1();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__1);
+l_Lean_Parser_mkAntiquot___closed__2 = _init_l_Lean_Parser_mkAntiquot___closed__2();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__2);
+l_Lean_Parser_mkAntiquot___closed__3 = _init_l_Lean_Parser_mkAntiquot___closed__3();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__3);
+l_Lean_Parser_mkAntiquot___closed__4 = _init_l_Lean_Parser_mkAntiquot___closed__4();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__4);
+l_Lean_Parser_mkAntiquot___closed__5 = _init_l_Lean_Parser_mkAntiquot___closed__5();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__5);
+l_Lean_Parser_mkAntiquot___closed__6 = _init_l_Lean_Parser_mkAntiquot___closed__6();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__6);
+l_Lean_Parser_mkAntiquot___closed__7 = _init_l_Lean_Parser_mkAntiquot___closed__7();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__7);
+l_Lean_Parser_mkAntiquot___closed__8 = _init_l_Lean_Parser_mkAntiquot___closed__8();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__8);
+l_Lean_Parser_mkAntiquot___closed__9 = _init_l_Lean_Parser_mkAntiquot___closed__9();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__9);
+l_Lean_Parser_mkAntiquot___closed__10 = _init_l_Lean_Parser_mkAntiquot___closed__10();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__10);
+l_Lean_Parser_mkAntiquot___closed__11 = _init_l_Lean_Parser_mkAntiquot___closed__11();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__11);
+l_Lean_Parser_mkAntiquot___closed__12 = _init_l_Lean_Parser_mkAntiquot___closed__12();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__12);
+l_Lean_Parser_mkAntiquot___closed__13 = _init_l_Lean_Parser_mkAntiquot___closed__13();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__13);
+l_Lean_Parser_mkAntiquot___closed__14 = _init_l_Lean_Parser_mkAntiquot___closed__14();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__14);
+l_Lean_Parser_mkAntiquot___closed__15 = _init_l_Lean_Parser_mkAntiquot___closed__15();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__15);
+l_Lean_Parser_mkAntiquot___closed__16 = _init_l_Lean_Parser_mkAntiquot___closed__16();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__16);
+l_Lean_Parser_mkAntiquot___closed__17 = _init_l_Lean_Parser_mkAntiquot___closed__17();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__17);
+l_Lean_Parser_mkAntiquot___closed__18 = _init_l_Lean_Parser_mkAntiquot___closed__18();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__18);
+l_Lean_Parser_mkAntiquot___closed__19 = _init_l_Lean_Parser_mkAntiquot___closed__19();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__19);
+l_Lean_Parser_mkAntiquot___closed__20 = _init_l_Lean_Parser_mkAntiquot___closed__20();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__20);
+l_Lean_Parser_mkAntiquot___closed__21 = _init_l_Lean_Parser_mkAntiquot___closed__21();
+lean_mark_persistent(l_Lean_Parser_mkAntiquot___closed__21);
+l_Lean_Parser_ident___elambda__1___closed__1 = _init_l_Lean_Parser_ident___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_ident___elambda__1___closed__1);
+l_Lean_Parser_ident___elambda__1___closed__2 = _init_l_Lean_Parser_ident___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_ident___elambda__1___closed__2);
 l_Lean_Parser_ident___closed__1 = _init_l_Lean_Parser_ident___closed__1();
 lean_mark_persistent(l_Lean_Parser_ident___closed__1);
+l_Lean_Parser_ident___closed__2 = _init_l_Lean_Parser_ident___closed__2();
+lean_mark_persistent(l_Lean_Parser_ident___closed__2);
+l_Lean_Parser_ident___closed__3 = _init_l_Lean_Parser_ident___closed__3();
+lean_mark_persistent(l_Lean_Parser_ident___closed__3);
+l_Lean_Parser_ident = _init_l_Lean_Parser_ident();
+lean_mark_persistent(l_Lean_Parser_ident);
+l_Lean_Parser_rawIdent___closed__1 = _init_l_Lean_Parser_rawIdent___closed__1();
+lean_mark_persistent(l_Lean_Parser_rawIdent___closed__1);
+l_Lean_Parser_rawIdent___closed__2 = _init_l_Lean_Parser_rawIdent___closed__2();
+lean_mark_persistent(l_Lean_Parser_rawIdent___closed__2);
+l_Lean_Parser_rawIdent___closed__3 = _init_l_Lean_Parser_rawIdent___closed__3();
+lean_mark_persistent(l_Lean_Parser_rawIdent___closed__3);
+l_Lean_Parser_rawIdent = _init_l_Lean_Parser_rawIdent();
+lean_mark_persistent(l_Lean_Parser_rawIdent);
+l_Lean_Parser_numLit___elambda__1___closed__1 = _init_l_Lean_Parser_numLit___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_numLit___elambda__1___closed__1);
+l_Lean_Parser_numLit___elambda__1___closed__2 = _init_l_Lean_Parser_numLit___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_numLit___elambda__1___closed__2);
 l_Lean_Parser_numLit___closed__1 = _init_l_Lean_Parser_numLit___closed__1();
 lean_mark_persistent(l_Lean_Parser_numLit___closed__1);
+l_Lean_Parser_numLit___closed__2 = _init_l_Lean_Parser_numLit___closed__2();
+lean_mark_persistent(l_Lean_Parser_numLit___closed__2);
+l_Lean_Parser_numLit___closed__3 = _init_l_Lean_Parser_numLit___closed__3();
+lean_mark_persistent(l_Lean_Parser_numLit___closed__3);
+l_Lean_Parser_numLit = _init_l_Lean_Parser_numLit();
+lean_mark_persistent(l_Lean_Parser_numLit);
+l_Lean_Parser_strLit___elambda__1___closed__1 = _init_l_Lean_Parser_strLit___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_strLit___elambda__1___closed__1);
+l_Lean_Parser_strLit___elambda__1___closed__2 = _init_l_Lean_Parser_strLit___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_strLit___elambda__1___closed__2);
 l_Lean_Parser_strLit___closed__1 = _init_l_Lean_Parser_strLit___closed__1();
 lean_mark_persistent(l_Lean_Parser_strLit___closed__1);
+l_Lean_Parser_strLit___closed__2 = _init_l_Lean_Parser_strLit___closed__2();
+lean_mark_persistent(l_Lean_Parser_strLit___closed__2);
+l_Lean_Parser_strLit___closed__3 = _init_l_Lean_Parser_strLit___closed__3();
+lean_mark_persistent(l_Lean_Parser_strLit___closed__3);
+l_Lean_Parser_strLit = _init_l_Lean_Parser_strLit();
+lean_mark_persistent(l_Lean_Parser_strLit);
+l_Lean_Parser_charLit___elambda__1___closed__1 = _init_l_Lean_Parser_charLit___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_charLit___elambda__1___closed__1);
+l_Lean_Parser_charLit___elambda__1___closed__2 = _init_l_Lean_Parser_charLit___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_charLit___elambda__1___closed__2);
 l_Lean_Parser_charLit___closed__1 = _init_l_Lean_Parser_charLit___closed__1();
 lean_mark_persistent(l_Lean_Parser_charLit___closed__1);
+l_Lean_Parser_charLit___closed__2 = _init_l_Lean_Parser_charLit___closed__2();
+lean_mark_persistent(l_Lean_Parser_charLit___closed__2);
+l_Lean_Parser_charLit___closed__3 = _init_l_Lean_Parser_charLit___closed__3();
+lean_mark_persistent(l_Lean_Parser_charLit___closed__3);
+l_Lean_Parser_charLit = _init_l_Lean_Parser_charLit();
+lean_mark_persistent(l_Lean_Parser_charLit);
+l_Lean_Parser_nameLit___elambda__1___closed__1 = _init_l_Lean_Parser_nameLit___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_nameLit___elambda__1___closed__1);
+l_Lean_Parser_nameLit___elambda__1___closed__2 = _init_l_Lean_Parser_nameLit___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_nameLit___elambda__1___closed__2);
 l_Lean_Parser_nameLit___closed__1 = _init_l_Lean_Parser_nameLit___closed__1();
 lean_mark_persistent(l_Lean_Parser_nameLit___closed__1);
+l_Lean_Parser_nameLit___closed__2 = _init_l_Lean_Parser_nameLit___closed__2();
+lean_mark_persistent(l_Lean_Parser_nameLit___closed__2);
+l_Lean_Parser_nameLit___closed__3 = _init_l_Lean_Parser_nameLit___closed__3();
+lean_mark_persistent(l_Lean_Parser_nameLit___closed__3);
+l_Lean_Parser_nameLit = _init_l_Lean_Parser_nameLit();
+lean_mark_persistent(l_Lean_Parser_nameLit);
 l_Lean_Parser_categoryParserOfStackFn___closed__1 = _init_l_Lean_Parser_categoryParserOfStackFn___closed__1();
 lean_mark_persistent(l_Lean_Parser_categoryParserOfStackFn___closed__1);
 l_Lean_Parser_categoryParserOfStackFn___closed__2 = _init_l_Lean_Parser_categoryParserOfStackFn___closed__2();
@@ -40497,6 +37723,16 @@ l_Lean_Parser_throwUnknownParserCategory___rarg___closed__1 = _init_l_Lean_Parse
 lean_mark_persistent(l_Lean_Parser_throwUnknownParserCategory___rarg___closed__1);
 l___private_Init_Lean_Parser_Parser_23__updateBuiltinTokens___closed__1 = _init_l___private_Init_Lean_Parser_Parser_23__updateBuiltinTokens___closed__1();
 lean_mark_persistent(l___private_Init_Lean_Parser_Parser_23__updateBuiltinTokens___closed__1);
+l_Lean_Parser_compileParserDescr___main___closed__1 = _init_l_Lean_Parser_compileParserDescr___main___closed__1();
+lean_mark_persistent(l_Lean_Parser_compileParserDescr___main___closed__1);
+l_Lean_Parser_compileParserDescr___main___closed__2 = _init_l_Lean_Parser_compileParserDescr___main___closed__2();
+lean_mark_persistent(l_Lean_Parser_compileParserDescr___main___closed__2);
+l_Lean_Parser_compileParserDescr___main___closed__3 = _init_l_Lean_Parser_compileParserDescr___main___closed__3();
+lean_mark_persistent(l_Lean_Parser_compileParserDescr___main___closed__3);
+l_Lean_Parser_compileParserDescr___main___closed__4 = _init_l_Lean_Parser_compileParserDescr___main___closed__4();
+lean_mark_persistent(l_Lean_Parser_compileParserDescr___main___closed__4);
+l_Lean_Parser_compileParserDescr___main___closed__5 = _init_l_Lean_Parser_compileParserDescr___main___closed__5();
+lean_mark_persistent(l_Lean_Parser_compileParserDescr___main___closed__5);
 l_Lean_Parser_mkParserOfConstantUnsafe___closed__1 = _init_l_Lean_Parser_mkParserOfConstantUnsafe___closed__1();
 lean_mark_persistent(l_Lean_Parser_mkParserOfConstantUnsafe___closed__1);
 l_Lean_Parser_mkParserOfConstantUnsafe___closed__2 = _init_l_Lean_Parser_mkParserOfConstantUnsafe___closed__2();
@@ -40507,10 +37743,6 @@ l_Lean_Parser_mkParserOfConstantUnsafe___closed__4 = _init_l_Lean_Parser_mkParse
 lean_mark_persistent(l_Lean_Parser_mkParserOfConstantUnsafe___closed__4);
 l_Lean_Parser_mkParserOfConstantUnsafe___closed__5 = _init_l_Lean_Parser_mkParserOfConstantUnsafe___closed__5();
 lean_mark_persistent(l_Lean_Parser_mkParserOfConstantUnsafe___closed__5);
-l_Lean_Parser_mkParserOfConstantUnsafe___closed__6 = _init_l_Lean_Parser_mkParserOfConstantUnsafe___closed__6();
-lean_mark_persistent(l_Lean_Parser_mkParserOfConstantUnsafe___closed__6);
-l_Lean_Parser_mkParserOfConstantUnsafe___closed__7 = _init_l_Lean_Parser_mkParserOfConstantUnsafe___closed__7();
-lean_mark_persistent(l_Lean_Parser_mkParserOfConstantUnsafe___closed__7);
 l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkParserExtension___spec__3___closed__1 = _init_l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkParserExtension___spec__3___closed__1();
 lean_mark_persistent(l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkParserExtension___spec__3___closed__1);
 l_Lean_Parser_mkParserExtension___closed__1 = _init_l_Lean_Parser_mkParserExtension___closed__1();
@@ -40622,6 +37854,16 @@ l_Lean_Parser_fieldIdx___closed__2 = _init_l_Lean_Parser_fieldIdx___closed__2();
 lean_mark_persistent(l_Lean_Parser_fieldIdx___closed__2);
 l_Lean_Parser_fieldIdx___closed__3 = _init_l_Lean_Parser_fieldIdx___closed__3();
 lean_mark_persistent(l_Lean_Parser_fieldIdx___closed__3);
+l_Lean_Parser_fieldIdx___closed__4 = _init_l_Lean_Parser_fieldIdx___closed__4();
+lean_mark_persistent(l_Lean_Parser_fieldIdx___closed__4);
+l_Lean_Parser_fieldIdx___closed__5 = _init_l_Lean_Parser_fieldIdx___closed__5();
+lean_mark_persistent(l_Lean_Parser_fieldIdx___closed__5);
+l_Lean_Parser_fieldIdx___closed__6 = _init_l_Lean_Parser_fieldIdx___closed__6();
+lean_mark_persistent(l_Lean_Parser_fieldIdx___closed__6);
+l_Lean_Parser_fieldIdx___closed__7 = _init_l_Lean_Parser_fieldIdx___closed__7();
+lean_mark_persistent(l_Lean_Parser_fieldIdx___closed__7);
+l_Lean_Parser_fieldIdx = _init_l_Lean_Parser_fieldIdx();
+lean_mark_persistent(l_Lean_Parser_fieldIdx);
 return lean_mk_io_result(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Init/Lean/Parser/Syntax.c b/stage0/stdlib/Init/Lean/Parser/Syntax.c
index 6c1d631c7a..8eb3af6b07 100644
--- a/stage0/stdlib/Init/Lean/Parser/Syntax.c
+++ b/stage0/stdlib/Init/Lean/Parser/Syntax.c
@@ -14,14 +14,15 @@
 extern "C" {
 #endif
 lean_object* l_Lean_Parser_Command_infixl___elambda__1___closed__8;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_notation___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_notation___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_macroHead___closed__3;
 lean_object* l_Lean_Parser_Command_syntax___elambda__1___closed__6;
+lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_orelse___closed__5;
-lean_object* l_Lean_Parser_Syntax_many___elambda__1___boxed(lean_object*);
+lean_object* l_Lean_Parser_Syntax_many___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_prefix___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Syntax_str___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_str___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_infixl___closed__5;
 lean_object* l_Lean_Parser_Syntax_char;
 lean_object* l_Lean_Parser_Command_macro__rules___closed__7;
@@ -38,81 +39,85 @@ lean_object* l_Lean_Parser_Command_macro__rules___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_mixfixKind___closed__2;
 lean_object* l_Lean_Parser_Command_infixr___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Syntax_many1;
-lean_object* l_Lean_Parser_Command_notation___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_notation___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_many___elambda__1___closed__2;
 lean_object* l_Lean_Parser_andthenInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_mixfix;
-lean_object* l_Lean_Parser_Command_mixfixSymbol___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_mixfixSymbol___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_lookahead___closed__4;
 lean_object* l_Lean_Parser_Command_macroArgType___closed__4;
 lean_object* l_Lean_Parser_Syntax_num___closed__5;
 lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Syntax_many1___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_Syntax_try___closed__3;
+lean_object* l_Lean_Parser_Syntax_many1___elambda__1___closed__1;
 extern lean_object* l_Lean_nullKind;
 extern lean_object* l_Lean_Parser_Tactic_orelse___closed__1;
 lean_object* l_Lean_Parser_Syntax_paren___closed__6;
-lean_object* l_Lean_Parser_Command_syntax___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_syntax___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_str___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Command_macroTail___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macroTail___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_identKind___closed__1;
-lean_object* l_Lean_Parser_maxPrec___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_maxPrec___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_mixfix___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1___closed__3;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_macroArgType___closed__2;
 lean_object* l_Lean_Parser_Command_macroTailDefault___closed__8;
 lean_object* l_Lean_Parser_Command_reserve___elambda__1___closed__7;
 lean_object* l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__2;
-lean_object* l_Lean_Parser_Command_infixr___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_infixr___elambda__1(lean_object*, lean_object*);
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 extern lean_object* l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
 lean_object* l_Lean_Parser_Syntax_paren___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_quotedSymbolPrec___closed__5;
 lean_object* l_Lean_Parser_Command_macroHead;
 lean_object* l_Lean_Parser_Syntax_paren___closed__4;
+lean_object* l_Lean_Parser_Syntax_many1___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Syntax_cat___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_cat(lean_object*);
-lean_object* l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2;
-extern lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5;
 lean_object* l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_macroTailTactic___closed__5;
 lean_object* l_Lean_Parser_Command_infixr___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Command_macro___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macro___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_macroArgType___closed__1;
 lean_object* l_Lean_Parser_Syntax_sepBy___closed__3;
 lean_object* l_Lean_Parser_Syntax_ident___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_macro__rules___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_macroArgSimple___closed__5;
 lean_object* l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-lean_object* l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Parser_Syntax_many___closed__1;
 lean_object* l_Lean_Parser_Syntax_many___closed__2;
 lean_object* l_Lean_Parser_Command_prefix___elambda__1___closed__6;
+lean_object* l_Lean_Parser_Syntax_many___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Syntax_str___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_macro__rules___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Command_identPrec___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_optPrecedence___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_identPrec___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_optPrecedence___elambda__1(lean_object*, lean_object*);
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_many(lean_object*);
+lean_object* l_Lean_Parser_Syntax_orelse___elambda__1___closed__1;
 lean_object* l_Lean_Parser_maxPrec___closed__4;
 lean_object* l_Lean_Parser_Command_macroTailTactic___closed__3;
 lean_object* l_Lean_Parser_Command_prefix;
 lean_object* l_Lean_Parser_Command_infixr___closed__1;
+extern lean_object* l_Lean_Parser_ident;
 lean_object* l_Lean_Parser_Syntax_lookahead___closed__5;
 lean_object* l_Lean_Parser_precedence___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Syntax_str___closed__3;
-extern lean_object* l_Lean_Parser_mkAntiquotAux___closed__3;
 lean_object* l_Lean_Parser_Syntax_sepBy;
 lean_object* l_Lean_Parser_Syntax_sepBy___closed__5;
 lean_object* l_Lean_Parser_Syntax_paren;
-lean_object* l_Lean_Parser_Syntax_paren___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_reserve___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_paren___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_reserve___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_macro__rules___elambda__1___closed__7;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_try(lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkNode(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_many___elambda__1___closed__3;
 extern lean_object* l_Lean_Parser_darrow;
 lean_object* l_Lean_Parser_Command_macroArgSimple___closed__4;
+extern lean_object* l_Lean_Parser_mkAntiquot___closed__9;
 lean_object* l_Lean_Parser_Syntax_str___closed__5;
 lean_object* l_Lean_Parser_Command_macroTailCommand___closed__5;
 lean_object* l_Lean_Parser_Command_strLitPrec___closed__1;
@@ -120,16 +125,14 @@ extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_macroArgSimple___closed__1;
-lean_object* l_Lean_Parser_Syntax_orelse___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_Syntax_try___closed__7;
 lean_object* l_Lean_Parser_precedenceLit___closed__2;
 lean_object* l_Lean_Parser_ParserState_mkTrailingNode(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_unquotedSymbolFn___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_mixfix___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_mixfix___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_cat___closed__2;
 lean_object* l_Lean_Parser_Command_notation___closed__10;
-extern lean_object* l_Lean_Parser_mkAntiquotAux___closed__10;
-lean_object* l_Lean_Parser_addBuiltinParser(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_mkAntiquot___closed__4;
+lean_object* l_Lean_Parser_addBuiltinParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__1;
 lean_object* l_Lean_Parser_Command_macroHead___closed__2;
 lean_object* lean_array_get_size(lean_object*);
@@ -137,35 +140,33 @@ lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__9;
 lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_infixr;
 lean_object* l_Lean_Parser_tokenFn(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_infixr___elambda__1___closed__6;
 extern lean_object* l_Lean_Parser_Term_listLit___closed__4;
-lean_object* l_Lean_Parser_Command_macroTailDefault___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macroTailDefault___elambda__1(lean_object*, lean_object*);
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_maxPrec___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1___closed__3;
 extern lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Syntax_ident___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_macroHead___closed__1;
 lean_object* l_Lean_Parser_precedence___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Syntax_ident___elambda__1___closed__1;
 lean_object* l_Lean_Parser_optPrecedence;
 lean_object* l_Lean_Parser_Syntax_num___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Syntax_many1___elambda__1___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_identEqFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Syntax_orelse___elambda__1___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_mkAppStx___closed__4;
 lean_object* l_Lean_Parser_ParserState_mkErrorsAt(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_infixl___closed__4;
-lean_object* l_Lean_Parser_Syntax_many___elambda__1(lean_object*);
+lean_object* l_Lean_Parser_Syntax_many___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_paren___closed__3;
-lean_object* l_Lean_Parser_Command_macroArgType___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macroArgType___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_infix;
-lean_object* l_Lean_Parser_Command_optKind___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_optKind___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
-lean_object* l_Lean_Parser_quotedSymbolFn(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_quotedSymbolFn(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_syntax___elambda__1___closed__2;
+extern lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__6;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_reserve(lean_object*);
 extern lean_object* l_Lean_Parser_Term_stxQuot___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_identPrec;
@@ -178,22 +179,22 @@ lean_object* l_Lean_Parser_Syntax_char___closed__2;
 lean_object* l_Lean_Parser_Command_postfix___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__8;
 extern lean_object* l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-lean_object* l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__3;
 lean_object* l_Lean_Parser_Syntax_char___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Syntax_sepBy___closed__4;
 lean_object* l_Lean_Parser_Command_macro___closed__5;
+extern lean_object* l_Lean_Parser_mkAntiquot___closed__3;
 lean_object* l_Lean_Parser_Syntax_str___closed__4;
 lean_object* l_Lean_Parser_Command_infix___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_mixfix___closed__4;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_notation___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_syntax;
 lean_object* l_Lean_Parser_Command_syntax___closed__5;
 lean_object* l_Lean_Parser_Syntax_lookahead___closed__6;
 lean_object* l_Lean_Parser_Syntax_str___elambda__1___closed__6;
+lean_object* l_Lean_Parser_identEqFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_mixfix___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_mixfix___closed__8;
 lean_object* l_Lean_Parser_Syntax_ident___closed__3;
-lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_macro__rules___closed__6;
 lean_object* l_Lean_Parser_Syntax_ident___closed__5;
 lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1___closed__6;
@@ -201,13 +202,12 @@ lean_object* l_Lean_Parser_Command_macroTailDefault___closed__5;
 lean_object* l_Lean_Parser_Command_notation___closed__6;
 lean_object* l_Lean_Parser_Command_macroArg___closed__3;
 lean_object* l_Lean_Parser_Command_macroTail___closed__2;
+lean_object* l_Lean_Parser_strLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_reserve___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Syntax_paren___closed__1;
 lean_object* l_Lean_Parser_Command_macroArg;
 lean_object* l_Lean_Parser_Command_macro__rules___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__5;
 lean_object* l_Lean_Parser_Command_macro__rules___elambda__1___closed__2;
-extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_infix___closed__4;
 lean_object* l_Lean_Parser_Syntax_char___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_prefix___closed__4;
@@ -218,13 +218,12 @@ lean_object* l_Lean_Parser_Command_macro___closed__3;
 lean_object* l_Lean_Parser_Syntax_cat___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_orelse(lean_object*);
 lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1___closed__1;
-lean_object* l_Lean_Parser_syntaxParser___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_macroArg___closed__1;
 extern lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_macroTailCommand___closed__6;
 lean_object* l_Lean_Parser_Command_macroTailDefault___closed__7;
 lean_object* l_Lean_Parser_Command_infixl;
-lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_notation___closed__3;
 lean_object* l_Lean_Parser_Syntax_num;
 extern lean_object* l_Lean_Parser_identNoAntiquot___closed__1;
@@ -240,26 +239,24 @@ lean_object* l_Lean_Parser_Command_postfix___closed__1;
 lean_object* l_Lean_Parser_Command_macroTailCommand___closed__3;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nonReservedSymbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_many1___closed__1;
-lean_object* l_Lean_Parser_Command_macroHead___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macroHead___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_lookahead(lean_object*);
 lean_object* l_Lean_Parser_Command_notation___closed__5;
 lean_object* l_Lean_Parser_nodeInfo(lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_mkAntiquotAux___closed__4;
 lean_object* l_Lean_Parser_Command_infix___closed__1;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_macro___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_macro___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_strLitPrec;
 lean_object* l_Lean_Parser_Command_postfix___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Syntax_many1___closed__2;
 lean_object* l_Lean_Parser_Syntax_sepBy1;
-lean_object* l_Lean_Parser_Command_mixfixSymbol___closed__4;
 lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1___closed__2;
-lean_object* l_Lean_Parser_quotedSymbol(uint8_t);
+extern lean_object* l_Lean_Parser_quotedSymbol;
 lean_object* l_Lean_Parser_Syntax_num___elambda__1___closed__1;
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_sepBy1___closed__2;
-lean_object* l_Lean_Parser_precedence___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_precedence___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_postfix;
 lean_object* l_Lean_Parser_Command_infix___closed__2;
@@ -283,10 +280,10 @@ lean_object* l_Lean_Parser_Syntax_sepBy1___closed__4;
 lean_object* l_Lean_Parser_Syntax_char___elambda__1___closed__6;
 lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_precedenceLit;
-lean_object* l_Lean_Parser_Syntax_try___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_try___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_notation;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_notation(lean_object*);
-lean_object* l_Lean_Parser_Syntax_ident___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_ident___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_macro___closed__7;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_macro__rules(lean_object*);
 lean_object* l_Lean_Parser_Syntax_paren___elambda__1___closed__1;
@@ -299,11 +296,12 @@ lean_object* l_Lean_Parser_Command_syntax___closed__7;
 lean_object* l_Lean_Parser_Command_mixfixSymbol___closed__1;
 lean_object* l_Lean_Parser_Syntax_str___closed__1;
 lean_object* l_Lean_Parser_optionaInfo(lean_object*);
-lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_tacticStxQuot___closed__2;
 extern lean_object* l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Syntax_paren___closed__5;
 lean_object* l_Lean_Parser_Command_prefix___elambda__1___closed__3;
+lean_object* l_Lean_Parser_Syntax_optional___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Syntax_paren___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_reserve___elambda__1___closed__9;
 lean_object* l_Lean_Parser_precedence___elambda__1___closed__5;
@@ -316,13 +314,12 @@ lean_object* l_Lean_Parser_Syntax_num___closed__1;
 lean_object* l_Lean_Parser_Syntax_paren___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_postfix___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_macroArgType___closed__5;
-lean_object* l_Lean_Parser_Syntax_optional___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_ident;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Syntax_num___closed__4;
-lean_object* l_Lean_Parser_categoryParserOfStack(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParserOfStack(lean_object*, lean_object*);
 extern lean_object* l_Char_HasRepr___closed__1;
 lean_object* l_Lean_Parser_Syntax_lookahead___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2;
 lean_object* l_Lean_Parser_Command_infixr___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_infixl___elambda__1___closed__6;
 lean_object* l_Lean_Parser_checkNoWsBeforeFn(lean_object*, lean_object*, lean_object*);
@@ -331,22 +328,19 @@ lean_object* l_Lean_Parser_orelseInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_char___closed__4;
 lean_object* l_Lean_Parser_Command_syntax___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Syntax_lookahead___closed__3;
-lean_object* l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Parser_Command_mixfixSymbol___closed__2;
 lean_object* l_Lean_Parser_Command_macroTailTactic;
 lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__3;
 extern lean_object* l_Lean_Parser_termParser___closed__2;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__5;
 extern lean_object* l_Lean_Parser_Term_stxQuot___closed__2;
-lean_object* l_Lean_Parser_Command_infix___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_infix___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_maxPrec;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_str(lean_object*);
 lean_object* l_Lean_Parser_Syntax_ident___elambda__1___closed__3;
 extern lean_object* l___regBuiltinParser_Lean_Parser_Command_antiquot___closed__2;
 extern lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_syntax___elambda__1___closed__5;
-extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__11;
 lean_object* l_Lean_Parser_Syntax_char___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_mixfixKind___closed__1;
 lean_object* l_Lean_Parser_Command_reserve___elambda__1___closed__3;
@@ -373,8 +367,8 @@ lean_object* l_Lean_Parser_Command_identPrec___elambda__1___closed__2;
 extern lean_object* l_Lean_Parser_Term_namedHole___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Syntax_cat___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_prefix___closed__2;
-lean_object* l_Lean_Parser_Syntax_num___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_num___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_reserve___closed__1;
 lean_object* l_Lean_Parser_Command_reserve___closed__2;
 lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
@@ -382,7 +376,6 @@ lean_object* l_Lean_Parser_maxPrec___closed__3;
 lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1___closed__1;
 extern lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Syntax_sepBy___closed__2;
-extern lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_notation___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_reserve;
 lean_object* l_Lean_Parser_Syntax_sepBy___closed__1;
@@ -394,10 +387,9 @@ lean_object* l___regBuiltinParser_Lean_Parser_Command_syntaxCat(lean_object*);
 lean_object* l_Lean_Parser_precedence___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Syntax_many___closed__3;
-lean_object* l_Lean_Parser_Syntax_optional___elambda__1(lean_object*);
+lean_object* l_Lean_Parser_Syntax_optional___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_num___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Command_macro___closed__1;
-lean_object* l_Lean_Parser_Syntax_optional___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_Command_mixfix___closed__1;
 lean_object* l_Lean_Parser_Syntax_atom___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_sepBy(lean_object*);
@@ -408,20 +400,18 @@ lean_object* l_Lean_Parser_Command_identPrec___closed__4;
 lean_object* l_Lean_Parser_Command_syntax___closed__1;
 lean_object* l_Lean_Parser_Command_infixl___elambda__1___closed__3;
 lean_object* l_Lean_Parser_precedence___closed__3;
-lean_object* l_Lean_Parser_Command_macroTailTactic___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_quotedSymbolPrec___closed__1;
 lean_object* l_Lean_Parser_Command_reserve___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_paren(lean_object*);
 extern lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__12;
 lean_object* l_Lean_Parser_Command_notation___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Syntax_char___elambda__1___closed__4;
-lean_object* l_Lean_Parser_categoryParserFn(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Syntax_cat___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Command_postfix___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_postfix___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_lookahead___elambda__1___closed__1;
 lean_object* l_Lean_Parser_precedence;
-extern lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__2;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2;
 lean_object* l_Lean_Parser_precedenceLit___closed__3;
@@ -433,22 +423,24 @@ lean_object* l_Lean_Parser_Command_mixfix___closed__2;
 extern lean_object* l_Lean_Parser_appPrec;
 lean_object* l_Lean_Parser_Command_syntaxCat___closed__6;
 lean_object* l_Lean_Parser_Command_infix___elambda__1___closed__6;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_mixfix___closed__5;
+lean_object* l_Lean_Parser_ident___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_sepBy1(lean_object*);
+lean_object* l_Lean_Parser_unquotedSymbolFn(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_identPrec___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_reserve___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1___closed__9;
+extern lean_object* l_Lean_Parser_numLit;
 lean_object* l_Lean_Parser_Syntax_num___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Syntax_many___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_paren___closed__2;
-lean_object* l_Lean_Parser_Command_mixfixKind___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_mixfixKind___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_haveAssign___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_num(lean_object*);
 lean_object* l_Lean_Parser_Command_macro___closed__6;
 lean_object* l_Lean_Parser_optPrecedence___closed__3;
 lean_object* l_Lean_Parser_Command_infix___closed__5;
+lean_object* l_Lean_Parser_numLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_atom___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_macro;
 lean_object* l_Lean_Parser_Command_syntax___closed__6;
@@ -460,14 +452,14 @@ lean_object* l_Lean_Parser_precedence___closed__5;
 lean_object* l_Lean_Parser_Syntax_optional___closed__3;
 lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Syntax_sepBy___closed__6;
-lean_object* l_Lean_Parser_Command_infixl___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_infixl___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_postfix___closed__4;
 lean_object* l_Lean_Parser_Command_notation___closed__2;
 lean_object* l_Lean_Parser_Command_syntaxCat___closed__3;
 lean_object* l_Lean_Parser_Syntax_str___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__1;
 lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Syntax_cat___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_cat___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_reserve___closed__6;
 lean_object* l_Lean_Parser_Syntax_sepBy1___closed__1;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
@@ -475,26 +467,26 @@ extern lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_quotedSymbolPrec___closed__2;
 lean_object* l_Lean_Parser_Command_mixfix___elambda__1___closed__3;
-lean_object* l_Lean_Parser_categoryParser(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParser(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_prefix___closed__5;
 lean_object* l_Lean_Parser_Syntax_many1___closed__3;
+lean_object* l_Lean_Parser_Syntax_optional___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_reserve___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2;
 lean_object* l_Lean_Parser_Command_infix___closed__3;
 lean_object* l_Lean_Parser_Syntax_ident___closed__4;
 lean_object* l_Lean_Parser_Syntax_atom___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_notation___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_infix___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Command_macro__rules___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macro__rules___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_syntaxCat___closed__5;
 extern lean_object* l_Lean_Parser_Term_match___elambda__1___closed__9;
 lean_object* l_Lean_Parser_maxPrec___closed__5;
 lean_object* l_Lean_Parser_Command_macroTailTactic___closed__6;
 lean_object* l_Lean_Parser_Command_notation___closed__1;
-extern lean_object* l_Lean_Parser_mkAntiquotAux___closed__11;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_macroTailCommand___closed__4;
 lean_object* l_Lean_Parser_Command_infixl___elambda__1___closed__7;
-lean_object* l_Lean_Parser_Syntax_lookahead___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_lookahead___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1___closed__8;
 lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_maxPrec___elambda__1___closed__7;
@@ -506,15 +498,16 @@ lean_object* l_Lean_Parser_Command_notation___closed__8;
 extern lean_object* l_Lean_Parser_epsilonInfo;
 lean_object* l_Lean_Parser_Command_macroTailDefault;
 lean_object* l_Lean_Parser_Command_mixfix___closed__6;
-lean_object* l_Lean_Parser_unquotedSymbol(uint8_t);
+extern lean_object* l_Lean_Parser_unquotedSymbol;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Syntax_ident___closed__1;
 extern lean_object* l_Lean_Parser_Term_typeAscription___closed__1;
 lean_object* l_Lean_Parser_Command_notation___elambda__1___closed__8;
+lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_reserve___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_strLitPrec___closed__3;
-lean_object* l_Lean_Parser_Syntax_atom___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_atom___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_postfix___closed__2;
 lean_object* l_Lean_Parser_Command_notation___closed__4;
 lean_object* l_Lean_Parser_Syntax_str___elambda__1___closed__1;
@@ -535,36 +528,34 @@ lean_object* l_Lean_Parser_Syntax_lookahead___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Syntax_atom___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_postfix___elambda__1___closed__7;
-lean_object* l_Lean_Parser_Command_macroArg___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macroArg___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_regBuiltinSyntaxParserAttr(lean_object*);
 lean_object* l_Lean_Parser_Command_infixl___closed__1;
 lean_object* l_Lean_Parser_Command_optKind___closed__4;
 lean_object* l_Lean_Parser_maxPrec___elambda__1___closed__1;
-lean_object* l_Lean_Parser_precedenceLit___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_precedenceLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_atom___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_notation___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_mixfixKind___closed__6;
 lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__8;
 extern lean_object* l_Lean_Level_LevelToFormat_Result_format___main___closed__3;
-extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
 lean_object* l_Lean_Parser_Syntax_orelse___closed__2;
 lean_object* l_Lean_Parser_Command_syntax___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Syntax_char___closed__3;
 lean_object* l_Lean_Parser_Command_notation___elambda__1___closed__7;
 lean_object* l_String_trim(lean_object*);
-lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_postfix___closed__3;
-extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__8;
+lean_object* l_Lean_Parser_darrow___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_orelse___closed__1;
-lean_object* l_Lean_Parser_Command_macroTailTactic___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macroTailTactic___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_syntax___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Command_mixfixKind___closed__3;
 lean_object* l_Lean_Parser_Command_infixr___elambda__1___closed__1;
-extern lean_object* l_Lean_Parser_Term_typeAscription___closed__2;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_optKind___closed__1;
 lean_object* l_Lean_Parser_Syntax_paren___closed__7;
 lean_object* l_Lean_Parser_Command_optKind;
-lean_object* l_Lean_Parser_Command_macroTailCommand___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_macroTailTactic___closed__2;
 lean_object* l_Lean_Parser_Syntax_str;
@@ -585,8 +576,7 @@ lean_object* l_Lean_Parser_Command_macro__rules___closed__3;
 lean_object* l_Lean_Parser_Command_syntaxCat___closed__4;
 lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Syntax_char___closed__5;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_macro___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquot(uint8_t, lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_Parser_mkAntiquot(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Parser_Command_macroTailCommand;
 lean_object* l_Lean_Parser_Command_syntaxCat___closed__1;
 lean_object* l_Lean_Parser_Command_macro__rules;
@@ -610,14 +600,14 @@ lean_object* l_Lean_Parser_Command_syntax___closed__9;
 lean_object* l_Lean_Parser_Command_macroTailDefault___closed__2;
 lean_object* l_Lean_Parser_Syntax_atom___closed__2;
 lean_object* l_Lean_Parser_precedence___closed__2;
-lean_object* l_Lean_Parser_Syntax_char___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Syntax_char___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+extern lean_object* l_Lean_Parser_mkAntiquot___closed__8;
 lean_object* l_Lean_Parser_Command_optKind___closed__3;
 lean_object* l_Lean_Parser_Command_infixr___closed__4;
 lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Command_macroTailDefault___closed__4;
 lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1___closed__6;
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_identPrec___closed__1;
 lean_object* l_Lean_Parser_Syntax_cat___closed__5;
 lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__2;
@@ -627,24 +617,22 @@ lean_object* l_Lean_Parser_ParserState_mkUnexpectedError(lean_object*, lean_obje
 lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Syntax_try___closed__6;
 lean_object* l_Lean_Parser_Command_macroTailDefault___closed__1;
-lean_object* l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__4;
+extern lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_syntax___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_atom(lean_object*);
 lean_object* l_Lean_Parser_Syntax_optional___closed__2;
 lean_object* l_Lean_Parser_Syntax_num___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_mixfixKind___closed__5;
 lean_object* l_Lean_Parser_Syntax_atom___closed__5;
-lean_object* l_Lean_Parser_categoryParserOfStackFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_macro___closed__4;
-lean_object* l_Lean_Parser_Syntax_orelse___elambda__1(lean_object*);
+lean_object* l_Lean_Parser_Syntax_orelse___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_optional___closed__1;
 lean_object* l_Lean_Parser_Syntax_cat___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_optional(lean_object*);
-lean_object* l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Parser_Command_infixr___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Syntax_many1___elambda__1(lean_object*);
+lean_object* l_Lean_Parser_Syntax_many1___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Command_syntaxCat;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_char(lean_object*);
 lean_object* l_Lean_Parser_Command_macroTail;
@@ -653,7 +641,6 @@ lean_object* l_Lean_Parser_maxPrec___closed__1;
 lean_object* l_Lean_Parser_Command_syntax___elambda__1___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_syntax(lean_object*);
 lean_object* l_Lean_Parser_Syntax_atom___closed__3;
-lean_object* l_Lean_Parser_Command_quotedSymbolPrec___closed__6;
 lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__5;
 extern lean_object* l_Lean_Parser_Term_orelse___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Syntax_orelse___closed__4;
@@ -669,9 +656,10 @@ lean_object* l_Lean_Parser_precedence___closed__1;
 lean_object* l_Lean_Parser_Command_macroTail___closed__3;
 lean_object* l_Lean_Parser_Command_macroTail___closed__1;
 lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__2;
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
+lean_object* l_Lean_Parser_Syntax_many___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__6;
 lean_object* l_Lean_Parser_maxPrec___elambda__1___closed__6;
+extern lean_object* l_Lean_Parser_strLit;
 lean_object* l_Lean_Parser_Command_infixr___closed__2;
 extern lean_object* l_Lean_Parser_Term_char___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_macro___closed__2;
@@ -679,14 +667,14 @@ lean_object* l_Lean_Parser_Command_prefix___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Command_quotedSymbolPrec___closed__3;
 lean_object* l_Lean_Parser_Command_infixr___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Command_prefix___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_prefix___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Syntax_cat___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Command_mixfix___closed__7;
 lean_object* l_Lean_Parser_Command_prefix___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Command_syntaxCat___closed__2;
 lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__6;
 extern lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Command_macroTailCommand___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Command_macroTailCommand___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_maxPrec___closed__2;
 lean_object* l_Lean_Parser_optPrecedence___closed__1;
 lean_object* l_Lean_Parser_Command_reserve___closed__3;
@@ -695,9 +683,8 @@ lean_object* l_Lean_Parser_Syntax_orelse;
 lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Command_macro___closed__9;
 lean_object* l_Lean_Parser_Command_syntax___closed__4;
-extern lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1___closed__4;
-lean_object* l_Lean_Parser_syntaxParser(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_syntaxParser(lean_object*);
 lean_object* l_Lean_Parser_Command_macro__rules___closed__5;
 lean_object* _init_l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__1() {
 _start:
@@ -746,23 +733,13 @@ x_5 = l_Lean_Parser_registerBuiltinParserAttribute(x_2, x_3, x_4, x_1);
 return x_5;
 }
 }
-lean_object* l_Lean_Parser_syntaxParser(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_syntaxParser(lean_object* x_1) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; 
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_syntaxParser___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_syntaxParser(x_3, x_2);
-return x_4;
+lean_object* x_2; lean_object* x_3; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_categoryParser(x_2, x_1);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_maxPrec___elambda__1___closed__1() {
@@ -796,13 +773,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_maxPrec___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_maxPrec___elambda__1___closed__1;
-x_3 = l_Lean_Parser_maxPrec___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_maxPrec___elambda__1___closed__1;
+x_2 = l_Lean_Parser_maxPrec___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_maxPrec___elambda__1___closed__5() {
@@ -834,66 +810,66 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_maxPrec___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_maxPrec___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_maxPrec___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_maxPrec___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_maxPrec___elambda__1___closed__5;
+x_17 = l_Lean_Parser_maxPrec___elambda__1___closed__7;
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = l_Lean_Parser_maxPrec___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_maxPrec___elambda__1___closed__5;
-x_18 = l_Lean_Parser_maxPrec___elambda__1___closed__7;
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = l_Lean_Parser_maxPrec___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+return x_21;
 }
 }
 }
@@ -934,7 +910,7 @@ lean_object* _init_l_Lean_Parser_maxPrec___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_maxPrec___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_maxPrec___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -958,61 +934,55 @@ x_1 = l_Lean_Parser_maxPrec___closed__5;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_precedenceLit___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_precedenceLit___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Level_num___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
+x_6 = l_Lean_Parser_numLit___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_9;
+return x_6;
 }
 else
 {
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
-lean_dec(x_11);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
 lean_dec(x_7);
-x_15 = l_Lean_Parser_maxPrec___elambda__1(x_1, x_2, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+x_10 = lean_nat_dec_eq(x_9, x_5);
+lean_dec(x_9);
+if (x_10 == 0)
+{
 lean_dec(x_8);
-return x_16;
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = l_Lean_Parser_maxPrec___elambda__1(x_1, x_11);
+x_13 = l_Lean_Parser_mergeOrElseErrors(x_12, x_8, x_5);
+lean_dec(x_5);
+return x_13;
 }
 }
 }
@@ -1021,7 +991,7 @@ lean_object* _init_l_Lean_Parser_precedenceLit___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Level_num___elambda__1___closed__5;
+x_1 = l_Lean_Parser_numLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_maxPrec;
@@ -1035,7 +1005,7 @@ lean_object* _init_l_Lean_Parser_precedenceLit___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_precedenceLit___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_precedenceLit___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1090,13 +1060,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_precedence___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_precedence___elambda__1___closed__1;
-x_3 = l_Lean_Parser_precedence___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_precedence___elambda__1___closed__1;
+x_2 = l_Lean_Parser_precedence___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_precedence___elambda__1___closed__5() {
@@ -1104,7 +1073,7 @@ _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_mkAntiquotAux___closed__3;
+x_2 = l_Lean_Parser_mkAntiquot___closed__3;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
@@ -1131,143 +1100,139 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_precedence___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_precedence___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_precedence___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_precedence___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_27; lean_object* x_28; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_27 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_28 = lean_ctor_get(x_27, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_26; lean_object* x_27; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
+{
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
 lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = lean_ctor_get(x_27, 0);
-lean_inc(x_29);
-x_30 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_29);
-lean_dec(x_29);
-if (lean_obj_tag(x_30) == 2)
-{
-lean_object* x_31; lean_object* x_32; uint8_t x_33; 
-x_31 = lean_ctor_get(x_30, 1);
-lean_inc(x_31);
-lean_dec(x_30);
-x_32 = l_Lean_Parser_mkAntiquotAux___closed__3;
-x_33 = lean_string_dec_eq(x_31, x_32);
-lean_dec(x_31);
-if (x_33 == 0)
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = l_Lean_Parser_precedence___elambda__1___closed__7;
-lean_inc(x_8);
-x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_8);
-x_17 = x_35;
-goto block_26;
-}
-else
-{
-x_17 = x_27;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-lean_dec(x_30);
-x_36 = l_Lean_Parser_precedence___elambda__1___closed__7;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_36, x_8);
-x_17 = x_37;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
 lean_dec(x_28);
-x_38 = l_Lean_Parser_precedence___elambda__1___closed__7;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_38, x_8);
-x_17 = x_39;
-goto block_26;
-}
-block_26:
+if (lean_obj_tag(x_29) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
+lean_inc(x_30);
+lean_dec(x_29);
+x_31 = l_Lean_Parser_mkAntiquot___closed__3;
+x_32 = lean_string_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = l_Lean_Parser_precedenceLit___elambda__1(x_1, x_2, x_17);
-x_20 = l_Lean_Parser_precedence___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_Parser_precedence___elambda__1___closed__7;
+lean_inc(x_7);
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_7);
+x_16 = x_34;
+goto block_25;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-lean_dec(x_18);
-lean_dec(x_2);
+x_16 = x_26;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_29);
+x_35 = l_Lean_Parser_precedence___elambda__1___closed__7;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_7);
+x_16 = x_36;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_27);
+x_37 = l_Lean_Parser_precedence___elambda__1___closed__7;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_7);
+x_16 = x_38;
+goto block_25;
+}
+block_25:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_precedenceLit___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_precedence___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_23 = l_Lean_Parser_precedence___elambda__1___closed__2;
-x_24 = l_Lean_Parser_ParserState_mkNode(x_17, x_23, x_16);
-x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_11, x_8);
-lean_dec(x_8);
-return x_25;
+x_22 = l_Lean_Parser_precedence___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -1281,7 +1246,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4;
 x_1 = l_Lean_Parser_precedenceLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_mkAntiquotAux___closed__4;
+x_3 = l_Lean_Parser_mkAntiquot___closed__4;
 x_4 = l_Lean_Parser_andthenInfo(x_3, x_2);
 return x_4;
 }
@@ -1312,7 +1277,7 @@ lean_object* _init_l_Lean_Parser_precedence___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_precedence___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_precedence___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1336,92 +1301,92 @@ x_1 = l_Lean_Parser_precedence___closed__5;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_optPrecedence___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_optPrecedence___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_2, 1);
 lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 1);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_4);
+x_5 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_6 = l_Lean_Parser_precedence___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; 
 lean_dec(x_4);
-x_7 = l_Lean_Parser_precedence___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
-lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; lean_object* x_10; 
-lean_dec(x_5);
-x_9 = l_Lean_nullKind;
-x_10 = l_Lean_Parser_ParserState_mkNode(x_7, x_9, x_6);
-return x_10;
+x_8 = l_Lean_nullKind;
+x_9 = l_Lean_Parser_ParserState_mkNode(x_6, x_8, x_5);
+return x_9;
 }
 else
 {
-uint8_t x_11; 
-x_11 = !lean_is_exclusive(x_7);
-if (x_11 == 0)
+uint8_t x_10; 
+x_10 = !lean_is_exclusive(x_6);
+if (x_10 == 0)
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_12 = lean_ctor_get(x_7, 0);
-x_13 = lean_ctor_get(x_7, 3);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; 
+x_11 = lean_ctor_get(x_6, 0);
+x_12 = lean_ctor_get(x_6, 3);
+lean_dec(x_12);
+x_13 = lean_ctor_get(x_6, 1);
 lean_dec(x_13);
-x_14 = lean_ctor_get(x_7, 1);
-lean_dec(x_14);
-x_15 = l_Array_shrink___main___rarg(x_12, x_6);
-lean_inc(x_5);
-lean_ctor_set(x_7, 1, x_5);
-lean_ctor_set(x_7, 0, x_15);
-x_16 = lean_nat_dec_eq(x_5, x_5);
-if (x_16 == 0)
+x_14 = l_Array_shrink___main___rarg(x_11, x_5);
+lean_inc(x_4);
+lean_ctor_set(x_6, 1, x_4);
+lean_ctor_set(x_6, 0, x_14);
+x_15 = lean_nat_dec_eq(x_4, x_4);
+if (x_15 == 0)
 {
-lean_object* x_17; lean_object* x_18; 
-lean_dec(x_5);
-x_17 = l_Lean_nullKind;
-x_18 = l_Lean_Parser_ParserState_mkNode(x_7, x_17, x_6);
-return x_18;
+lean_object* x_16; lean_object* x_17; 
+lean_dec(x_4);
+x_16 = l_Lean_nullKind;
+x_17 = l_Lean_Parser_ParserState_mkNode(x_6, x_16, x_5);
+return x_17;
 }
 else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = l_Lean_Parser_ParserState_restore(x_7, x_6, x_5);
-x_20 = l_Lean_nullKind;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_6);
-return x_21;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = l_Lean_Parser_ParserState_restore(x_6, x_5, x_4);
+x_19 = l_Lean_nullKind;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_5);
+return x_20;
 }
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_22 = lean_ctor_get(x_7, 0);
-x_23 = lean_ctor_get(x_7, 2);
-lean_inc(x_23);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_21 = lean_ctor_get(x_6, 0);
+x_22 = lean_ctor_get(x_6, 2);
 lean_inc(x_22);
-lean_dec(x_7);
-x_24 = l_Array_shrink___main___rarg(x_22, x_6);
-lean_inc(x_5);
-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_8);
-x_26 = lean_nat_dec_eq(x_5, x_5);
-if (x_26 == 0)
+lean_inc(x_21);
+lean_dec(x_6);
+x_23 = l_Array_shrink___main___rarg(x_21, x_5);
+lean_inc(x_4);
+x_24 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_24, 0, x_23);
+lean_ctor_set(x_24, 1, x_4);
+lean_ctor_set(x_24, 2, x_22);
+lean_ctor_set(x_24, 3, x_7);
+x_25 = lean_nat_dec_eq(x_4, x_4);
+if (x_25 == 0)
 {
-lean_object* x_27; lean_object* x_28; 
-lean_dec(x_5);
-x_27 = l_Lean_nullKind;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_25, x_27, x_6);
-return x_28;
+lean_object* x_26; lean_object* x_27; 
+lean_dec(x_4);
+x_26 = l_Lean_nullKind;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_5);
+return x_27;
 }
 else
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_ParserState_restore(x_25, x_6, x_5);
-x_30 = l_Lean_nullKind;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_6);
-return x_31;
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_ParserState_restore(x_24, x_5, x_4);
+x_29 = l_Lean_nullKind;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_5);
+return x_30;
 }
 }
 }
@@ -1442,7 +1407,7 @@ lean_object* _init_l_Lean_Parser_optPrecedence___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_optPrecedence___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_optPrecedence___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1466,66 +1431,66 @@ x_1 = l_Lean_Parser_optPrecedence___closed__3;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-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; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-x_8 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_9 = lean_unsigned_to_nat(0u);
+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; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-x_10 = l_Lean_Parser_categoryParserFn(x_8, x_9, x_3, x_4);
-x_11 = lean_ctor_get(x_10, 3);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+x_6 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_7 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_8 = l_Lean_Parser_categoryParser___elambda__1(x_6, x_7, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_object* x_12; uint8_t x_13; 
-lean_dec(x_6);
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_7, x_12);
-lean_dec(x_12);
-lean_dec(x_7);
-if (x_13 == 0)
+lean_object* x_10; uint8_t x_11; 
+lean_dec(x_4);
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+x_11 = lean_nat_dec_eq(x_5, x_10);
+lean_dec(x_10);
+lean_dec(x_5);
+if (x_11 == 0)
 {
-x_4 = x_10;
+x_2 = x_8;
 goto _start;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; 
-lean_dec(x_3);
-x_15 = l_Lean_Parser_manyAux___main___closed__1;
-x_16 = l_Lean_Parser_ParserState_mkUnexpectedError(x_10, x_15);
-return x_16;
+lean_object* x_13; lean_object* x_14; 
+lean_dec(x_1);
+x_13 = l_Lean_Parser_manyAux___main___closed__1;
+x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
+return x_14;
 }
 }
 else
 {
-lean_object* x_17; uint8_t x_18; 
-lean_dec(x_11);
-lean_dec(x_3);
-x_17 = lean_ctor_get(x_10, 1);
-lean_inc(x_17);
-x_18 = lean_nat_dec_eq(x_7, x_17);
-lean_dec(x_17);
-if (x_18 == 0)
+lean_object* x_15; uint8_t x_16; 
+lean_dec(x_9);
+lean_dec(x_1);
+x_15 = lean_ctor_get(x_8, 1);
+lean_inc(x_15);
+x_16 = lean_nat_dec_eq(x_5, x_15);
+lean_dec(x_15);
+if (x_16 == 0)
 {
-lean_dec(x_7);
-lean_dec(x_6);
-return x_10;
+lean_dec(x_5);
+lean_dec(x_4);
+return x_8;
 }
 else
 {
-lean_object* x_19; 
-x_19 = l_Lean_Parser_ParserState_restore(x_10, x_6, x_7);
-lean_dec(x_6);
-return x_19;
+lean_object* x_17; 
+x_17 = l_Lean_Parser_ParserState_restore(x_8, x_4, x_5);
+lean_dec(x_4);
+return x_17;
 }
 }
 }
@@ -1571,267 +1536,259 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_paren___elambda__1___closed__5() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_paren___elambda__1___closed__4;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_paren___elambda__1___closed__4;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Syntax_paren___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_paren___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Syntax_paren___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_paren___elambda__1___closed__5;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_49; lean_object* x_67; lean_object* x_68; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_67 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_68 = lean_ctor_get(x_67, 3);
-lean_inc(x_68);
-if (lean_obj_tag(x_68) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_48; lean_object* x_65; lean_object* x_66; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_65 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_66 = lean_ctor_get(x_65, 3);
+lean_inc(x_66);
+if (lean_obj_tag(x_66) == 0)
 {
-lean_object* x_69; lean_object* x_70; 
-x_69 = lean_ctor_get(x_67, 0);
+lean_object* x_67; lean_object* x_68; 
+x_67 = lean_ctor_get(x_65, 0);
+lean_inc(x_67);
+x_68 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_67);
+lean_dec(x_67);
+if (lean_obj_tag(x_68) == 2)
+{
+lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_69 = lean_ctor_get(x_68, 1);
 lean_inc(x_69);
-x_70 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_69);
+lean_dec(x_68);
+x_70 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_71 = lean_string_dec_eq(x_69, x_70);
 lean_dec(x_69);
-if (lean_obj_tag(x_70) == 2)
+if (x_71 == 0)
 {
-lean_object* x_71; lean_object* x_72; uint8_t x_73; 
-x_71 = lean_ctor_get(x_70, 1);
-lean_inc(x_71);
-lean_dec(x_70);
-x_72 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_73 = lean_string_dec_eq(x_71, x_72);
-lean_dec(x_71);
-if (x_73 == 0)
+lean_object* x_72; lean_object* x_73; 
+x_72 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_72, x_7);
+x_48 = x_73;
+goto block_64;
+}
+else
+{
+x_48 = x_65;
+goto block_64;
+}
+}
+else
 {
 lean_object* x_74; lean_object* x_75; 
-x_74 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_74, x_8);
-x_49 = x_75;
-goto block_66;
-}
-else
-{
-x_49 = x_67;
-goto block_66;
+lean_dec(x_68);
+x_74 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_74, x_7);
+x_48 = x_75;
+goto block_64;
 }
 }
 else
 {
 lean_object* x_76; lean_object* x_77; 
-lean_dec(x_70);
-x_76 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_76, x_8);
-x_49 = x_77;
-goto block_66;
+lean_dec(x_66);
+x_76 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_76, x_7);
+x_48 = x_77;
+goto block_64;
 }
-}
-else
+block_47:
 {
-lean_object* x_78; lean_object* x_79; 
-lean_dec(x_68);
-x_78 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_78, x_8);
-x_49 = x_79;
-goto block_66;
-}
-block_48:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_16, 1);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_19 = l_Lean_Parser_tokenFn(x_1, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = lean_ctor_get(x_17, 1);
-lean_inc(x_19);
-x_20 = l_Lean_Parser_tokenFn(x_2, x_17);
-x_21 = lean_ctor_get(x_20, 3);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_object* x_22; lean_object* x_23; 
-x_22 = lean_ctor_get(x_20, 0);
-lean_inc(x_22);
-x_23 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_22);
-lean_dec(x_22);
-if (lean_obj_tag(x_23) == 2)
-{
-lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_24 = lean_ctor_get(x_23, 1);
-lean_inc(x_24);
-lean_dec(x_23);
-x_25 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_26 = lean_string_dec_eq(x_24, x_25);
-lean_dec(x_24);
-if (x_26 == 0)
-{
-lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_27 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_27, x_19);
-x_29 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-lean_dec(x_19);
-x_32 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_20, x_32, x_16);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_8);
-lean_dec(x_8);
-return x_34;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_23);
-x_35 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_35, x_19);
-x_37 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_16);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_8);
-lean_dec(x_8);
-return x_39;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
 lean_dec(x_21);
-x_40 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_40, x_19);
-x_42 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_16);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_11, x_8);
-lean_dec(x_8);
-return x_44;
-}
+if (lean_obj_tag(x_22) == 2)
+{
+lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 1);
+lean_inc(x_23);
+lean_dec(x_22);
+x_24 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_25 = lean_string_dec_eq(x_23, x_24);
+lean_dec(x_23);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_26 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18);
+x_28 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
 lean_dec(x_18);
-lean_dec(x_2);
-x_45 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_17, x_45, x_16);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_11, x_8);
-lean_dec(x_8);
-return x_47;
+x_31 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_19, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
 }
 }
-block_66:
+else
 {
-lean_object* x_50; 
-x_50 = lean_ctor_get(x_49, 3);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_22);
+x_34 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_34, x_18);
+x_36 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_20);
+x_39 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_39, x_18);
+x_41 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_44 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_16, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+block_64:
+{
+lean_object* x_49; 
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+x_50 = lean_ctor_get(x_48, 0);
 lean_inc(x_50);
-if (lean_obj_tag(x_50) == 0)
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_51 = lean_ctor_get(x_49, 0);
-lean_inc(x_51);
-x_52 = lean_array_get_size(x_51);
-lean_dec(x_51);
-x_53 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_54 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_55 = l_Lean_Parser_categoryParserFn(x_53, x_54, x_2, x_49);
-x_56 = lean_ctor_get(x_55, 3);
-lean_inc(x_56);
-if (lean_obj_tag(x_56) == 0)
-{
-uint8_t x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_57 = 0;
-lean_inc(x_2);
-x_58 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(x_57, x_1, x_2, x_55);
-lean_dec(x_1);
-x_59 = l_Lean_nullKind;
-x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_52);
-x_17 = x_60;
-goto block_48;
-}
-else
-{
-lean_object* x_61; lean_object* x_62; 
-lean_dec(x_56);
-lean_dec(x_1);
-x_61 = l_Lean_nullKind;
-x_62 = l_Lean_Parser_ParserState_mkNode(x_55, x_61, x_52);
-x_17 = x_62;
-goto block_48;
-}
-}
-else
-{
-lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_51 = lean_array_get_size(x_50);
 lean_dec(x_50);
-lean_dec(x_2);
+x_52 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_53 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_54 = l_Lean_Parser_categoryParser___elambda__1(x_52, x_53, x_1, x_48);
+x_55 = lean_ctor_get(x_54, 3);
+lean_inc(x_55);
+if (lean_obj_tag(x_55) == 0)
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+lean_inc(x_1);
+x_56 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(x_1, x_54);
+x_57 = l_Lean_nullKind;
+x_58 = l_Lean_Parser_ParserState_mkNode(x_56, x_57, x_51);
+x_16 = x_58;
+goto block_47;
+}
+else
+{
+lean_object* x_59; lean_object* x_60; 
+lean_dec(x_55);
+x_59 = l_Lean_nullKind;
+x_60 = l_Lean_Parser_ParserState_mkNode(x_54, x_59, x_51);
+x_16 = x_60;
+goto block_47;
+}
+}
+else
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+lean_dec(x_49);
 lean_dec(x_1);
-x_63 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
-x_64 = l_Lean_Parser_ParserState_mkNode(x_49, x_63, x_16);
-x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_11, x_8);
-lean_dec(x_8);
-return x_65;
+x_61 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
+x_62 = l_Lean_Parser_ParserState_mkNode(x_48, x_61, x_15);
+x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_10, x_7);
+lean_dec(x_7);
+return x_63;
 }
 }
 }
@@ -1841,12 +1798,11 @@ return x_65;
 lean_object* _init_l_Lean_Parser_Syntax_paren___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_2 = lean_unsigned_to_nat(0u);
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_paren___closed__2() {
@@ -1856,7 +1812,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4;
 x_1 = l_Lean_Parser_Syntax_paren___closed__1;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
@@ -1865,7 +1821,7 @@ lean_object* _init_l_Lean_Parser_Syntax_paren___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 x_2 = l_Lean_Parser_Syntax_paren___closed__2;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
@@ -1897,7 +1853,7 @@ lean_object* _init_l_Lean_Parser_Syntax_paren___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_paren___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_paren___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1921,24 +1877,13 @@ x_1 = l_Lean_Parser_Syntax_paren___closed__7;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_6;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_paren(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_paren;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -1975,101 +1920,90 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_cat___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Syntax_cat___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_cat___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Syntax_cat___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_cat___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Syntax_cat___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_cat___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_cat___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Syntax_cat___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
 lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_16 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_22 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -2079,7 +2013,7 @@ lean_object* _init_l_Lean_Parser_Syntax_cat___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_optPrecedence;
@@ -2115,7 +2049,7 @@ lean_object* _init_l_Lean_Parser_Syntax_cat___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_cat___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_cat___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2142,10 +2076,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_cat(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_cat;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2182,101 +2116,90 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_atom___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Syntax_atom___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_atom___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Syntax_atom___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_atom___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Syntax_atom___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_atom___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_str___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_atom___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Syntax_atom___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
 lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_16 = l_Lean_Parser_strLit___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_22 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -2286,7 +2209,7 @@ lean_object* _init_l_Lean_Parser_Syntax_atom___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Term_str___elambda__1___closed__5;
+x_1 = l_Lean_Parser_strLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_optPrecedence;
@@ -2322,7 +2245,7 @@ lean_object* _init_l_Lean_Parser_Syntax_atom___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_atom___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_atom___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2349,10 +2272,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_atom(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_atom;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2381,13 +2304,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_num___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Level_num___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_num___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Level_num___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_num___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_num___elambda__1___closed__4() {
@@ -2419,66 +2341,66 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_num___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_num___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Syntax_num___elambda__1___closed__3;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_num___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Syntax_num___elambda__1___closed__4;
+x_17 = l_Lean_Parser_Syntax_num___elambda__1___closed__6;
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = l_Lean_Parser_Syntax_num___elambda__1___closed__1;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Syntax_num___elambda__1___closed__4;
-x_18 = l_Lean_Parser_Syntax_num___elambda__1___closed__6;
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = l_Lean_Parser_Syntax_num___elambda__1___closed__1;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+return x_21;
 }
 }
 }
@@ -2519,7 +2441,7 @@ lean_object* _init_l_Lean_Parser_Syntax_num___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_num___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_num___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2546,10 +2468,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_num(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_num___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_num___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_num;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2578,13 +2500,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_str___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_str___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_str___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_str___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_str___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_str___elambda__1___closed__4() {
@@ -2616,66 +2537,66 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_str___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_str___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Syntax_str___elambda__1___closed__3;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_str___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Syntax_str___elambda__1___closed__4;
+x_17 = l_Lean_Parser_Syntax_str___elambda__1___closed__6;
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = l_Lean_Parser_Syntax_str___elambda__1___closed__1;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Syntax_str___elambda__1___closed__4;
-x_18 = l_Lean_Parser_Syntax_str___elambda__1___closed__6;
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = l_Lean_Parser_Syntax_str___elambda__1___closed__1;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+return x_21;
 }
 }
 }
@@ -2716,7 +2637,7 @@ lean_object* _init_l_Lean_Parser_Syntax_str___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_str___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_str___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2743,10 +2664,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_str(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_str___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_str___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_str;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2775,13 +2696,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_char___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_char___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_char___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_char___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_char___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_char___elambda__1___closed__4() {
@@ -2813,66 +2733,66 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_char___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_char___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Syntax_char___elambda__1___closed__3;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_char___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Syntax_char___elambda__1___closed__4;
+x_17 = l_Lean_Parser_Syntax_char___elambda__1___closed__6;
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = l_Lean_Parser_Syntax_char___elambda__1___closed__1;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Syntax_char___elambda__1___closed__4;
-x_18 = l_Lean_Parser_Syntax_char___elambda__1___closed__6;
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = l_Lean_Parser_Syntax_char___elambda__1___closed__1;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+return x_21;
 }
 }
 }
@@ -2913,7 +2833,7 @@ lean_object* _init_l_Lean_Parser_Syntax_char___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_char___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_char___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2940,10 +2860,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_char(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_char___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_char___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_char;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2972,13 +2892,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_ident___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_identKind___closed__1;
-x_3 = l_Lean_Parser_Syntax_ident___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_identKind___closed__1;
+x_2 = l_Lean_Parser_Syntax_ident___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_ident___elambda__1___closed__4() {
@@ -3010,66 +2929,66 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_ident___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_ident___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Syntax_ident___elambda__1___closed__3;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_ident___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Syntax_ident___elambda__1___closed__4;
+x_17 = l_Lean_Parser_Syntax_ident___elambda__1___closed__6;
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = l_Lean_Parser_Syntax_ident___elambda__1___closed__1;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Syntax_ident___elambda__1___closed__4;
-x_18 = l_Lean_Parser_Syntax_ident___elambda__1___closed__6;
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = l_Lean_Parser_Syntax_ident___elambda__1___closed__1;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+return x_21;
 }
 }
 }
@@ -3110,7 +3029,7 @@ lean_object* _init_l_Lean_Parser_Syntax_ident___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_ident___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_ident___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3137,10 +3056,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_ident(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_ident___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_ident___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_ident;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -3177,13 +3096,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_try___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Syntax_try___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_try___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Syntax_try___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_try___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_try___elambda__1___closed__5() {
@@ -3223,86 +3141,86 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_try___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_try___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Syntax_try___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_try___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Syntax_try___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Syntax_try___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Syntax_try___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Syntax_try___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_21 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_22 = l_Lean_Parser_appPrec;
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = l_Lean_Parser_Syntax_try___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_20 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_21 = l_Lean_Parser_appPrec;
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+x_23 = l_Lean_Parser_Syntax_try___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_27 = l_Lean_Parser_Syntax_try___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_19, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_26 = l_Lean_Parser_Syntax_try___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 }
@@ -3321,12 +3239,11 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Syntax_try___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_3 = l_Lean_Parser_appPrec;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_2 = l_Lean_Parser_appPrec;
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_try___closed__3() {
@@ -3367,7 +3284,7 @@ lean_object* _init_l_Lean_Parser_Syntax_try___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_try___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_try___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3394,10 +3311,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_try(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_try___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_try___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_try;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -3434,13 +3351,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_lookahead___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_lookahead___elambda__1___closed__5() {
@@ -3480,86 +3396,86 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_lookahead___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_lookahead___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Syntax_lookahead___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_21 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_22 = l_Lean_Parser_appPrec;
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_20 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_21 = l_Lean_Parser_appPrec;
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+x_23 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_27 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_19, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_26 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 }
@@ -3613,7 +3529,7 @@ lean_object* _init_l_Lean_Parser_Syntax_lookahead___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_lookahead___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_lookahead___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3640,10 +3556,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_lookahead(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_lookahead___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_lookahead;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -3680,13 +3596,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_sepBy___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_sepBy___elambda__1___closed__5() {
@@ -3726,105 +3641,105 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Syntax_sepBy___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_21 = l_Lean_Parser_appPrec;
+lean_inc(x_1);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+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_object* x_27; 
+x_24 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_22);
+x_25 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-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_24; 
-x_21 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_22 = l_Lean_Parser_appPrec;
-lean_inc(x_2);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_25 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_23);
-x_26 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
+return x_27;
 }
 else
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-lean_dec(x_24);
-lean_dec(x_2);
-x_29 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_23);
+lean_dec(x_1);
+x_28 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
 }
 }
 else
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_32 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_19, x_32, x_16);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_8);
-lean_dec(x_8);
-return x_34;
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_31 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_18, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
 }
 }
 }
@@ -3888,7 +3803,7 @@ lean_object* _init_l_Lean_Parser_Syntax_sepBy___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_sepBy___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_sepBy___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3915,10 +3830,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_sepBy(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_sepBy;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -3955,13 +3870,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__5() {
@@ -4001,105 +3915,105 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Syntax_sepBy1___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_21 = l_Lean_Parser_appPrec;
+lean_inc(x_1);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+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_object* x_27; 
+x_24 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_22);
+x_25 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-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_24; 
-x_21 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_22 = l_Lean_Parser_appPrec;
-lean_inc(x_2);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_25 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_23);
-x_26 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
+return x_27;
 }
 else
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-lean_dec(x_24);
-lean_dec(x_2);
-x_29 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_23);
+lean_dec(x_1);
+x_28 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
 }
 }
 else
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_32 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_19, x_32, x_16);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_8);
-lean_dec(x_8);
-return x_34;
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_31 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_18, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
 }
 }
 }
@@ -4151,7 +4065,7 @@ lean_object* _init_l_Lean_Parser_Syntax_sepBy1___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_sepBy1___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_sepBy1___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4178,16 +4092,16 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_sepBy1(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Syntax_sepBy1;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* _init_l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Syntax_optional___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -4195,17 +4109,17 @@ x_1 = lean_mk_string("optional");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_Syntax_optional___elambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Syntax_paren___elambda__1___closed__2;
-x_2 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Syntax_optional___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_optional___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Syntax_optional___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
@@ -4223,7 +4137,7 @@ if (lean_obj_tag(x_7) == 0)
 lean_object* x_8; lean_object* x_9; 
 x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
-x_9 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_8);
+x_9 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_8);
 lean_dec(x_8);
 if (lean_obj_tag(x_9) == 2)
 {
@@ -4239,7 +4153,7 @@ if (x_12 == 0)
 lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
 x_13 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
 x_14 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_13, x_5);
-x_15 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2;
+x_15 = l_Lean_Parser_Syntax_optional___elambda__1___closed__2;
 x_16 = l_Lean_Parser_ParserState_mkTrailingNode(x_14, x_15, x_4);
 lean_dec(x_4);
 return x_16;
@@ -4248,7 +4162,7 @@ else
 {
 lean_object* x_17; lean_object* x_18; 
 lean_dec(x_5);
-x_17 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2;
+x_17 = l_Lean_Parser_Syntax_optional___elambda__1___closed__2;
 x_18 = l_Lean_Parser_ParserState_mkTrailingNode(x_6, x_17, x_4);
 lean_dec(x_4);
 return x_18;
@@ -4260,7 +4174,7 @@ lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22;
 lean_dec(x_9);
 x_19 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
 x_20 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_19, x_5);
-x_21 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2;
+x_21 = l_Lean_Parser_Syntax_optional___elambda__1___closed__2;
 x_22 = l_Lean_Parser_ParserState_mkTrailingNode(x_20, x_21, x_4);
 lean_dec(x_4);
 return x_22;
@@ -4272,21 +4186,13 @@ lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26;
 lean_dec(x_7);
 x_23 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
 x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_23, x_5);
-x_25 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2;
+x_25 = l_Lean_Parser_Syntax_optional___elambda__1___closed__2;
 x_26 = l_Lean_Parser_ParserState_mkTrailingNode(x_24, x_25, x_4);
 lean_dec(x_4);
 return x_26;
 }
 }
 }
-lean_object* l_Lean_Parser_Syntax_optional___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_optional___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Syntax_optional___closed__1() {
 _start:
 {
@@ -4301,7 +4207,7 @@ lean_object* _init_l_Lean_Parser_Syntax_optional___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2;
+x_1 = l_Lean_Parser_Syntax_optional___elambda__1___closed__2;
 x_2 = l_Lean_Parser_Syntax_optional___closed__1;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
@@ -4311,7 +4217,7 @@ lean_object* _init_l_Lean_Parser_Syntax_optional___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_optional___elambda__1___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_optional___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4335,28 +4241,19 @@ x_1 = l_Lean_Parser_Syntax_optional___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Syntax_optional___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Syntax_optional___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_optional(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_optional___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Syntax_optional;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* _init_l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Syntax_many___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -4364,49 +4261,49 @@ x_1 = lean_mk_string("many");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_Syntax_many___elambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Syntax_paren___elambda__1___closed__2;
-x_2 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Syntax_many___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__3() {
+lean_object* _init_l_Lean_Parser_Syntax_many___elambda__1___closed__3() {
 _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_mkAntiquotAux___closed__10;
+x_2 = l_Lean_Parser_mkAntiquot___closed__8;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__4() {
+lean_object* _init_l_Lean_Parser_Syntax_many___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__3;
+x_1 = l_Lean_Parser_Syntax_many___elambda__1___closed__3;
 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_Syntax_many___elambda__1___rarg___closed__5() {
+lean_object* _init_l_Lean_Parser_Syntax_many___elambda__1___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__4;
+x_2 = l_Lean_Parser_Syntax_many___elambda__1___closed__4;
 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* l_Lean_Parser_Syntax_many___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Syntax_many___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
@@ -4424,7 +4321,7 @@ if (lean_obj_tag(x_7) == 0)
 lean_object* x_8; lean_object* x_9; 
 x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
-x_9 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_8);
+x_9 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_8);
 lean_dec(x_8);
 if (lean_obj_tag(x_9) == 2)
 {
@@ -4432,15 +4329,15 @@ lean_object* x_10; lean_object* x_11; uint8_t x_12;
 x_10 = lean_ctor_get(x_9, 1);
 lean_inc(x_10);
 lean_dec(x_9);
-x_11 = l_Lean_Parser_mkAntiquotAux___closed__10;
+x_11 = l_Lean_Parser_mkAntiquot___closed__8;
 x_12 = lean_string_dec_eq(x_10, x_11);
 lean_dec(x_10);
 if (x_12 == 0)
 {
 lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_13 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__5;
+x_13 = l_Lean_Parser_Syntax_many___elambda__1___closed__5;
 x_14 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_13, x_5);
-x_15 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2;
+x_15 = l_Lean_Parser_Syntax_many___elambda__1___closed__2;
 x_16 = l_Lean_Parser_ParserState_mkTrailingNode(x_14, x_15, x_4);
 lean_dec(x_4);
 return x_16;
@@ -4449,7 +4346,7 @@ else
 {
 lean_object* x_17; lean_object* x_18; 
 lean_dec(x_5);
-x_17 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2;
+x_17 = l_Lean_Parser_Syntax_many___elambda__1___closed__2;
 x_18 = l_Lean_Parser_ParserState_mkTrailingNode(x_6, x_17, x_4);
 lean_dec(x_4);
 return x_18;
@@ -4459,9 +4356,9 @@ else
 {
 lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
 lean_dec(x_9);
-x_19 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__5;
+x_19 = l_Lean_Parser_Syntax_many___elambda__1___closed__5;
 x_20 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_19, x_5);
-x_21 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2;
+x_21 = l_Lean_Parser_Syntax_many___elambda__1___closed__2;
 x_22 = l_Lean_Parser_ParserState_mkTrailingNode(x_20, x_21, x_4);
 lean_dec(x_4);
 return x_22;
@@ -4471,29 +4368,21 @@ else
 {
 lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
 lean_dec(x_7);
-x_23 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__5;
+x_23 = l_Lean_Parser_Syntax_many___elambda__1___closed__5;
 x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_23, x_5);
-x_25 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2;
+x_25 = l_Lean_Parser_Syntax_many___elambda__1___closed__2;
 x_26 = l_Lean_Parser_ParserState_mkTrailingNode(x_24, x_25, x_4);
 lean_dec(x_4);
 return x_26;
 }
 }
 }
-lean_object* l_Lean_Parser_Syntax_many___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_many___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Syntax_many___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2;
-x_2 = l_Lean_Parser_mkAntiquotAux___closed__11;
+x_1 = l_Lean_Parser_Syntax_many___elambda__1___closed__2;
+x_2 = l_Lean_Parser_mkAntiquot___closed__9;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
 }
@@ -4502,7 +4391,7 @@ lean_object* _init_l_Lean_Parser_Syntax_many___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_many___elambda__1___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_many___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4526,28 +4415,19 @@ x_1 = l_Lean_Parser_Syntax_many___closed__3;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Syntax_many___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Syntax_many___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_many(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_many___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Syntax_many;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* _init_l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Syntax_many1___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -4555,17 +4435,17 @@ x_1 = lean_mk_string("many1");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_Syntax_many1___elambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Syntax_paren___elambda__1___closed__2;
-x_2 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Syntax_many1___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_many1___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Syntax_many1___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
@@ -4583,7 +4463,7 @@ if (lean_obj_tag(x_7) == 0)
 lean_object* x_8; lean_object* x_9; 
 x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
-x_9 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_8);
+x_9 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_8);
 lean_dec(x_8);
 if (lean_obj_tag(x_9) == 2)
 {
@@ -4597,9 +4477,9 @@ lean_dec(x_10);
 if (x_12 == 0)
 {
 lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_13 = l_Lean_Parser_Level_addLit___elambda__1___closed__7;
+x_13 = l_Lean_Parser_Level_addLit___elambda__1___closed__6;
 x_14 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_13, x_5);
-x_15 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2;
+x_15 = l_Lean_Parser_Syntax_many1___elambda__1___closed__2;
 x_16 = l_Lean_Parser_ParserState_mkTrailingNode(x_14, x_15, x_4);
 lean_dec(x_4);
 return x_16;
@@ -4608,7 +4488,7 @@ else
 {
 lean_object* x_17; lean_object* x_18; 
 lean_dec(x_5);
-x_17 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2;
+x_17 = l_Lean_Parser_Syntax_many1___elambda__1___closed__2;
 x_18 = l_Lean_Parser_ParserState_mkTrailingNode(x_6, x_17, x_4);
 lean_dec(x_4);
 return x_18;
@@ -4618,9 +4498,9 @@ else
 {
 lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
 lean_dec(x_9);
-x_19 = l_Lean_Parser_Level_addLit___elambda__1___closed__7;
+x_19 = l_Lean_Parser_Level_addLit___elambda__1___closed__6;
 x_20 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_19, x_5);
-x_21 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2;
+x_21 = l_Lean_Parser_Syntax_many1___elambda__1___closed__2;
 x_22 = l_Lean_Parser_ParserState_mkTrailingNode(x_20, x_21, x_4);
 lean_dec(x_4);
 return x_22;
@@ -4630,23 +4510,15 @@ else
 {
 lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
 lean_dec(x_7);
-x_23 = l_Lean_Parser_Level_addLit___elambda__1___closed__7;
+x_23 = l_Lean_Parser_Level_addLit___elambda__1___closed__6;
 x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_23, x_5);
-x_25 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2;
+x_25 = l_Lean_Parser_Syntax_many1___elambda__1___closed__2;
 x_26 = l_Lean_Parser_ParserState_mkTrailingNode(x_24, x_25, x_4);
 lean_dec(x_4);
 return x_26;
 }
 }
 }
-lean_object* l_Lean_Parser_Syntax_many1___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_many1___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Syntax_many1___closed__1() {
 _start:
 {
@@ -4661,7 +4533,7 @@ lean_object* _init_l_Lean_Parser_Syntax_many1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2;
+x_1 = l_Lean_Parser_Syntax_many1___elambda__1___closed__2;
 x_2 = l_Lean_Parser_Syntax_many1___closed__1;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
@@ -4671,7 +4543,7 @@ lean_object* _init_l_Lean_Parser_Syntax_many1___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_many1___elambda__1___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_many1___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4695,28 +4567,19 @@ x_1 = l_Lean_Parser_Syntax_many1___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Syntax_many1___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Syntax_many1___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_many1(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_many1___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Syntax_many1;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* _init_l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Syntax_orelse___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -4726,7 +4589,7 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Syntax_orelse___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Syntax_orelse___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
@@ -4745,7 +4608,7 @@ if (lean_obj_tag(x_17) == 0)
 lean_object* x_18; lean_object* x_19; 
 x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-x_19 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_18);
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
 if (lean_obj_tag(x_19) == 2)
 {
@@ -4753,13 +4616,13 @@ lean_object* x_20; lean_object* x_21; uint8_t x_22;
 x_20 = lean_ctor_get(x_19, 1);
 lean_inc(x_20);
 lean_dec(x_19);
-x_21 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__2;
+x_21 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__2;
 x_22 = lean_string_dec_eq(x_20, x_21);
 lean_dec(x_20);
 if (x_22 == 0)
 {
 lean_object* x_23; lean_object* x_24; 
-x_23 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5;
+x_23 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5;
 x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_15);
 x_5 = x_24;
 goto block_14;
@@ -4775,7 +4638,7 @@ else
 {
 lean_object* x_25; lean_object* x_26; 
 lean_dec(x_19);
-x_25 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5;
+x_25 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5;
 x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_25, x_15);
 x_5 = x_26;
 goto block_14;
@@ -4785,7 +4648,7 @@ else
 {
 lean_object* x_27; lean_object* x_28; 
 lean_dec(x_17);
-x_27 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5;
+x_27 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5;
 x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_27, x_15);
 x_5 = x_28;
 goto block_14;
@@ -4800,8 +4663,8 @@ if (lean_obj_tag(x_6) == 0)
 lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_7 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
 x_8 = lean_unsigned_to_nat(1u);
-x_9 = l_Lean_Parser_categoryParserFn(x_7, x_8, x_1, x_5);
-x_10 = l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1;
+x_9 = l_Lean_Parser_categoryParser___elambda__1(x_7, x_8, x_1, x_5);
+x_10 = l_Lean_Parser_Syntax_orelse___elambda__1___closed__1;
 x_11 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_10, x_4);
 lean_dec(x_4);
 return x_11;
@@ -4811,7 +4674,7 @@ else
 lean_object* x_12; lean_object* x_13; 
 lean_dec(x_6);
 lean_dec(x_1);
-x_12 = l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1;
+x_12 = l_Lean_Parser_Syntax_orelse___elambda__1___closed__1;
 x_13 = l_Lean_Parser_ParserState_mkTrailingNode(x_5, x_12, x_4);
 lean_dec(x_4);
 return x_13;
@@ -4819,23 +4682,14 @@ return x_13;
 }
 }
 }
-lean_object* l_Lean_Parser_Syntax_orelse___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_orelse___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Syntax_orelse___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 1;
-x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_3 = lean_unsigned_to_nat(1u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_2 = lean_unsigned_to_nat(1u);
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Syntax_orelse___closed__2() {
@@ -4854,7 +4708,7 @@ lean_object* _init_l_Lean_Parser_Syntax_orelse___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1;
+x_1 = l_Lean_Parser_Syntax_orelse___elambda__1___closed__1;
 x_2 = l_Lean_Parser_Syntax_orelse___closed__2;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
@@ -4864,7 +4718,7 @@ lean_object* _init_l_Lean_Parser_Syntax_orelse___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_orelse___elambda__1___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_orelse___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4888,22 +4742,13 @@ x_1 = l_Lean_Parser_Syntax_orelse___closed__5;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Syntax_orelse___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Syntax_orelse___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Syntax_orelse(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_4 = l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_3 = l_Lean_Parser_Syntax_orelse___elambda__1___closed__1;
+x_4 = 0;
 x_5 = l_Lean_Parser_Syntax_orelse;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -4940,95 +4785,89 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_quotedSymbolPrec___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = 0;
-x_18 = l_Lean_Parser_quotedSymbolFn(x_17, x_1, x_2, x_14);
-x_19 = lean_ctor_get(x_18, 3);
-lean_inc(x_19);
-if (lean_obj_tag(x_19) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_quotedSymbolFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_20 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_2, x_18);
-x_21 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__2;
-x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_16);
-x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_11, x_8);
-lean_dec(x_8);
-return x_23;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
 }
 else
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-lean_dec(x_19);
-lean_dec(x_2);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_24 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+x_22 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -5037,17 +4876,8 @@ return x_26;
 lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_quotedSymbol(x_1);
-return x_2;
-}
-}
-lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__2() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Command_quotedSymbolPrec___closed__1;
+x_1 = l_Lean_Parser_quotedSymbol;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_optPrecedence;
@@ -5057,42 +4887,42 @@ x_5 = l_Lean_Parser_andthenInfo(x_2, x_4);
 return x_5;
 }
 }
-lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__3() {
+lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__2;
-x_2 = l_Lean_Parser_Command_quotedSymbolPrec___closed__2;
+x_2 = l_Lean_Parser_Command_quotedSymbolPrec___closed__1;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__4() {
+lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1___closed__4;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_Command_quotedSymbolPrec___closed__3;
+x_3 = l_Lean_Parser_Command_quotedSymbolPrec___closed__2;
 x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
 return x_4;
 }
 }
+lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__4() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_quotedSymbolPrec___elambda__1), 2, 0);
+return x_1;
+}
+}
 lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__5() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_quotedSymbolPrec___elambda__1), 3, 0);
-return x_1;
-}
-}
-lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__6() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Command_quotedSymbolPrec___closed__4;
-x_2 = l_Lean_Parser_Command_quotedSymbolPrec___closed__5;
+x_1 = l_Lean_Parser_Command_quotedSymbolPrec___closed__3;
+x_2 = l_Lean_Parser_Command_quotedSymbolPrec___closed__4;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -5103,7 +4933,7 @@ lean_object* _init_l_Lean_Parser_Command_quotedSymbolPrec() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Command_quotedSymbolPrec___closed__6;
+x_1 = l_Lean_Parser_Command_quotedSymbolPrec___closed__5;
 return x_1;
 }
 }
@@ -5138,13 +4968,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_prefix___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_prefix___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_prefix___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_prefix___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_prefix___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_prefix___elambda__1___closed__5() {
@@ -5188,125 +5017,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_prefix___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_prefix___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_prefix___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_prefix___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_prefix___elambda__1___closed__5;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_prefix___elambda__1___closed__8;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_prefix___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_prefix___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_prefix___elambda__1___closed__8;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_prefix___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_prefix___elambda__1___closed__8;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_prefix___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_prefix___elambda__1___closed__5;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_prefix___elambda__1___closed__8;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_prefix___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_prefix___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_prefix___elambda__1___closed__8;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_prefix___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_prefix___elambda__1___closed__8;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_prefix___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -5348,7 +5177,7 @@ lean_object* _init_l_Lean_Parser_Command_prefix___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_prefix___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_prefix___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5403,13 +5232,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_infix___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_infix___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_infix___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_infix___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_infix___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_infix___elambda__1___closed__5() {
@@ -5453,125 +5281,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_infix___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_infix___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_infix___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_infix___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_infix___elambda__1___closed__5;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_infix___elambda__1___closed__8;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_infix___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_infix___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_infix___elambda__1___closed__8;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_infix___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_infix___elambda__1___closed__8;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_infix___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_infix___elambda__1___closed__5;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_infix___elambda__1___closed__8;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_infix___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_infix___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_infix___elambda__1___closed__8;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_infix___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_infix___elambda__1___closed__8;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_infix___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -5613,7 +5441,7 @@ lean_object* _init_l_Lean_Parser_Command_infix___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_infix___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_infix___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5668,13 +5496,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_infixl___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_infixl___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_infixl___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_infixl___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_infixl___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_infixl___elambda__1___closed__5() {
@@ -5718,125 +5545,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_infixl___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_infixl___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_infixl___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_infixl___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_infixl___elambda__1___closed__5;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_infixl___elambda__1___closed__8;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_infixl___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_infixl___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_infixl___elambda__1___closed__8;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_infixl___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_infixl___elambda__1___closed__8;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_infixl___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_infixl___elambda__1___closed__5;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_infixl___elambda__1___closed__8;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_infixl___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_infixl___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_infixl___elambda__1___closed__8;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_infixl___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_infixl___elambda__1___closed__8;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_infixl___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -5878,7 +5705,7 @@ lean_object* _init_l_Lean_Parser_Command_infixl___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_infixl___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_infixl___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5933,13 +5760,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_infixr___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_infixr___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_infixr___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_infixr___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_infixr___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_infixr___elambda__1___closed__5() {
@@ -5983,125 +5809,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_infixr___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_infixr___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_infixr___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_infixr___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_infixr___elambda__1___closed__5;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_infixr___elambda__1___closed__8;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_infixr___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_infixr___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_infixr___elambda__1___closed__8;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_infixr___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_infixr___elambda__1___closed__8;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_infixr___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_infixr___elambda__1___closed__5;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_infixr___elambda__1___closed__8;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_infixr___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_infixr___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_infixr___elambda__1___closed__8;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_infixr___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_infixr___elambda__1___closed__8;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_infixr___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -6143,7 +5969,7 @@ lean_object* _init_l_Lean_Parser_Command_infixr___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_infixr___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_infixr___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6198,13 +6024,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_postfix___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_postfix___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_postfix___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_postfix___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_postfix___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_postfix___elambda__1___closed__5() {
@@ -6248,125 +6073,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_postfix___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_postfix___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_postfix___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_postfix___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Command_postfix___elambda__1___closed__5;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Command_postfix___elambda__1___closed__8;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Command_postfix___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Command_postfix___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Command_postfix___elambda__1___closed__8;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Command_postfix___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Command_postfix___elambda__1___closed__8;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Command_postfix___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Command_postfix___elambda__1___closed__5;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Command_postfix___elambda__1___closed__8;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Command_postfix___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Command_postfix___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Command_postfix___elambda__1___closed__8;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Command_postfix___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Command_postfix___elambda__1___closed__8;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Command_postfix___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -6408,7 +6233,7 @@ lean_object* _init_l_Lean_Parser_Command_postfix___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_postfix___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_postfix___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6432,205 +6257,193 @@ x_1 = l_Lean_Parser_Command_postfix___closed__5;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_mixfixKind___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_mixfixKind___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Command_prefix___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
 lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-lean_inc(x_2);
-lean_inc(x_1);
-x_7 = l_Lean_Parser_Command_prefix___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_7;
-}
-else
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_7, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_10, x_6);
-lean_dec(x_10);
-if (x_11 == 0)
-{
+x_10 = lean_nat_dec_eq(x_9, x_5);
 lean_dec(x_9);
-lean_dec(x_6);
+if (x_10 == 0)
+{
+lean_dec(x_8);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_6);
-x_12 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
-lean_dec(x_5);
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-x_14 = lean_array_get_size(x_13);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = lean_ctor_get(x_11, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+lean_inc(x_1);
+x_14 = l_Lean_Parser_Command_infix___elambda__1(x_1, x_11);
+x_15 = lean_ctor_get(x_14, 3);
+lean_inc(x_15);
+if (lean_obj_tag(x_15) == 0)
+{
+lean_object* x_16; 
 lean_dec(x_13);
-lean_inc(x_2);
-lean_inc(x_1);
-x_15 = l_Lean_Parser_Command_infix___elambda__1(x_1, x_2, x_12);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; 
-lean_dec(x_14);
-lean_dec(x_2);
 lean_dec(x_1);
-x_17 = l_Lean_Parser_mergeOrElseErrors(x_15, x_9, x_6);
-lean_dec(x_6);
-return x_17;
+x_16 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_5);
+lean_dec(x_5);
+return x_16;
 }
 else
 {
-lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_18 = lean_ctor_get(x_16, 0);
+lean_object* x_17; lean_object* x_18; uint8_t x_19; 
+x_17 = lean_ctor_get(x_15, 0);
+lean_inc(x_17);
+lean_dec(x_15);
+x_18 = lean_ctor_get(x_14, 1);
 lean_inc(x_18);
-lean_dec(x_16);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_20 = lean_nat_dec_eq(x_19, x_6);
-lean_dec(x_19);
-if (x_20 == 0)
-{
-lean_object* x_21; 
+x_19 = lean_nat_dec_eq(x_18, x_5);
 lean_dec(x_18);
-lean_dec(x_14);
-lean_dec(x_2);
+if (x_19 == 0)
+{
+lean_object* x_20; 
+lean_dec(x_17);
+lean_dec(x_13);
 lean_dec(x_1);
-x_21 = l_Lean_Parser_mergeOrElseErrors(x_15, x_9, x_6);
-lean_dec(x_6);
-return x_21;
+x_20 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_5);
+lean_dec(x_5);
+return x_20;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-lean_inc(x_6);
-x_22 = l_Lean_Parser_ParserState_restore(x_15, x_14, x_6);
-lean_dec(x_14);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_inc(x_5);
+x_21 = l_Lean_Parser_ParserState_restore(x_14, x_13, x_5);
+lean_dec(x_13);
+x_22 = lean_ctor_get(x_21, 0);
+lean_inc(x_22);
+x_23 = lean_array_get_size(x_22);
+lean_dec(x_22);
+lean_inc(x_1);
+x_24 = l_Lean_Parser_Command_infixl___elambda__1(x_1, x_21);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_object* x_26; lean_object* x_27; 
 lean_dec(x_23);
-lean_inc(x_2);
-lean_inc(x_1);
-x_25 = l_Lean_Parser_Command_infixl___elambda__1(x_1, x_2, x_22);
-x_26 = lean_ctor_get(x_25, 3);
-lean_inc(x_26);
-if (lean_obj_tag(x_26) == 0)
-{
-lean_object* x_27; lean_object* x_28; 
-lean_dec(x_24);
-lean_dec(x_2);
 lean_dec(x_1);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_25, x_18, x_6);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_9, x_6);
-lean_dec(x_6);
-return x_28;
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_24, x_17, x_5);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_8, x_5);
+lean_dec(x_5);
+return x_27;
 }
 else
 {
-lean_object* x_29; lean_object* x_30; uint8_t x_31; 
-x_29 = lean_ctor_get(x_26, 0);
+lean_object* x_28; lean_object* x_29; uint8_t x_30; 
+x_28 = lean_ctor_get(x_25, 0);
+lean_inc(x_28);
+lean_dec(x_25);
+x_29 = lean_ctor_get(x_24, 1);
 lean_inc(x_29);
-lean_dec(x_26);
-x_30 = lean_ctor_get(x_25, 1);
-lean_inc(x_30);
-x_31 = lean_nat_dec_eq(x_30, x_6);
-lean_dec(x_30);
-if (x_31 == 0)
-{
-lean_object* x_32; lean_object* x_33; 
+x_30 = lean_nat_dec_eq(x_29, x_5);
 lean_dec(x_29);
-lean_dec(x_24);
-lean_dec(x_2);
+if (x_30 == 0)
+{
+lean_object* x_31; lean_object* x_32; 
+lean_dec(x_28);
+lean_dec(x_23);
 lean_dec(x_1);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_25, x_18, x_6);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_9, x_6);
-lean_dec(x_6);
-return x_33;
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_24, x_17, x_5);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_8, x_5);
+lean_dec(x_5);
+return x_32;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_inc(x_6);
-x_34 = l_Lean_Parser_ParserState_restore(x_25, x_24, x_6);
-lean_dec(x_24);
-x_35 = lean_ctor_get(x_34, 0);
-lean_inc(x_35);
-x_36 = lean_array_get_size(x_35);
-lean_dec(x_35);
-lean_inc(x_2);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_inc(x_5);
+x_33 = l_Lean_Parser_ParserState_restore(x_24, x_23, x_5);
+lean_dec(x_23);
+x_34 = lean_ctor_get(x_33, 0);
+lean_inc(x_34);
+x_35 = lean_array_get_size(x_34);
+lean_dec(x_34);
 lean_inc(x_1);
-x_37 = l_Lean_Parser_Command_infixr___elambda__1(x_1, x_2, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
+x_36 = l_Lean_Parser_Command_infixr___elambda__1(x_1, x_33);
+x_37 = lean_ctor_get(x_36, 3);
+lean_inc(x_37);
+if (lean_obj_tag(x_37) == 0)
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_36);
-lean_dec(x_2);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_35);
 lean_dec(x_1);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_37, x_29, x_6);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_18, x_6);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_9, x_6);
-lean_dec(x_6);
-return x_41;
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_36, x_28, x_5);
+x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_17, x_5);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_8, x_5);
+lean_dec(x_5);
+return x_40;
 }
 else
 {
-lean_object* x_42; lean_object* x_43; uint8_t x_44; 
-x_42 = lean_ctor_get(x_38, 0);
+lean_object* x_41; lean_object* x_42; uint8_t x_43; 
+x_41 = lean_ctor_get(x_37, 0);
+lean_inc(x_41);
+lean_dec(x_37);
+x_42 = lean_ctor_get(x_36, 1);
 lean_inc(x_42);
-lean_dec(x_38);
-x_43 = lean_ctor_get(x_37, 1);
-lean_inc(x_43);
-x_44 = lean_nat_dec_eq(x_43, x_6);
-lean_dec(x_43);
-if (x_44 == 0)
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+x_43 = lean_nat_dec_eq(x_42, x_5);
 lean_dec(x_42);
-lean_dec(x_36);
-lean_dec(x_2);
+if (x_43 == 0)
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_41);
+lean_dec(x_35);
 lean_dec(x_1);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_37, x_29, x_6);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_18, x_6);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_9, x_6);
-lean_dec(x_6);
-return x_47;
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_36, x_28, x_5);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_17, x_5);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_8, x_5);
+lean_dec(x_5);
+return x_46;
 }
 else
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_inc(x_6);
-x_48 = l_Lean_Parser_ParserState_restore(x_37, x_36, x_6);
-lean_dec(x_36);
-x_49 = l_Lean_Parser_Command_postfix___elambda__1(x_1, x_2, x_48);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_42, x_6);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_29, x_6);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_18, x_6);
-x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_9, x_6);
-lean_dec(x_6);
-return x_53;
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_inc(x_5);
+x_47 = l_Lean_Parser_ParserState_restore(x_36, x_35, x_5);
+lean_dec(x_35);
+x_48 = l_Lean_Parser_Command_postfix___elambda__1(x_1, x_47);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_41, x_5);
+x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_28, x_5);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_17, x_5);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_8, x_5);
+lean_dec(x_5);
+return x_52;
 }
 }
 }
@@ -6695,7 +6508,7 @@ lean_object* _init_l_Lean_Parser_Command_mixfixKind___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_mixfixKind___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_mixfixKind___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6750,13 +6563,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_reserve___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_reserve___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_reserve___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_reserve___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_reserve___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_reserve___elambda__1___closed__5() {
@@ -6808,164 +6620,158 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_reserve___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_reserve___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_reserve___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_reserve___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_32; lean_object* x_33; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_32 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_33 = lean_ctor_get(x_32, 3);
-lean_inc(x_33);
-if (lean_obj_tag(x_33) == 0)
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = lean_ctor_get(x_32, 0);
-lean_inc(x_34);
-x_35 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_34);
-lean_dec(x_34);
-if (lean_obj_tag(x_35) == 2)
-{
-lean_object* x_36; lean_object* x_37; uint8_t x_38; 
-x_36 = lean_ctor_get(x_35, 1);
-lean_inc(x_36);
-lean_dec(x_35);
-x_37 = l_Lean_Parser_Command_reserve___elambda__1___closed__6;
-x_38 = lean_string_dec_eq(x_36, x_37);
-lean_dec(x_36);
-if (x_38 == 0)
-{
-lean_object* x_39; lean_object* x_40; 
-x_39 = l_Lean_Parser_Command_reserve___elambda__1___closed__9;
-lean_inc(x_8);
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_39, x_8);
-x_17 = x_40;
-goto block_31;
-}
-else
-{
-x_17 = x_32;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_41; lean_object* x_42; 
-lean_dec(x_35);
-x_41 = l_Lean_Parser_Command_reserve___elambda__1___closed__9;
-lean_inc(x_8);
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_41, x_8);
-x_17 = x_42;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; 
-lean_dec(x_33);
-x_43 = l_Lean_Parser_Command_reserve___elambda__1___closed__9;
-lean_inc(x_8);
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_43, x_8);
-x_17 = x_44;
-goto block_31;
-}
-block_31:
-{
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_31; lean_object* x_32; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Command_mixfixKind___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_31 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_32 = lean_ctor_get(x_31, 3);
+lean_inc(x_32);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_reserve___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_33; lean_object* x_34; 
+x_33 = lean_ctor_get(x_31, 0);
+lean_inc(x_33);
+x_34 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_33);
+lean_dec(x_33);
+if (lean_obj_tag(x_34) == 2)
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = lean_ctor_get(x_34, 1);
+lean_inc(x_35);
+lean_dec(x_34);
+x_36 = l_Lean_Parser_Command_reserve___elambda__1___closed__6;
+x_37 = lean_string_dec_eq(x_35, x_36);
+lean_dec(x_35);
+if (x_37 == 0)
+{
+lean_object* x_38; lean_object* x_39; 
+x_38 = l_Lean_Parser_Command_reserve___elambda__1___closed__9;
+lean_inc(x_7);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_7);
+x_16 = x_39;
+goto block_30;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_reserve___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_31;
+goto block_30;
 }
 }
 else
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_34);
+x_40 = l_Lean_Parser_Command_reserve___elambda__1___closed__9;
+lean_inc(x_7);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_7);
+x_16 = x_41;
+goto block_30;
+}
+}
+else
+{
+lean_object* x_42; lean_object* x_43; 
+lean_dec(x_32);
+x_42 = l_Lean_Parser_Command_reserve___elambda__1___closed__9;
+lean_inc(x_7);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_7);
+x_16 = x_43;
+goto block_30;
+}
+block_30:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Command_mixfixKind___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(x_1, x_18);
+x_21 = l_Lean_Parser_Command_reserve___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_28 = l_Lean_Parser_Command_reserve___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_17, x_28, x_16);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_11, x_8);
-lean_dec(x_8);
-return x_30;
+x_24 = l_Lean_Parser_Command_reserve___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
+}
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_27 = l_Lean_Parser_Command_reserve___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_16, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
 }
 }
 }
@@ -7032,7 +6838,7 @@ lean_object* _init_l_Lean_Parser_Command_reserve___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_reserve___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_reserve___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7059,64 +6865,64 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_reserve(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_reserve___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_reserve___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_reserve;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_Command_mixfixSymbol___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_mixfixSymbol___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
 lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-lean_inc(x_2);
-x_7 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_2);
-return x_7;
-}
-else
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_7, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_10, x_6);
-lean_dec(x_10);
-if (x_11 == 0)
-{
+x_10 = lean_nat_dec_eq(x_9, x_5);
 lean_dec(x_9);
-lean_dec(x_6);
+if (x_10 == 0)
+{
+lean_dec(x_8);
 lean_dec(x_5);
-lean_dec(x_2);
-return x_7;
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-lean_inc(x_6);
-x_12 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = l_Lean_Parser_unquotedSymbolFn(x_1, x_11);
+x_13 = l_Lean_Parser_mergeOrElseErrors(x_12, x_8, x_5);
 lean_dec(x_5);
-x_13 = l_Lean_Parser_unquotedSymbolFn___rarg(x_2, x_12);
-x_14 = l_Lean_Parser_mergeOrElseErrors(x_13, x_9, x_6);
-lean_dec(x_6);
-return x_14;
+return x_13;
 }
 }
 }
@@ -7124,40 +6930,31 @@ return x_14;
 lean_object* _init_l_Lean_Parser_Command_mixfixSymbol___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_unquotedSymbol(x_1);
-return x_2;
-}
-}
-lean_object* _init_l_Lean_Parser_Command_mixfixSymbol___closed__2() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_1 = l_Lean_Parser_Command_quotedSymbolPrec;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_Command_mixfixSymbol___closed__1;
+x_3 = l_Lean_Parser_unquotedSymbol;
 x_4 = lean_ctor_get(x_3, 0);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_orelseInfo(x_2, x_4);
 return x_5;
 }
 }
-lean_object* _init_l_Lean_Parser_Command_mixfixSymbol___closed__3() {
+lean_object* _init_l_Lean_Parser_Command_mixfixSymbol___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_mixfixSymbol___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_mixfixSymbol___elambda__1), 2, 0);
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Command_mixfixSymbol___closed__4() {
+lean_object* _init_l_Lean_Parser_Command_mixfixSymbol___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Command_mixfixSymbol___closed__2;
-x_2 = l_Lean_Parser_Command_mixfixSymbol___closed__3;
+x_1 = l_Lean_Parser_Command_mixfixSymbol___closed__1;
+x_2 = l_Lean_Parser_Command_mixfixSymbol___closed__2;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -7168,7 +6965,7 @@ lean_object* _init_l_Lean_Parser_Command_mixfixSymbol() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Command_mixfixSymbol___closed__4;
+x_1 = l_Lean_Parser_Command_mixfixSymbol___closed__3;
 return x_1;
 }
 }
@@ -7203,251 +7000,245 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_mixfix___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_mixfix___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_mixfix___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_mixfix___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_mixfix___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_mixfix___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_mixfix___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_mixfix___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_mixfix___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
 lean_inc(x_1);
-x_17 = l_Lean_Parser_Command_mixfixKind___elambda__1(x_1, x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = l_Lean_Parser_Command_mixfixKind___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
-x_19 = l_Lean_Parser_Command_mixfixSymbol___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Command_mixfixSymbol___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_51; lean_object* x_52; 
+x_20 = lean_ctor_get(x_18, 0);
 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_24; lean_object* x_52; lean_object* x_53; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = lean_ctor_get(x_19, 1);
-lean_inc(x_23);
-lean_inc(x_2);
-x_52 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_53 = lean_ctor_get(x_52, 3);
-lean_inc(x_53);
-if (lean_obj_tag(x_53) == 0)
-{
-lean_object* x_54; lean_object* x_55; 
-x_54 = lean_ctor_get(x_52, 0);
-lean_inc(x_54);
-x_55 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_54);
-lean_dec(x_54);
-if (lean_obj_tag(x_55) == 2)
-{
-lean_object* x_56; lean_object* x_57; uint8_t x_58; 
-x_56 = lean_ctor_get(x_55, 1);
-lean_inc(x_56);
-lean_dec(x_55);
-x_57 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_58 = lean_string_dec_eq(x_56, x_57);
-lean_dec(x_56);
-if (x_58 == 0)
-{
-lean_object* x_59; lean_object* x_60; 
-x_59 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_23);
-x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_59, x_23);
-x_24 = x_60;
-goto block_51;
-}
-else
-{
-x_24 = x_52;
-goto block_51;
-}
-}
-else
-{
-lean_object* x_61; lean_object* x_62; 
-lean_dec(x_55);
-x_61 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_23);
-x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_61, x_23);
-x_24 = x_62;
-goto block_51;
-}
-}
-else
-{
-lean_object* x_63; lean_object* x_64; 
-lean_dec(x_53);
-x_63 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_23);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_63, x_23);
-x_24 = x_64;
-goto block_51;
-}
-block_51:
-{
-lean_object* x_25; 
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-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_dec(x_23);
-lean_dec(x_22);
-x_26 = l_Lean_Parser_termParser___closed__2;
-x_27 = lean_unsigned_to_nat(0u);
-x_28 = l_Lean_Parser_categoryParserFn(x_26, x_27, x_2, x_24);
-x_29 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; uint8_t x_34; 
-x_32 = lean_ctor_get(x_25, 0);
-lean_inc(x_32);
-lean_dec(x_25);
-x_33 = lean_ctor_get(x_24, 1);
-lean_inc(x_33);
-x_34 = lean_nat_dec_eq(x_33, x_23);
-lean_dec(x_33);
-if (x_34 == 0)
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_32);
-lean_dec(x_23);
-lean_dec(x_22);
-lean_dec(x_2);
-x_35 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_24, x_35, x_16);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_11, x_8);
-lean_dec(x_8);
-return x_37;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_inc(x_23);
-x_38 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
-lean_dec(x_22);
-lean_inc(x_2);
-x_39 = l_Lean_Parser_darrow___elambda__1___rarg(x_2, x_38);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_32, x_23);
-lean_dec(x_23);
-x_41 = lean_ctor_get(x_40, 3);
-lean_inc(x_41);
-if (lean_obj_tag(x_41) == 0)
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-x_42 = l_Lean_Parser_termParser___closed__2;
-x_43 = lean_unsigned_to_nat(0u);
-x_44 = l_Lean_Parser_categoryParserFn(x_42, x_43, x_2, x_40);
-x_45 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_16);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_11, x_8);
-lean_dec(x_8);
-return x_47;
-}
-else
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-lean_dec(x_41);
-lean_dec(x_2);
-x_48 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_40, x_48, x_16);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_11, x_8);
-lean_dec(x_8);
-return x_50;
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_21 = lean_array_get_size(x_20);
 lean_dec(x_20);
-lean_dec(x_2);
-x_65 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
-x_66 = l_Lean_Parser_ParserState_mkNode(x_19, x_65, x_16);
-x_67 = l_Lean_Parser_mergeOrElseErrors(x_66, x_11, x_8);
-lean_dec(x_8);
-return x_67;
+x_22 = lean_ctor_get(x_18, 1);
+lean_inc(x_22);
+lean_inc(x_1);
+x_51 = l_Lean_Parser_tokenFn(x_1, x_18);
+x_52 = lean_ctor_get(x_51, 3);
+lean_inc(x_52);
+if (lean_obj_tag(x_52) == 0)
+{
+lean_object* x_53; lean_object* x_54; 
+x_53 = lean_ctor_get(x_51, 0);
+lean_inc(x_53);
+x_54 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_53);
+lean_dec(x_53);
+if (lean_obj_tag(x_54) == 2)
+{
+lean_object* x_55; lean_object* x_56; uint8_t x_57; 
+x_55 = lean_ctor_get(x_54, 1);
+lean_inc(x_55);
+lean_dec(x_54);
+x_56 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
+x_57 = lean_string_dec_eq(x_55, x_56);
+lean_dec(x_55);
+if (x_57 == 0)
+{
+lean_object* x_58; lean_object* x_59; 
+x_58 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_22);
+x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_58, x_22);
+x_23 = x_59;
+goto block_50;
+}
+else
+{
+x_23 = x_51;
+goto block_50;
 }
 }
 else
 {
-lean_object* x_68; lean_object* x_69; lean_object* x_70; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_60; lean_object* x_61; 
+lean_dec(x_54);
+x_60 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_22);
+x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_60, x_22);
+x_23 = x_61;
+goto block_50;
+}
+}
+else
+{
+lean_object* x_62; lean_object* x_63; 
+lean_dec(x_52);
+x_62 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_22);
+x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_62, x_22);
+x_23 = x_63;
+goto block_50;
+}
+block_50:
+{
+lean_object* x_24; 
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
+{
+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_dec(x_22);
+lean_dec(x_21);
+x_25 = l_Lean_Parser_termParser___closed__2;
+x_26 = lean_unsigned_to_nat(0u);
+x_27 = l_Lean_Parser_categoryParser___elambda__1(x_25, x_26, x_1, x_23);
+x_28 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+else
+{
+lean_object* x_31; lean_object* x_32; uint8_t x_33; 
+x_31 = lean_ctor_get(x_24, 0);
+lean_inc(x_31);
+lean_dec(x_24);
+x_32 = lean_ctor_get(x_23, 1);
+lean_inc(x_32);
+x_33 = lean_nat_dec_eq(x_32, x_22);
+lean_dec(x_32);
+if (x_33 == 0)
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_31);
+lean_dec(x_22);
+lean_dec(x_21);
 lean_dec(x_1);
-x_68 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_17, x_68, x_16);
-x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_11, x_8);
-lean_dec(x_8);
-return x_70;
+x_34 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_23, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
+}
+else
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_inc(x_22);
+x_37 = l_Lean_Parser_ParserState_restore(x_23, x_21, x_22);
+lean_dec(x_21);
+lean_inc(x_1);
+x_38 = l_Lean_Parser_darrow___elambda__1(x_1, x_37);
+x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_31, x_22);
+lean_dec(x_22);
+x_40 = lean_ctor_get(x_39, 3);
+lean_inc(x_40);
+if (lean_obj_tag(x_40) == 0)
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_41 = l_Lean_Parser_termParser___closed__2;
+x_42 = lean_unsigned_to_nat(0u);
+x_43 = l_Lean_Parser_categoryParser___elambda__1(x_41, x_42, x_1, x_39);
+x_44 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_40);
+lean_dec(x_1);
+x_47 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_39, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_64 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_18, x_64, x_15);
+x_66 = l_Lean_Parser_mergeOrElseErrors(x_65, x_10, x_7);
+lean_dec(x_7);
+return x_66;
+}
+}
+else
+{
+lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_67 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
+x_68 = l_Lean_Parser_ParserState_mkNode(x_16, x_67, x_15);
+x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_10, x_7);
+lean_dec(x_7);
+return x_69;
 }
 }
 }
@@ -7469,7 +7260,7 @@ lean_object* _init_l_Lean_Parser_Command_mixfix___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_mixfix___closed__1;
@@ -7527,7 +7318,7 @@ lean_object* _init_l_Lean_Parser_Command_mixfix___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_mixfix___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_mixfix___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7554,10 +7345,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_mixfix(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_mixfix___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_mixfix;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -7594,101 +7385,90 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_strLitPrec___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_str___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
 lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_16 = l_Lean_Parser_strLit___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_22 = l_Lean_Parser_Command_strLitPrec___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -7720,7 +7500,7 @@ lean_object* _init_l_Lean_Parser_Command_strLitPrec___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_strLitPrec___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_strLitPrec___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7775,101 +7555,90 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_identPrec___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_identPrec___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_identPrec___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_identPrec___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_identPrec___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Command_identPrec___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_identPrec___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_identPrec___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_identPrec___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
 lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_16 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_identPrec___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Command_identPrec___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_identPrec___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_22 = l_Lean_Parser_Command_identPrec___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -7901,7 +7670,7 @@ lean_object* _init_l_Lean_Parser_Command_identPrec___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_identPrec___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_identPrec___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7925,201 +7694,196 @@ x_1 = l_Lean_Parser_Command_identPrec___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_optKind___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_optKind___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_21; lean_object* x_40; lean_object* x_41; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_18; lean_object* x_37; lean_object* x_38; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_40 = l_Lean_Parser_tokenFn(x_2, x_3);
-x_41 = lean_ctor_get(x_40, 3);
+lean_inc(x_1);
+x_37 = l_Lean_Parser_tokenFn(x_1, x_2);
+x_38 = lean_ctor_get(x_37, 3);
+lean_inc(x_38);
+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_Lean_Parser_checkStackTopFn___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);
-if (lean_obj_tag(x_41) == 0)
-{
-lean_object* x_42; lean_object* x_43; 
-x_42 = lean_ctor_get(x_40, 0);
-lean_inc(x_42);
-x_43 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_42);
-lean_dec(x_42);
-if (lean_obj_tag(x_43) == 2)
-{
-lean_object* x_44; lean_object* x_45; uint8_t x_46; 
-x_44 = lean_ctor_get(x_43, 1);
-lean_inc(x_44);
-lean_dec(x_43);
-x_45 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
-x_46 = lean_string_dec_eq(x_44, x_45);
-lean_dec(x_44);
-if (x_46 == 0)
-{
-lean_object* x_47; lean_object* x_48; 
-x_47 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_8);
-x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_47, x_8);
-x_21 = x_48;
-goto block_39;
-}
-else
-{
-x_21 = x_40;
-goto block_39;
-}
-}
-else
-{
-lean_object* x_49; lean_object* x_50; 
-lean_dec(x_43);
-x_49 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_8);
-x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_49, x_8);
-x_21 = x_50;
-goto block_39;
-}
-}
-else
-{
-lean_object* x_51; lean_object* x_52; 
+lean_dec(x_40);
+x_42 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
+x_43 = lean_string_dec_eq(x_41, x_42);
 lean_dec(x_41);
-x_51 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_8);
-x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_51, x_8);
-x_21 = x_52;
-goto block_39;
-}
-block_20:
+if (x_43 == 0)
 {
-lean_object* x_10; 
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_object* x_11; lean_object* x_12; 
-lean_dec(x_8);
-x_11 = l_Lean_nullKind;
-x_12 = l_Lean_Parser_ParserState_mkNode(x_9, x_11, x_7);
-return x_12;
+lean_object* x_44; lean_object* x_45; 
+x_44 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+lean_inc(x_5);
+x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_5);
+x_18 = x_45;
+goto block_36;
 }
 else
 {
-lean_object* x_13; uint8_t x_14; 
-lean_dec(x_10);
-x_13 = lean_ctor_get(x_9, 1);
-lean_inc(x_13);
-x_14 = lean_nat_dec_eq(x_13, x_8);
-lean_dec(x_13);
-if (x_14 == 0)
+x_18 = x_37;
+goto block_36;
+}
+}
+else
 {
-lean_object* x_15; lean_object* x_16; 
-lean_dec(x_8);
+lean_object* x_46; lean_object* x_47; 
+lean_dec(x_40);
+x_46 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+lean_inc(x_5);
+x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_5);
+x_18 = x_47;
+goto block_36;
+}
+}
+else
+{
+lean_object* x_48; lean_object* x_49; 
+lean_dec(x_38);
+x_48 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+lean_inc(x_5);
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_5);
+x_18 = x_49;
+goto block_36;
+}
+block_17:
+{
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; 
+lean_dec(x_5);
+x_8 = l_Lean_nullKind;
+x_9 = l_Lean_Parser_ParserState_mkNode(x_6, x_8, x_4);
+return x_9;
+}
+else
+{
+lean_object* x_10; uint8_t x_11; 
+lean_dec(x_7);
+x_10 = lean_ctor_get(x_6, 1);
+lean_inc(x_10);
+x_11 = lean_nat_dec_eq(x_10, x_5);
+lean_dec(x_10);
+if (x_11 == 0)
+{
+lean_object* x_12; lean_object* x_13; 
+lean_dec(x_5);
+x_12 = l_Lean_nullKind;
+x_13 = l_Lean_Parser_ParserState_mkNode(x_6, x_12, x_4);
+return x_13;
+}
+else
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+x_14 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
 x_15 = l_Lean_nullKind;
-x_16 = l_Lean_Parser_ParserState_mkNode(x_9, x_15, x_7);
+x_16 = l_Lean_Parser_ParserState_mkNode(x_14, x_15, x_4);
 return x_16;
 }
-else
+}
+}
+block_36:
 {
-lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_17 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-x_18 = l_Lean_nullKind;
-x_19 = l_Lean_Parser_ParserState_mkNode(x_17, x_18, x_7);
-return x_19;
-}
-}
-}
-block_39:
+lean_object* x_19; 
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_22; 
-x_22 = lean_ctor_get(x_21, 3);
+lean_object* x_20; lean_object* x_21; 
+lean_inc(x_1);
+x_20 = l_Lean_Parser_ident___elambda__1(x_1, x_18);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_22 = lean_ctor_get(x_20, 1);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; 
-lean_inc(x_2);
-x_23 = lean_apply_3(x_5, x_1, x_2, x_21);
+x_23 = l_Lean_Parser_tokenFn(x_1, x_20);
 x_24 = lean_ctor_get(x_23, 3);
 lean_inc(x_24);
 if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_25 = lean_ctor_get(x_23, 1);
+lean_object* x_25; lean_object* x_26; 
+x_25 = lean_ctor_get(x_23, 0);
 lean_inc(x_25);
-x_26 = l_Lean_Parser_tokenFn(x_2, x_23);
-x_27 = lean_ctor_get(x_26, 3);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; lean_object* x_29; 
-x_28 = lean_ctor_get(x_26, 0);
-lean_inc(x_28);
-x_29 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_28);
-lean_dec(x_28);
-if (lean_obj_tag(x_29) == 2)
-{
-lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_30 = lean_ctor_get(x_29, 1);
-lean_inc(x_30);
-lean_dec(x_29);
-x_31 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
-x_32 = lean_string_dec_eq(x_30, x_31);
-lean_dec(x_30);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; 
-x_33 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_25);
-x_9 = x_34;
-goto block_20;
-}
-else
-{
+x_26 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_25);
 lean_dec(x_25);
-x_9 = x_26;
-goto block_20;
-}
-}
-else
+if (lean_obj_tag(x_26) == 2)
 {
-lean_object* x_35; lean_object* x_36; 
-lean_dec(x_29);
-x_35 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_25);
-x_9 = x_36;
-goto block_20;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; 
+lean_object* x_27; lean_object* x_28; uint8_t x_29; 
+x_27 = lean_ctor_get(x_26, 1);
+lean_inc(x_27);
+lean_dec(x_26);
+x_28 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
+x_29 = lean_string_dec_eq(x_27, x_28);
 lean_dec(x_27);
-x_37 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_25);
-x_9 = x_38;
-goto block_20;
-}
-}
-else
+if (x_29 == 0)
 {
-lean_dec(x_24);
-lean_dec(x_2);
-x_9 = x_23;
-goto block_20;
-}
+lean_object* x_30; lean_object* x_31; 
+x_30 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22);
+x_6 = x_31;
+goto block_17;
 }
 else
 {
 lean_dec(x_22);
-lean_dec(x_5);
-lean_dec(x_2);
+x_6 = x_23;
+goto block_17;
+}
+}
+else
+{
+lean_object* x_32; lean_object* x_33; 
+lean_dec(x_26);
+x_32 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22);
+x_6 = x_33;
+goto block_17;
+}
+}
+else
+{
+lean_object* x_34; lean_object* x_35; 
+lean_dec(x_24);
+x_34 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22);
+x_6 = x_35;
+goto block_17;
+}
+}
+else
+{
+lean_dec(x_21);
 lean_dec(x_1);
-x_9 = x_21;
-goto block_20;
+x_6 = x_20;
+goto block_17;
+}
+}
+else
+{
+lean_dec(x_19);
+lean_dec(x_1);
+x_6 = x_18;
+goto block_17;
 }
 }
 }
@@ -8128,7 +7892,7 @@ lean_object* _init_l_Lean_Parser_Command_optKind___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_listLit___closed__4;
@@ -8159,7 +7923,7 @@ lean_object* _init_l_Lean_Parser_Command_optKind___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_optKind___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_optKind___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -8183,151 +7947,146 @@ x_1 = l_Lean_Parser_Command_optKind___closed__5;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_notation___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_notation___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_19; lean_object* x_20; 
-x_5 = lean_ctor_get(x_4, 0);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_17; lean_object* x_18; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-lean_inc(x_3);
-lean_inc(x_2);
-x_19 = l_Lean_Parser_Command_strLitPrec___elambda__1(x_2, x_3, x_4);
-x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_1);
+x_17 = l_Lean_Parser_Command_strLitPrec___elambda__1(x_1, x_2);
+x_18 = lean_ctor_get(x_17, 3);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
+{
+x_6 = x_17;
+goto block_16;
+}
+else
+{
+lean_object* x_19; lean_object* x_20; uint8_t x_21; 
+x_19 = lean_ctor_get(x_18, 0);
+lean_inc(x_19);
+lean_dec(x_18);
+x_20 = lean_ctor_get(x_17, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-x_8 = x_19;
-goto block_18;
-}
-else
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 0);
-lean_inc(x_21);
+x_21 = lean_nat_dec_eq(x_20, x_5);
 lean_dec(x_20);
-x_22 = lean_ctor_get(x_19, 1);
-lean_inc(x_22);
-x_23 = lean_nat_dec_eq(x_22, x_7);
-lean_dec(x_22);
-if (x_23 == 0)
+if (x_21 == 0)
 {
-lean_dec(x_21);
-x_8 = x_19;
-goto block_18;
+lean_dec(x_19);
+x_6 = x_17;
+goto block_16;
 }
 else
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-lean_inc(x_7);
-x_24 = l_Lean_Parser_ParserState_restore(x_19, x_6, x_7);
-x_25 = lean_ctor_get(x_24, 0);
-lean_inc(x_25);
-x_26 = lean_array_get_size(x_25);
-lean_dec(x_25);
-lean_inc(x_3);
-lean_inc(x_2);
-x_27 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(x_2, x_3, x_24);
-x_28 = lean_ctor_get(x_27, 3);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_inc(x_5);
+x_22 = l_Lean_Parser_ParserState_restore(x_17, x_4, x_5);
+x_23 = lean_ctor_get(x_22, 0);
+lean_inc(x_23);
+x_24 = lean_array_get_size(x_23);
+lean_dec(x_23);
+lean_inc(x_1);
+x_25 = l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(x_1, x_22);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
+{
+lean_object* x_27; 
+lean_dec(x_24);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_25, x_19, x_5);
+x_6 = x_27;
+goto block_16;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; uint8_t x_30; 
+x_28 = lean_ctor_get(x_26, 0);
 lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; 
 lean_dec(x_26);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_27, x_21, x_7);
-x_8 = x_29;
-goto block_18;
-}
-else
+x_29 = lean_ctor_get(x_25, 1);
+lean_inc(x_29);
+x_30 = lean_nat_dec_eq(x_29, x_5);
+lean_dec(x_29);
+if (x_30 == 0)
 {
-lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_30 = lean_ctor_get(x_28, 0);
-lean_inc(x_30);
+lean_object* x_31; 
 lean_dec(x_28);
-x_31 = lean_ctor_get(x_27, 1);
-lean_inc(x_31);
-x_32 = lean_nat_dec_eq(x_31, x_7);
-lean_dec(x_31);
-if (x_32 == 0)
-{
-lean_object* x_33; 
-lean_dec(x_30);
-lean_dec(x_26);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_27, x_21, x_7);
-x_8 = x_33;
-goto block_18;
+lean_dec(x_24);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_25, x_19, x_5);
+x_6 = x_31;
+goto block_16;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_inc(x_5);
+x_32 = l_Lean_Parser_ParserState_restore(x_25, x_24, x_5);
+lean_dec(x_24);
+lean_inc(x_1);
+x_33 = l_Lean_Parser_Command_identPrec___elambda__1(x_1, x_32);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_28, x_5);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_19, x_5);
+x_6 = x_35;
+goto block_16;
+}
+}
+}
+}
+block_16:
+{
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_6, 3);
 lean_inc(x_7);
-x_34 = l_Lean_Parser_ParserState_restore(x_27, x_26, x_7);
-lean_dec(x_26);
-lean_inc(x_3);
-lean_inc(x_2);
-x_35 = l_Lean_Parser_Command_identPrec___elambda__1(x_2, x_3, x_34);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_30, x_7);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_21, x_7);
-x_8 = x_37;
-goto block_18;
-}
-}
-}
-}
-block_18:
+if (lean_obj_tag(x_7) == 0)
 {
-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_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
+lean_dec(x_5);
+if (x_9 == 0)
 {
-lean_object* x_10; uint8_t x_11; 
-lean_dec(x_6);
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_7, x_10);
-lean_dec(x_10);
-lean_dec(x_7);
-if (x_11 == 0)
-{
-x_4 = x_8;
+x_2 = x_6;
 goto _start;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_13 = l_Lean_Parser_manyAux___main___closed__1;
-x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
-return x_14;
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_15; uint8_t x_16; 
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_15 = lean_ctor_get(x_8, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_7, x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+lean_object* x_13; uint8_t x_14; 
 lean_dec(x_7);
-lean_dec(x_6);
-return x_8;
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_17;
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+return x_15;
 }
 }
 }
@@ -8364,13 +8123,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_notation___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_notation___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_notation___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_notation___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_notation___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_notation___elambda__1___closed__5() {
@@ -8414,305 +8172,300 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_notation___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_notation___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_notation___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_notation___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_77; lean_object* x_78; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_77 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_78 = lean_ctor_get(x_77, 3);
-lean_inc(x_78);
-if (lean_obj_tag(x_78) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_75; lean_object* x_76; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_75 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_76 = lean_ctor_get(x_75, 3);
+lean_inc(x_76);
+if (lean_obj_tag(x_76) == 0)
 {
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_ctor_get(x_77, 0);
+lean_object* x_77; lean_object* x_78; 
+x_77 = lean_ctor_get(x_75, 0);
+lean_inc(x_77);
+x_78 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_77);
+lean_dec(x_77);
+if (lean_obj_tag(x_78) == 2)
+{
+lean_object* x_79; lean_object* x_80; uint8_t x_81; 
+x_79 = lean_ctor_get(x_78, 1);
 lean_inc(x_79);
-x_80 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_79);
+lean_dec(x_78);
+x_80 = l_Lean_Parser_Command_notation___elambda__1___closed__5;
+x_81 = lean_string_dec_eq(x_79, x_80);
 lean_dec(x_79);
-if (lean_obj_tag(x_80) == 2)
+if (x_81 == 0)
 {
-lean_object* x_81; lean_object* x_82; uint8_t x_83; 
-x_81 = lean_ctor_get(x_80, 1);
-lean_inc(x_81);
-lean_dec(x_80);
-x_82 = l_Lean_Parser_Command_notation___elambda__1___closed__5;
-x_83 = lean_string_dec_eq(x_81, x_82);
-lean_dec(x_81);
-if (x_83 == 0)
+lean_object* x_82; lean_object* x_83; 
+x_82 = l_Lean_Parser_Command_notation___elambda__1___closed__8;
+lean_inc(x_7);
+x_83 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_82, x_7);
+x_16 = x_83;
+goto block_74;
+}
+else
+{
+x_16 = x_75;
+goto block_74;
+}
+}
+else
 {
 lean_object* x_84; lean_object* x_85; 
+lean_dec(x_78);
 x_84 = l_Lean_Parser_Command_notation___elambda__1___closed__8;
-lean_inc(x_8);
-x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_84, x_8);
-x_17 = x_85;
-goto block_76;
-}
-else
-{
-x_17 = x_77;
-goto block_76;
+lean_inc(x_7);
+x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_84, x_7);
+x_16 = x_85;
+goto block_74;
 }
 }
 else
 {
 lean_object* x_86; lean_object* x_87; 
-lean_dec(x_80);
+lean_dec(x_76);
 x_86 = l_Lean_Parser_Command_notation___elambda__1___closed__8;
-lean_inc(x_8);
-x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_86, x_8);
-x_17 = x_87;
-goto block_76;
+lean_inc(x_7);
+x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_86, x_7);
+x_16 = x_87;
+goto block_74;
 }
+block_74:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = lean_ctor_get(x_16, 0);
+lean_inc(x_18);
+x_19 = lean_array_get_size(x_18);
+lean_dec(x_18);
+lean_inc(x_1);
+x_20 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_notation___elambda__1___spec__1(x_1, x_16);
+x_21 = l_Lean_nullKind;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_19);
+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_object* x_27; lean_object* x_55; lean_object* x_56; 
+x_24 = lean_ctor_get(x_22, 0);
+lean_inc(x_24);
+x_25 = lean_array_get_size(x_24);
+lean_dec(x_24);
+x_26 = lean_ctor_get(x_22, 1);
+lean_inc(x_26);
+lean_inc(x_1);
+x_55 = l_Lean_Parser_tokenFn(x_1, x_22);
+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_Lean_Parser_checkStackTopFn___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);
+lean_inc(x_59);
+lean_dec(x_58);
+x_60 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
+x_61 = lean_string_dec_eq(x_59, x_60);
+lean_dec(x_59);
+if (x_61 == 0)
+{
+lean_object* x_62; lean_object* x_63; 
+x_62 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_26);
+x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_26);
+x_27 = x_63;
+goto block_54;
 }
 else
 {
-lean_object* x_88; lean_object* x_89; 
-lean_dec(x_78);
-x_88 = l_Lean_Parser_Command_notation___elambda__1___closed__8;
-lean_inc(x_8);
-x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_88, x_8);
-x_17 = x_89;
-goto block_76;
+x_27 = x_55;
+goto block_54;
 }
-block_76:
-{
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-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 = 0;
-lean_inc(x_2);
-x_22 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_notation___elambda__1___spec__1(x_21, x_1, x_2, x_17);
-x_23 = l_Lean_nullKind;
-x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_20);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_57; lean_object* x_58; 
-x_26 = lean_ctor_get(x_24, 0);
-lean_inc(x_26);
-x_27 = lean_array_get_size(x_26);
-lean_dec(x_26);
-x_28 = lean_ctor_get(x_24, 1);
-lean_inc(x_28);
-lean_inc(x_2);
-x_57 = l_Lean_Parser_tokenFn(x_2, x_24);
-x_58 = lean_ctor_get(x_57, 3);
-lean_inc(x_58);
-if (lean_obj_tag(x_58) == 0)
-{
-lean_object* x_59; lean_object* x_60; 
-x_59 = lean_ctor_get(x_57, 0);
-lean_inc(x_59);
-x_60 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_59);
-lean_dec(x_59);
-if (lean_obj_tag(x_60) == 2)
-{
-lean_object* x_61; lean_object* x_62; uint8_t x_63; 
-x_61 = lean_ctor_get(x_60, 1);
-lean_inc(x_61);
-lean_dec(x_60);
-x_62 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_63 = lean_string_dec_eq(x_61, x_62);
-lean_dec(x_61);
-if (x_63 == 0)
+}
+else
 {
 lean_object* x_64; lean_object* x_65; 
+lean_dec(x_58);
 x_64 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_28);
-x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_64, x_28);
-x_29 = x_65;
-goto block_56;
-}
-else
-{
-x_29 = x_57;
-goto block_56;
+lean_inc(x_26);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_26);
+x_27 = x_65;
+goto block_54;
 }
 }
 else
 {
 lean_object* x_66; lean_object* x_67; 
-lean_dec(x_60);
+lean_dec(x_56);
 x_66 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_26);
+x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_26);
+x_27 = x_67;
+goto block_54;
+}
+block_54:
+{
+lean_object* x_28; 
+x_28 = lean_ctor_get(x_27, 3);
 lean_inc(x_28);
-x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_66, x_28);
-x_29 = x_67;
-goto block_56;
-}
-}
-else
+if (lean_obj_tag(x_28) == 0)
 {
-lean_object* x_68; lean_object* x_69; 
-lean_dec(x_58);
-x_68 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_28);
-x_69 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_68, x_28);
-x_29 = x_69;
-goto block_56;
-}
-block_56:
-{
-lean_object* x_30; 
-x_30 = lean_ctor_get(x_29, 3);
-lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_28);
-lean_dec(x_27);
-x_31 = l_Lean_Parser_termParser___closed__2;
-x_32 = lean_unsigned_to_nat(0u);
-x_33 = l_Lean_Parser_categoryParserFn(x_31, x_32, x_2, x_29);
-x_34 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-else
-{
-lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_37 = lean_ctor_get(x_30, 0);
-lean_inc(x_37);
-lean_dec(x_30);
-x_38 = lean_ctor_get(x_29, 1);
-lean_inc(x_38);
-x_39 = lean_nat_dec_eq(x_38, x_28);
-lean_dec(x_38);
-if (x_39 == 0)
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-lean_dec(x_37);
-lean_dec(x_28);
-lean_dec(x_27);
-lean_dec(x_2);
-x_40 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
-x_41 = l_Lean_Parser_ParserState_mkNode(x_29, x_40, x_16);
-x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_11, x_8);
-lean_dec(x_8);
-return x_42;
-}
-else
-{
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-lean_inc(x_28);
-x_43 = l_Lean_Parser_ParserState_restore(x_29, x_27, x_28);
-lean_dec(x_27);
-lean_inc(x_2);
-x_44 = l_Lean_Parser_darrow___elambda__1___rarg(x_2, x_43);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_37, x_28);
-lean_dec(x_28);
-x_46 = lean_ctor_get(x_45, 3);
-lean_inc(x_46);
-if (lean_obj_tag(x_46) == 0)
-{
-lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_47 = l_Lean_Parser_termParser___closed__2;
-x_48 = lean_unsigned_to_nat(0u);
-x_49 = l_Lean_Parser_categoryParserFn(x_47, x_48, x_2, x_45);
-x_50 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_16);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_11, x_8);
-lean_dec(x_8);
-return x_52;
-}
-else
-{
-lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-lean_dec(x_46);
-lean_dec(x_2);
-x_53 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
-x_54 = l_Lean_Parser_ParserState_mkNode(x_45, x_53, x_16);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_11, x_8);
-lean_dec(x_8);
-return x_55;
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+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_dec(x_26);
 lean_dec(x_25);
-lean_dec(x_2);
-x_70 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_24, x_70, x_16);
-x_72 = l_Lean_Parser_mergeOrElseErrors(x_71, x_11, x_8);
-lean_dec(x_8);
-return x_72;
+x_29 = l_Lean_Parser_termParser___closed__2;
+x_30 = lean_unsigned_to_nat(0u);
+x_31 = l_Lean_Parser_categoryParser___elambda__1(x_29, x_30, x_1, x_27);
+x_32 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
+}
+else
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = lean_ctor_get(x_28, 0);
+lean_inc(x_35);
+lean_dec(x_28);
+x_36 = lean_ctor_get(x_27, 1);
+lean_inc(x_36);
+x_37 = lean_nat_dec_eq(x_36, x_26);
+lean_dec(x_36);
+if (x_37 == 0)
+{
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_35);
+lean_dec(x_26);
+lean_dec(x_25);
+lean_dec(x_1);
+x_38 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_27, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+lean_inc(x_26);
+x_41 = l_Lean_Parser_ParserState_restore(x_27, x_25, x_26);
+lean_dec(x_25);
+lean_inc(x_1);
+x_42 = l_Lean_Parser_darrow___elambda__1(x_1, x_41);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_35, x_26);
+lean_dec(x_26);
+x_44 = lean_ctor_get(x_43, 3);
+lean_inc(x_44);
+if (lean_obj_tag(x_44) == 0)
+{
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_45 = l_Lean_Parser_termParser___closed__2;
+x_46 = lean_unsigned_to_nat(0u);
+x_47 = l_Lean_Parser_categoryParser___elambda__1(x_45, x_46, x_1, x_43);
+x_48 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
+x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_15);
+x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_10, x_7);
+lean_dec(x_7);
+return x_50;
+}
+else
+{
+lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+lean_dec(x_44);
+lean_dec(x_1);
+x_51 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
+x_52 = l_Lean_Parser_ParserState_mkNode(x_43, x_51, x_15);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_10, x_7);
+lean_dec(x_7);
+return x_53;
+}
+}
+}
 }
 }
 else
 {
-lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+lean_dec(x_23);
 lean_dec(x_1);
-x_73 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
-x_74 = l_Lean_Parser_ParserState_mkNode(x_17, x_73, x_16);
-x_75 = l_Lean_Parser_mergeOrElseErrors(x_74, x_11, x_8);
-lean_dec(x_8);
-return x_75;
+x_68 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
+x_69 = l_Lean_Parser_ParserState_mkNode(x_22, x_68, x_15);
+x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_10, x_7);
+lean_dec(x_7);
+return x_70;
+}
+}
+else
+{
+lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_71 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
+x_72 = l_Lean_Parser_ParserState_mkNode(x_16, x_71, x_15);
+x_73 = l_Lean_Parser_mergeOrElseErrors(x_72, x_10, x_7);
+lean_dec(x_7);
+return x_73;
 }
 }
 }
@@ -8810,7 +8563,7 @@ lean_object* _init_l_Lean_Parser_Command_notation___closed__9() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_notation___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_notation___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -8834,23 +8587,13 @@ x_1 = l_Lean_Parser_Command_notation___closed__10;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_notation___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_notation___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-return x_6;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Command_notation(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_notation___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_notation;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -8887,13 +8630,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_macro__rules___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_macro__rules___elambda__1___closed__5() {
@@ -8937,171 +8679,165 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_macro__rules___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macro__rules___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_match___elambda__1___closed__9;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_Term_match___elambda__1___closed__9;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
+lean_inc(x_1);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
 lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
-lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_34; lean_object* x_35; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_34 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 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_Lean_Parser_checkLeadingFn___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_inc(x_38);
-lean_dec(x_37);
-x_39 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__5;
-x_40 = lean_string_dec_eq(x_38, x_39);
-lean_dec(x_38);
-if (x_40 == 0)
-{
-lean_object* x_41; lean_object* x_42; 
-x_41 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__8;
-lean_inc(x_10);
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_41, x_10);
-x_19 = x_42;
-goto block_33;
-}
-else
-{
-x_19 = x_34;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; 
-lean_dec(x_37);
-x_43 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__8;
-lean_inc(x_10);
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_43, x_10);
-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_Command_macro__rules___elambda__1___closed__8;
-lean_inc(x_10);
-x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_45, x_10);
-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_inc(x_2);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_33; lean_object* x_34; 
+lean_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
 lean_inc(x_1);
-x_21 = l_Lean_Parser_Command_optKind___elambda__1(x_1, x_2, x_19);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
+x_33 = l_Lean_Parser_tokenFn(x_1, x_15);
+x_34 = lean_ctor_get(x_33, 3);
+lean_inc(x_34);
+if (lean_obj_tag(x_34) == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_23 = lean_apply_3(x_5, x_1, x_2, x_21);
-x_24 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_18);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_13, x_10);
-lean_dec(x_10);
-return x_26;
+lean_object* x_35; lean_object* x_36; 
+x_35 = lean_ctor_get(x_33, 0);
+lean_inc(x_35);
+x_36 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_35);
+lean_dec(x_35);
+if (lean_obj_tag(x_36) == 2)
+{
+lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_37 = lean_ctor_get(x_36, 1);
+lean_inc(x_37);
+lean_dec(x_36);
+x_38 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__5;
+x_39 = lean_string_dec_eq(x_37, x_38);
+lean_dec(x_37);
+if (x_39 == 0)
+{
+lean_object* x_40; lean_object* x_41; 
+x_40 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__8;
+lean_inc(x_9);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_9);
+x_18 = x_41;
+goto block_32;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_22);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_27 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_21, x_27, x_18);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_13, x_10);
-lean_dec(x_10);
-return x_29;
+x_18 = x_33;
+goto block_32;
 }
 }
 else
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_42; lean_object* x_43; 
+lean_dec(x_36);
+x_42 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__8;
+lean_inc(x_9);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_42, x_9);
+x_18 = x_43;
+goto block_32;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; 
+lean_dec(x_34);
+x_44 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__8;
+lean_inc(x_9);
+x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_44, x_9);
+x_18 = x_45;
+goto block_32;
+}
+block_32:
+{
+lean_object* x_19; 
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; 
+lean_inc(x_1);
+x_20 = l_Lean_Parser_Command_optKind___elambda__1(x_1, x_18);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_22 = lean_apply_2(x_4, x_1, x_20);
+x_23 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_17);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_12, x_9);
+lean_dec(x_9);
+return x_25;
+}
+else
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_21);
+lean_dec(x_4);
 lean_dec(x_1);
-x_30 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_18);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_13, x_10);
-lean_dec(x_10);
-return x_32;
+x_26 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_17);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_12, x_9);
+lean_dec(x_9);
+return x_28;
+}
+}
+else
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_19);
+lean_dec(x_4);
+lean_dec(x_1);
+x_29 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_18, x_29, x_17);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_12, x_9);
+lean_dec(x_9);
+return x_31;
 }
 }
 }
@@ -9168,7 +8904,7 @@ lean_object* _init_l_Lean_Parser_Command_macro__rules___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macro__rules___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macro__rules___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -9195,10 +8931,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_macro__rules(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_macro__rules___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_macro__rules;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -9227,13 +8963,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_syntax___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__3;
-x_3 = l_Lean_Parser_Command_syntax___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__3;
+x_2 = l_Lean_Parser_Command_syntax___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_syntax___elambda__1___closed__4() {
@@ -9285,297 +9020,275 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_syntax___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_syntax___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_syntax___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_syntax___elambda__1___closed__3;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_52; lean_object* x_75; lean_object* x_76; 
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_75 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_76 = lean_ctor_get(x_75, 3);
-lean_inc(x_76);
-if (lean_obj_tag(x_76) == 0)
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_77; lean_object* x_78; 
-x_77 = lean_ctor_get(x_75, 0);
-lean_inc(x_77);
-x_78 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_77);
-lean_dec(x_77);
-if (lean_obj_tag(x_78) == 2)
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
 {
-lean_object* x_79; lean_object* x_80; uint8_t x_81; 
-x_79 = lean_ctor_get(x_78, 1);
-lean_inc(x_79);
-lean_dec(x_78);
-x_80 = l_Lean_Parser_Command_syntax___elambda__1___closed__5;
-x_81 = lean_string_dec_eq(x_79, x_80);
-lean_dec(x_79);
-if (x_81 == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_49; lean_object* x_71; lean_object* x_72; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_71 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_72 = lean_ctor_get(x_71, 3);
+lean_inc(x_72);
+if (lean_obj_tag(x_72) == 0)
+{
+lean_object* x_73; lean_object* x_74; 
+x_73 = lean_ctor_get(x_71, 0);
+lean_inc(x_73);
+x_74 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_73);
+lean_dec(x_73);
+if (lean_obj_tag(x_74) == 2)
+{
+lean_object* x_75; lean_object* x_76; uint8_t x_77; 
+x_75 = lean_ctor_get(x_74, 1);
+lean_inc(x_75);
+lean_dec(x_74);
+x_76 = l_Lean_Parser_Command_syntax___elambda__1___closed__5;
+x_77 = lean_string_dec_eq(x_75, x_76);
+lean_dec(x_75);
+if (x_77 == 0)
+{
+lean_object* x_78; lean_object* x_79; 
+x_78 = l_Lean_Parser_Command_syntax___elambda__1___closed__8;
+lean_inc(x_7);
+x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_78, x_7);
+x_49 = x_79;
+goto block_70;
+}
+else
+{
+x_49 = x_71;
+goto block_70;
+}
+}
+else
+{
+lean_object* x_80; lean_object* x_81; 
+lean_dec(x_74);
+x_80 = l_Lean_Parser_Command_syntax___elambda__1___closed__8;
+lean_inc(x_7);
+x_81 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_80, x_7);
+x_49 = x_81;
+goto block_70;
+}
+}
+else
 {
 lean_object* x_82; lean_object* x_83; 
+lean_dec(x_72);
 x_82 = l_Lean_Parser_Command_syntax___elambda__1___closed__8;
-lean_inc(x_10);
-x_83 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_82, x_10);
-x_52 = x_83;
-goto block_74;
+lean_inc(x_7);
+x_83 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_82, x_7);
+x_49 = x_83;
+goto block_70;
 }
-else
+block_48:
 {
-x_52 = x_75;
-goto block_74;
-}
-}
-else
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_84; lean_object* x_85; 
-lean_dec(x_78);
-x_84 = l_Lean_Parser_Command_syntax___elambda__1___closed__8;
-lean_inc(x_10);
-x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_84, x_10);
-x_52 = x_85;
-goto block_74;
-}
-}
-else
-{
-lean_object* x_86; lean_object* x_87; 
-lean_dec(x_76);
-x_86 = l_Lean_Parser_Command_syntax___elambda__1___closed__8;
-lean_inc(x_10);
-x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_75, x_86, x_10);
-x_52 = x_87;
-goto block_74;
-}
-block_51:
-{
-lean_object* x_20; 
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_16, 1);
+lean_inc(x_18);
+lean_inc(x_1);
+x_19 = l_Lean_Parser_tokenFn(x_1, x_16);
 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; 
-x_21 = lean_ctor_get(x_19, 1);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-lean_inc(x_2);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-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; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
-{
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_29 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
-x_31 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_18);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_13, x_10);
-lean_dec(x_10);
-return x_33;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
 lean_dec(x_21);
-x_34 = lean_apply_3(x_5, x_1, x_2, x_22);
-x_35 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_18);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_13, x_10);
-lean_dec(x_10);
-return x_37;
-}
-}
-else
+if (lean_obj_tag(x_22) == 2)
 {
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-lean_dec(x_25);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_38 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_38, x_21);
-x_40 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
-x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_18);
-x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_13, x_10);
-lean_dec(x_10);
-return x_42;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 1);
+lean_inc(x_23);
+lean_dec(x_22);
+x_24 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
+x_25 = lean_string_dec_eq(x_23, x_24);
 lean_dec(x_23);
-lean_dec(x_5);
-lean_dec(x_2);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_1);
+x_26 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18);
+x_28 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_18);
+x_31 = l_Lean_Parser_ident___elambda__1(x_1, x_19);
+x_32 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+lean_dec(x_22);
+lean_dec(x_1);
+x_35 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_35, x_18);
+x_37 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
+x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_15);
+x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_10, x_7);
+lean_dec(x_7);
+return x_39;
+}
+}
+else
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+lean_dec(x_20);
+lean_dec(x_1);
+x_40 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_40, x_18);
+x_42 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
+x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_15);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_10, x_7);
+lean_dec(x_7);
+return x_44;
+}
+}
+else
+{
+lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_43 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_43, x_21);
 x_45 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_18);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_13, x_10);
-lean_dec(x_10);
+x_46 = l_Lean_Parser_ParserState_mkNode(x_16, x_45, x_15);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_10, x_7);
+lean_dec(x_7);
 return x_47;
 }
 }
-else
+block_70:
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_48 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_19, x_48, x_18);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_13, x_10);
-lean_dec(x_10);
-return x_50;
-}
-}
-block_74:
+lean_object* x_50; 
+x_50 = lean_ctor_get(x_49, 3);
+lean_inc(x_50);
+if (lean_obj_tag(x_50) == 0)
 {
-lean_object* x_53; 
-x_53 = lean_ctor_get(x_52, 3);
-lean_inc(x_53);
-if (lean_obj_tag(x_53) == 0)
-{
-lean_object* x_54; lean_object* x_55; 
-lean_inc(x_2);
+lean_object* x_51; lean_object* x_52; 
 lean_inc(x_1);
-x_54 = l_Lean_Parser_Command_optKind___elambda__1(x_1, x_2, x_52);
-x_55 = lean_ctor_get(x_54, 3);
-lean_inc(x_55);
-if (lean_obj_tag(x_55) == 0)
+x_51 = l_Lean_Parser_Command_optKind___elambda__1(x_1, x_49);
+x_52 = lean_ctor_get(x_51, 3);
+lean_inc(x_52);
+if (lean_obj_tag(x_52) == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-x_56 = lean_ctor_get(x_54, 0);
-lean_inc(x_56);
-x_57 = lean_array_get_size(x_56);
-lean_dec(x_56);
-x_58 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
-x_59 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_60 = l_Lean_Parser_categoryParserFn(x_58, x_59, x_2, x_54);
-x_61 = lean_ctor_get(x_60, 3);
-lean_inc(x_61);
-if (lean_obj_tag(x_61) == 0)
-{
-uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-x_62 = 0;
-lean_inc(x_2);
-x_63 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(x_62, x_1, x_2, x_60);
-x_64 = l_Lean_nullKind;
-x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_57);
-x_19 = x_65;
-goto block_51;
-}
-else
-{
-lean_object* x_66; lean_object* x_67; 
-lean_dec(x_61);
-x_66 = l_Lean_nullKind;
-x_67 = l_Lean_Parser_ParserState_mkNode(x_60, x_66, x_57);
-x_19 = x_67;
-goto block_51;
-}
-}
-else
-{
-lean_object* x_68; lean_object* x_69; lean_object* x_70; 
-lean_dec(x_55);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_68 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_54, x_68, x_18);
-x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_13, x_10);
-lean_dec(x_10);
-return x_70;
-}
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; 
+lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_53 = lean_ctor_get(x_51, 0);
+lean_inc(x_53);
+x_54 = lean_array_get_size(x_53);
 lean_dec(x_53);
-lean_dec(x_5);
-lean_dec(x_2);
+x_55 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4;
+x_56 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_57 = l_Lean_Parser_categoryParser___elambda__1(x_55, x_56, x_1, x_51);
+x_58 = lean_ctor_get(x_57, 3);
+lean_inc(x_58);
+if (lean_obj_tag(x_58) == 0)
+{
+lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+lean_inc(x_1);
+x_59 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(x_1, x_57);
+x_60 = l_Lean_nullKind;
+x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_54);
+x_16 = x_61;
+goto block_48;
+}
+else
+{
+lean_object* x_62; lean_object* x_63; 
+lean_dec(x_58);
+x_62 = l_Lean_nullKind;
+x_63 = l_Lean_Parser_ParserState_mkNode(x_57, x_62, x_54);
+x_16 = x_63;
+goto block_48;
+}
+}
+else
+{
+lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+lean_dec(x_52);
 lean_dec(x_1);
-x_71 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
-x_72 = l_Lean_Parser_ParserState_mkNode(x_52, x_71, x_18);
-x_73 = l_Lean_Parser_mergeOrElseErrors(x_72, x_13, x_10);
-lean_dec(x_10);
-return x_73;
+x_64 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_51, x_64, x_15);
+x_66 = l_Lean_Parser_mergeOrElseErrors(x_65, x_10, x_7);
+lean_dec(x_7);
+return x_66;
+}
+}
+else
+{
+lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+lean_dec(x_50);
+lean_dec(x_1);
+x_67 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
+x_68 = l_Lean_Parser_ParserState_mkNode(x_49, x_67, x_15);
+x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_10, x_7);
+lean_dec(x_7);
+return x_69;
 }
 }
 }
@@ -9596,7 +9309,7 @@ lean_object* _init_l_Lean_Parser_Command_syntax___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_typeAscription___closed__1;
@@ -9664,7 +9377,7 @@ lean_object* _init_l_Lean_Parser_Command_syntax___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_syntax___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_syntax___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -9691,10 +9404,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_syntax(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_syntax___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_syntax;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -9731,13 +9444,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_syntaxCat___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_syntaxCat___elambda__1___closed__5() {
@@ -9789,149 +9501,139 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_26; lean_object* x_27; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
+lean_inc(x_28);
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
+lean_dec(x_28);
+if (lean_obj_tag(x_29) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__9;
-lean_inc(x_10);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_10);
-x_19 = x_37;
-goto block_28;
-}
-else
-{
-x_19 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__9;
-lean_inc(x_10);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_10);
-x_19 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+lean_dec(x_29);
+x_31 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__6;
+x_32 = lean_string_dec_eq(x_30, x_31);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__9;
-lean_inc(x_10);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_10);
-x_19 = x_41;
-goto block_28;
-}
-block_28:
+if (x_32 == 0)
 {
-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_24; 
-x_21 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__9;
+lean_inc(x_7);
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_7);
+x_16 = x_34;
+goto block_25;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+x_16 = x_26;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_29);
+x_35 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_7);
+x_16 = x_36;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_27);
+x_37 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_7);
+x_16 = x_38;
+goto block_25;
+}
+block_25:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_22 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -9952,7 +9654,7 @@ lean_object* _init_l_Lean_Parser_Command_syntaxCat___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_syntaxCat___closed__1;
@@ -9986,7 +9688,7 @@ lean_object* _init_l_Lean_Parser_Command_syntaxCat___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_syntaxCat___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_syntaxCat___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -10013,250 +9715,229 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Command_syntaxCat(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_syntaxCat___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_syntaxCat;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_Command_macroArgType___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macroArgType___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-x_9 = l_Lean_Parser_Syntax_ident___elambda__1___closed__4;
-x_10 = l_Lean_Parser_Syntax_ident___elambda__1___closed__6;
-lean_inc(x_2);
-x_11 = l_Lean_Parser_nonReservedSymbolFnAux(x_9, x_10, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_6 = l_Lean_Parser_Syntax_ident___elambda__1___closed__4;
+x_7 = l_Lean_Parser_Syntax_ident___elambda__1___closed__6;
+lean_inc(x_1);
+x_8 = l_Lean_Parser_nonReservedSymbolFnAux(x_6, x_7, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_8);
-lean_dec(x_7);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_5);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_inc(x_5);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_4, x_5);
+lean_dec(x_4);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_8);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+x_16 = l_Lean_Parser_Syntax_num___elambda__1___closed__4;
+x_17 = l_Lean_Parser_Syntax_num___elambda__1___closed__6;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_20; 
+lean_dec(x_15);
 lean_dec(x_1);
-return x_11;
+x_20 = l_Lean_Parser_mergeOrElseErrors(x_18, x_10, x_5);
+lean_dec(x_5);
+return x_20;
 }
 else
 {
-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_inc(x_8);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_7, x_8);
-lean_dec(x_7);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = l_Lean_Parser_Syntax_num___elambda__1___closed__4;
-x_20 = l_Lean_Parser_Syntax_num___elambda__1___closed__6;
-lean_inc(x_2);
-x_21 = l_Lean_Parser_nonReservedSymbolFnAux(x_19, x_20, x_2, x_16);
-x_22 = lean_ctor_get(x_21, 3);
+lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+lean_dec(x_19);
+x_22 = lean_ctor_get(x_18, 1);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; 
-lean_dec(x_18);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_23 = l_Lean_Parser_mergeOrElseErrors(x_21, x_13, x_8);
-lean_dec(x_8);
-return x_23;
-}
-else
-{
-lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
+x_23 = lean_nat_dec_eq(x_22, x_5);
 lean_dec(x_22);
-x_25 = lean_ctor_get(x_21, 1);
-lean_inc(x_25);
-x_26 = lean_nat_dec_eq(x_25, x_8);
-lean_dec(x_25);
-if (x_26 == 0)
+if (x_23 == 0)
 {
-lean_object* x_27; 
-lean_dec(x_24);
-lean_dec(x_18);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_24; 
+lean_dec(x_21);
+lean_dec(x_15);
 lean_dec(x_1);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_21, x_13, x_8);
-lean_dec(x_8);
-return x_27;
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_18, x_10, x_5);
+lean_dec(x_5);
+return x_24;
 }
 else
 {
-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_inc(x_8);
-x_28 = l_Lean_Parser_ParserState_restore(x_21, x_18, x_8);
-lean_dec(x_18);
-x_29 = lean_ctor_get(x_28, 0);
-lean_inc(x_29);
-x_30 = lean_array_get_size(x_29);
-lean_dec(x_29);
-x_31 = l_Lean_Parser_Syntax_str___elambda__1___closed__4;
-x_32 = l_Lean_Parser_Syntax_str___elambda__1___closed__6;
-lean_inc(x_2);
-x_33 = l_Lean_Parser_nonReservedSymbolFnAux(x_31, x_32, x_2, x_28);
-x_34 = lean_ctor_get(x_33, 3);
+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_inc(x_5);
+x_25 = l_Lean_Parser_ParserState_restore(x_18, x_15, x_5);
+lean_dec(x_15);
+x_26 = lean_ctor_get(x_25, 0);
+lean_inc(x_26);
+x_27 = lean_array_get_size(x_26);
+lean_dec(x_26);
+x_28 = l_Lean_Parser_Syntax_str___elambda__1___closed__4;
+x_29 = l_Lean_Parser_Syntax_str___elambda__1___closed__6;
+lean_inc(x_1);
+x_30 = l_Lean_Parser_nonReservedSymbolFnAux(x_28, x_29, x_1, x_25);
+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; 
+lean_dec(x_27);
+lean_dec(x_1);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_30, x_21, x_5);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_5);
+lean_dec(x_5);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; uint8_t x_36; 
+x_34 = lean_ctor_get(x_31, 0);
 lean_inc(x_34);
-if (lean_obj_tag(x_34) == 0)
+lean_dec(x_31);
+x_35 = lean_ctor_get(x_30, 1);
+lean_inc(x_35);
+x_36 = lean_nat_dec_eq(x_35, x_5);
+lean_dec(x_35);
+if (x_36 == 0)
 {
-lean_object* x_35; lean_object* x_36; 
-lean_dec(x_30);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_33, x_24, x_8);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_8);
-lean_dec(x_8);
-return x_36;
-}
-else
-{
-lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_37 = lean_ctor_get(x_34, 0);
-lean_inc(x_37);
+lean_object* x_37; lean_object* x_38; 
 lean_dec(x_34);
-x_38 = lean_ctor_get(x_33, 1);
-lean_inc(x_38);
-x_39 = lean_nat_dec_eq(x_38, x_8);
-lean_dec(x_38);
-if (x_39 == 0)
-{
-lean_object* x_40; lean_object* x_41; 
-lean_dec(x_37);
-lean_dec(x_30);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_27);
 lean_dec(x_1);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_33, x_24, x_8);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_13, x_8);
-lean_dec(x_8);
-return x_41;
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_30, x_21, x_5);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_5);
+lean_dec(x_5);
+return x_38;
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_inc(x_8);
-x_42 = l_Lean_Parser_ParserState_restore(x_33, x_30, x_8);
-lean_dec(x_30);
-x_43 = lean_ctor_get(x_42, 0);
-lean_inc(x_43);
-x_44 = lean_array_get_size(x_43);
-lean_dec(x_43);
-x_45 = l_Lean_Parser_Syntax_char___elambda__1___closed__4;
-x_46 = l_Lean_Parser_Syntax_char___elambda__1___closed__6;
-lean_inc(x_2);
-x_47 = l_Lean_Parser_nonReservedSymbolFnAux(x_45, x_46, x_2, x_42);
-x_48 = lean_ctor_get(x_47, 3);
-lean_inc(x_48);
-if (lean_obj_tag(x_48) == 0)
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_inc(x_5);
+x_39 = l_Lean_Parser_ParserState_restore(x_30, x_27, x_5);
+lean_dec(x_27);
+x_40 = lean_ctor_get(x_39, 0);
+lean_inc(x_40);
+x_41 = lean_array_get_size(x_40);
+lean_dec(x_40);
+x_42 = l_Lean_Parser_Syntax_char___elambda__1___closed__4;
+x_43 = l_Lean_Parser_Syntax_char___elambda__1___closed__6;
+lean_inc(x_1);
+x_44 = l_Lean_Parser_nonReservedSymbolFnAux(x_42, x_43, x_1, x_39);
+x_45 = lean_ctor_get(x_44, 3);
+lean_inc(x_45);
+if (lean_obj_tag(x_45) == 0)
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_44);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_41);
 lean_dec(x_1);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_47, x_37, x_8);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_24, x_8);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_13, x_8);
-lean_dec(x_8);
-return x_51;
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_44, x_34, x_5);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_21, x_5);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_5);
+lean_dec(x_5);
+return x_48;
 }
 else
 {
-lean_object* x_52; lean_object* x_53; uint8_t x_54; 
-x_52 = lean_ctor_get(x_48, 0);
-lean_inc(x_52);
-lean_dec(x_48);
-x_53 = lean_ctor_get(x_47, 1);
-lean_inc(x_53);
-x_54 = lean_nat_dec_eq(x_53, x_8);
-lean_dec(x_53);
-if (x_54 == 0)
+lean_object* x_49; lean_object* x_50; uint8_t x_51; 
+x_49 = lean_ctor_get(x_45, 0);
+lean_inc(x_49);
+lean_dec(x_45);
+x_50 = lean_ctor_get(x_44, 1);
+lean_inc(x_50);
+x_51 = lean_nat_dec_eq(x_50, x_5);
+lean_dec(x_50);
+if (x_51 == 0)
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+lean_dec(x_49);
+lean_dec(x_41);
+lean_dec(x_1);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_44, x_34, x_5);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_21, x_5);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_10, x_5);
+lean_dec(x_5);
+return x_54;
+}
+else
 {
 lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-lean_dec(x_52);
-lean_dec(x_44);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_47, x_37, x_8);
-x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_24, x_8);
-x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_13, x_8);
-lean_dec(x_8);
-return x_57;
-}
-else
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-lean_inc(x_8);
-x_58 = l_Lean_Parser_ParserState_restore(x_47, x_44, x_8);
-lean_dec(x_44);
-lean_inc(x_2);
+lean_inc(x_5);
+x_55 = l_Lean_Parser_ParserState_restore(x_44, x_41, x_5);
+lean_dec(x_41);
 lean_inc(x_1);
-x_59 = lean_apply_3(x_5, x_1, x_2, x_58);
-x_60 = lean_ctor_get(x_59, 3);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
+x_56 = l_Lean_Parser_ident___elambda__1(x_1, x_55);
+x_57 = lean_ctor_get(x_56, 3);
+lean_inc(x_57);
+if (lean_obj_tag(x_57) == 0)
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-x_61 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_2, x_59);
-x_62 = l_Lean_Parser_mergeOrElseErrors(x_61, x_52, x_8);
-x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_37, x_8);
-x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_24, x_8);
-x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_13, x_8);
-lean_dec(x_8);
-return x_65;
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_58 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_56);
+x_59 = l_Lean_Parser_mergeOrElseErrors(x_58, x_49, x_5);
+x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_34, x_5);
+x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_21, x_5);
+x_62 = l_Lean_Parser_mergeOrElseErrors(x_61, x_10, x_5);
+lean_dec(x_5);
+return x_62;
 }
 else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-lean_dec(x_60);
-lean_dec(x_2);
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+lean_dec(x_57);
 lean_dec(x_1);
-x_66 = l_Lean_Parser_mergeOrElseErrors(x_59, x_52, x_8);
-x_67 = l_Lean_Parser_mergeOrElseErrors(x_66, x_37, x_8);
-x_68 = l_Lean_Parser_mergeOrElseErrors(x_67, x_24, x_8);
-x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_13, x_8);
-lean_dec(x_8);
-return x_69;
+x_63 = l_Lean_Parser_mergeOrElseErrors(x_56, x_49, x_5);
+x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_34, x_5);
+x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_21, x_5);
+x_66 = l_Lean_Parser_mergeOrElseErrors(x_65, x_10, x_5);
+lean_dec(x_5);
+return x_66;
 }
 }
 }
@@ -10312,7 +9993,7 @@ lean_object* _init_l_Lean_Parser_Command_macroArgType___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroArgType___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroArgType___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -10367,13 +10048,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__5() {
@@ -10384,184 +10064,170 @@ x_1 = lean_mk_string("no space before ':'");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macroArgSimple___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
 lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
+x_16 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__5;
+x_19 = l_Lean_Parser_checkNoWsBeforeFn(x_18, x_1, x_16);
 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; 
-x_21 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__5;
-x_22 = l_Lean_Parser_checkNoWsBeforeFn(x_21, x_2, x_19);
+x_21 = lean_ctor_get(x_19, 1);
+lean_inc(x_21);
+lean_inc(x_1);
+x_22 = l_Lean_Parser_tokenFn(x_1, x_19);
 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; 
-x_24 = lean_ctor_get(x_22, 1);
+lean_object* x_24; lean_object* x_25; 
+x_24 = lean_ctor_get(x_22, 0);
 lean_inc(x_24);
-lean_inc(x_2);
-x_25 = l_Lean_Parser_tokenFn(x_2, x_22);
-x_26 = lean_ctor_get(x_25, 3);
-lean_inc(x_26);
-if (lean_obj_tag(x_26) == 0)
-{
-lean_object* x_27; lean_object* x_28; 
-x_27 = lean_ctor_get(x_25, 0);
-lean_inc(x_27);
-x_28 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_27);
-lean_dec(x_27);
-if (lean_obj_tag(x_28) == 2)
-{
-lean_object* x_29; lean_object* x_30; uint8_t x_31; 
-x_29 = lean_ctor_get(x_28, 1);
-lean_inc(x_29);
-lean_dec(x_28);
-x_30 = l_Lean_Parser_mkAntiquotAux___closed__3;
-x_31 = lean_string_dec_eq(x_29, x_30);
-lean_dec(x_29);
-if (x_31 == 0)
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_2);
-lean_dec(x_1);
-x_32 = l_Lean_Parser_precedence___elambda__1___closed__7;
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_32, x_24);
-x_34 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_18);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
-lean_dec(x_10);
-return x_36;
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_25 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_24);
 lean_dec(x_24);
-x_37 = l_Lean_Parser_Command_macroArgType___elambda__1(x_1, x_2, x_25);
-x_38 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_18);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_13, x_10);
-lean_dec(x_10);
-return x_40;
-}
-}
-else
+if (lean_obj_tag(x_25) == 2)
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-lean_dec(x_28);
-lean_dec(x_2);
-lean_dec(x_1);
-x_41 = l_Lean_Parser_precedence___elambda__1___closed__7;
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_41, x_24);
-x_43 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_18);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_13, x_10);
-lean_dec(x_10);
-return x_45;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_25, 1);
+lean_inc(x_26);
+lean_dec(x_25);
+x_27 = l_Lean_Parser_mkAntiquot___closed__3;
+x_28 = lean_string_dec_eq(x_26, x_27);
 lean_dec(x_26);
-lean_dec(x_2);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_dec(x_1);
+x_29 = l_Lean_Parser_precedence___elambda__1___closed__7;
+x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+x_31 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_21);
+x_34 = l_Lean_Parser_Command_macroArgType___elambda__1(x_1, x_22);
+x_35 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_15);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_10, x_7);
+lean_dec(x_7);
+return x_37;
+}
+}
+else
+{
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+lean_dec(x_25);
+lean_dec(x_1);
+x_38 = l_Lean_Parser_precedence___elambda__1___closed__7;
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_38, x_21);
+x_40 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_15);
+x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_10, x_7);
+lean_dec(x_7);
+return x_42;
+}
+}
+else
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_23);
+lean_dec(x_1);
+x_43 = l_Lean_Parser_precedence___elambda__1___closed__7;
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_43, x_21);
+x_45 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
+x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_10, x_7);
+lean_dec(x_7);
+return x_47;
+}
+}
+else
+{
+lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_dec(x_20);
 lean_dec(x_1);
-x_46 = l_Lean_Parser_precedence___elambda__1___closed__7;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_46, x_24);
 x_48 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_18);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_13, x_10);
-lean_dec(x_10);
+x_49 = l_Lean_Parser_ParserState_mkNode(x_19, x_48, x_15);
+x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_10, x_7);
+lean_dec(x_7);
 return x_50;
 }
 }
 else
 {
 lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_dec(x_23);
-lean_dec(x_2);
+lean_dec(x_17);
 lean_dec(x_1);
 x_51 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
-x_52 = l_Lean_Parser_ParserState_mkNode(x_22, x_51, x_18);
-x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_13, x_10);
-lean_dec(x_10);
+x_52 = l_Lean_Parser_ParserState_mkNode(x_16, x_51, x_15);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_10, x_7);
+lean_dec(x_7);
 return x_53;
 }
 }
-else
-{
-lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_54 = l_Lean_Parser_Command_macroArgSimple___elambda__1___closed__2;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_19, x_54, x_18);
-x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_13, x_10);
-lean_dec(x_10);
-return x_56;
-}
-}
 }
 }
 }
@@ -10572,7 +10238,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4;
 x_1 = l_Lean_Parser_Command_macroArgType;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_mkAntiquotAux___closed__4;
+x_3 = l_Lean_Parser_mkAntiquot___closed__4;
 x_4 = l_Lean_Parser_andthenInfo(x_3, x_2);
 return x_4;
 }
@@ -10591,7 +10257,7 @@ lean_object* _init_l_Lean_Parser_Command_macroArgSimple___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_macroArgSimple___closed__2;
@@ -10625,7 +10291,7 @@ lean_object* _init_l_Lean_Parser_Command_macroArgSimple___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroArgSimple___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroArgSimple___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -10649,202 +10315,198 @@ x_1 = l_Lean_Parser_Command_macroArgSimple___closed__7;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_macroArg___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macroArg___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_2, 1);
 lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 1);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_4);
-lean_dec(x_4);
-lean_inc(x_2);
+x_5 = lean_array_get_size(x_3);
+lean_dec(x_3);
 lean_inc(x_1);
-x_7 = l_Lean_Parser_Command_strLitPrec___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
-lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
+x_6 = l_Lean_Parser_Command_strLitPrec___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_dec(x_6);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 else
 {
-uint8_t x_9; 
-x_9 = !lean_is_exclusive(x_7);
-if (x_9 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_6);
+if (x_8 == 0)
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_10 = lean_ctor_get(x_7, 0);
-x_11 = lean_ctor_get(x_7, 3);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_9 = lean_ctor_get(x_6, 0);
+x_10 = lean_ctor_get(x_6, 3);
+lean_dec(x_10);
+x_11 = lean_ctor_get(x_6, 1);
 lean_dec(x_11);
-x_12 = lean_ctor_get(x_7, 1);
+x_12 = lean_ctor_get(x_7, 0);
+lean_inc(x_12);
+x_13 = l_Array_shrink___main___rarg(x_9, x_5);
+lean_inc(x_4);
+lean_ctor_set(x_6, 1, x_4);
+lean_ctor_set(x_6, 0, x_13);
+x_14 = lean_nat_dec_eq(x_4, x_4);
+if (x_14 == 0)
+{
 lean_dec(x_12);
-x_13 = lean_ctor_get(x_8, 0);
-lean_inc(x_13);
-x_14 = l_Array_shrink___main___rarg(x_10, x_6);
-lean_inc(x_5);
-lean_ctor_set(x_7, 1, x_5);
-lean_ctor_set(x_7, 0, x_14);
-x_15 = lean_nat_dec_eq(x_5, x_5);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_6);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_5);
-x_16 = l_Lean_Parser_ParserState_restore(x_7, x_6, x_5);
-lean_dec(x_6);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_inc(x_4);
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_5, x_4);
+lean_dec(x_5);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = l_Lean_Parser_Command_macroArgSimple___elambda__1(x_1, x_15);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; 
 lean_dec(x_17);
-x_19 = l_Lean_Parser_Command_macroArgSimple___elambda__1(x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_object* x_21; 
-lean_dec(x_18);
-x_21 = l_Lean_Parser_mergeOrElseErrors(x_19, x_13, x_5);
-lean_dec(x_5);
-return x_21;
+x_20 = l_Lean_Parser_mergeOrElseErrors(x_18, x_12, x_4);
+lean_dec(x_4);
+return x_20;
 }
 else
 {
-uint8_t x_22; 
-x_22 = !lean_is_exclusive(x_19);
-if (x_22 == 0)
+uint8_t x_21; 
+x_21 = !lean_is_exclusive(x_18);
+if (x_21 == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_23 = lean_ctor_get(x_19, 0);
-x_24 = lean_ctor_get(x_19, 3);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+x_22 = lean_ctor_get(x_18, 0);
+x_23 = lean_ctor_get(x_18, 3);
+lean_dec(x_23);
+x_24 = lean_ctor_get(x_18, 1);
 lean_dec(x_24);
-x_25 = lean_ctor_get(x_19, 1);
-lean_dec(x_25);
-x_26 = l_Array_shrink___main___rarg(x_23, x_18);
-lean_dec(x_18);
-lean_inc(x_5);
-lean_ctor_set(x_19, 1, x_5);
-lean_ctor_set(x_19, 0, x_26);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_19, x_13, x_5);
-lean_dec(x_5);
-return x_27;
+x_25 = l_Array_shrink___main___rarg(x_22, x_17);
+lean_dec(x_17);
+lean_inc(x_4);
+lean_ctor_set(x_18, 1, x_4);
+lean_ctor_set(x_18, 0, x_25);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_18, x_12, x_4);
+lean_dec(x_4);
+return x_26;
 }
 else
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_28 = lean_ctor_get(x_19, 0);
-x_29 = lean_ctor_get(x_19, 2);
-lean_inc(x_29);
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+x_27 = lean_ctor_get(x_18, 0);
+x_28 = lean_ctor_get(x_18, 2);
 lean_inc(x_28);
-lean_dec(x_19);
-x_30 = l_Array_shrink___main___rarg(x_28, x_18);
+lean_inc(x_27);
 lean_dec(x_18);
-lean_inc(x_5);
-x_31 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_31, 0, x_30);
-lean_ctor_set(x_31, 1, x_5);
-lean_ctor_set(x_31, 2, x_29);
-lean_ctor_set(x_31, 3, x_20);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_13, x_5);
-lean_dec(x_5);
-return x_32;
+x_29 = l_Array_shrink___main___rarg(x_27, x_17);
+lean_dec(x_17);
+lean_inc(x_4);
+x_30 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_30, 0, x_29);
+lean_ctor_set(x_30, 1, x_4);
+lean_ctor_set(x_30, 2, x_28);
+lean_ctor_set(x_30, 3, x_19);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_12, x_4);
+lean_dec(x_4);
+return x_31;
 }
 }
 }
 }
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; 
-x_33 = lean_ctor_get(x_7, 0);
-x_34 = lean_ctor_get(x_7, 2);
-lean_inc(x_34);
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_32 = lean_ctor_get(x_6, 0);
+x_33 = lean_ctor_get(x_6, 2);
 lean_inc(x_33);
-lean_dec(x_7);
-x_35 = lean_ctor_get(x_8, 0);
-lean_inc(x_35);
-x_36 = l_Array_shrink___main___rarg(x_33, x_6);
-lean_inc(x_5);
-x_37 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_37, 0, x_36);
-lean_ctor_set(x_37, 1, x_5);
-lean_ctor_set(x_37, 2, x_34);
-lean_ctor_set(x_37, 3, x_8);
-x_38 = lean_nat_dec_eq(x_5, x_5);
-if (x_38 == 0)
-{
-lean_dec(x_35);
+lean_inc(x_32);
 lean_dec(x_6);
+x_34 = lean_ctor_get(x_7, 0);
+lean_inc(x_34);
+x_35 = l_Array_shrink___main___rarg(x_32, x_5);
+lean_inc(x_4);
+x_36 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_36, 0, x_35);
+lean_ctor_set(x_36, 1, x_4);
+lean_ctor_set(x_36, 2, x_33);
+lean_ctor_set(x_36, 3, x_7);
+x_37 = lean_nat_dec_eq(x_4, x_4);
+if (x_37 == 0)
+{
+lean_dec(x_34);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_37;
+return x_36;
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_inc(x_5);
-x_39 = l_Lean_Parser_ParserState_restore(x_37, x_6, x_5);
-lean_dec(x_6);
-x_40 = lean_ctor_get(x_39, 0);
-lean_inc(x_40);
-x_41 = lean_array_get_size(x_40);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+lean_inc(x_4);
+x_38 = l_Lean_Parser_ParserState_restore(x_36, x_5, x_4);
+lean_dec(x_5);
+x_39 = lean_ctor_get(x_38, 0);
+lean_inc(x_39);
+x_40 = lean_array_get_size(x_39);
+lean_dec(x_39);
+x_41 = l_Lean_Parser_Command_macroArgSimple___elambda__1(x_1, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; 
 lean_dec(x_40);
-x_42 = l_Lean_Parser_Command_macroArgSimple___elambda__1(x_1, x_2, x_39);
-x_43 = lean_ctor_get(x_42, 3);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; 
-lean_dec(x_41);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_42, x_35, x_5);
-lean_dec(x_5);
-return x_44;
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_41, x_34, x_4);
+lean_dec(x_4);
+return x_43;
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-x_45 = lean_ctor_get(x_42, 0);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_44 = lean_ctor_get(x_41, 0);
+lean_inc(x_44);
+x_45 = lean_ctor_get(x_41, 2);
 lean_inc(x_45);
-x_46 = lean_ctor_get(x_42, 2);
-lean_inc(x_46);
-if (lean_is_exclusive(x_42)) {
- lean_ctor_release(x_42, 0);
- lean_ctor_release(x_42, 1);
- lean_ctor_release(x_42, 2);
- lean_ctor_release(x_42, 3);
- x_47 = x_42;
+if (lean_is_exclusive(x_41)) {
+ lean_ctor_release(x_41, 0);
+ lean_ctor_release(x_41, 1);
+ lean_ctor_release(x_41, 2);
+ lean_ctor_release(x_41, 3);
+ x_46 = x_41;
 } else {
- lean_dec_ref(x_42);
- x_47 = lean_box(0);
+ lean_dec_ref(x_41);
+ x_46 = lean_box(0);
 }
-x_48 = l_Array_shrink___main___rarg(x_45, x_41);
-lean_dec(x_41);
-lean_inc(x_5);
-if (lean_is_scalar(x_47)) {
- x_49 = lean_alloc_ctor(0, 4, 0);
+x_47 = l_Array_shrink___main___rarg(x_44, x_40);
+lean_dec(x_40);
+lean_inc(x_4);
+if (lean_is_scalar(x_46)) {
+ x_48 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_49 = x_47;
+ x_48 = x_46;
 }
-lean_ctor_set(x_49, 0, x_48);
-lean_ctor_set(x_49, 1, x_5);
-lean_ctor_set(x_49, 2, x_46);
-lean_ctor_set(x_49, 3, x_43);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_35, x_5);
-lean_dec(x_5);
-return x_50;
+lean_ctor_set(x_48, 0, x_47);
+lean_ctor_set(x_48, 1, x_4);
+lean_ctor_set(x_48, 2, x_45);
+lean_ctor_set(x_48, 3, x_42);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_34, x_4);
+lean_dec(x_4);
+return x_49;
 }
 }
 }
@@ -10869,7 +10531,7 @@ lean_object* _init_l_Lean_Parser_Command_macroArg___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroArg___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroArg___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -10893,109 +10555,106 @@ x_1 = l_Lean_Parser_Command_macroArg___closed__3;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_macroHead___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macroHead___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_2, 1);
 lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 1);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_4);
-lean_dec(x_4);
-lean_inc(x_2);
+x_5 = lean_array_get_size(x_3);
+lean_dec(x_3);
 lean_inc(x_1);
-x_7 = l_Lean_Parser_Command_macroArg___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+x_6 = l_Lean_Parser_Command_macroArg___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_7;
-}
-else
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_7, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_10, x_5);
-lean_dec(x_10);
-if (x_11 == 0)
-{
+x_10 = lean_nat_dec_eq(x_9, x_4);
 lean_dec(x_9);
-lean_dec(x_6);
+if (x_10 == 0)
+{
+lean_dec(x_8);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_5);
-x_12 = l_Lean_Parser_ParserState_restore(x_7, x_6, x_5);
-lean_dec(x_6);
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-x_14 = lean_array_get_size(x_13);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_4);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_5, x_4);
+lean_dec(x_5);
+x_12 = lean_ctor_get(x_11, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_Command_identPrec___elambda__1(x_1, x_11);
+x_15 = lean_ctor_get(x_14, 3);
+lean_inc(x_15);
+if (lean_obj_tag(x_15) == 0)
+{
+lean_object* x_16; 
 lean_dec(x_13);
-x_15 = l_Lean_Parser_Command_identPrec___elambda__1(x_1, x_2, x_12);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; 
-lean_dec(x_14);
-x_17 = l_Lean_Parser_mergeOrElseErrors(x_15, x_9, x_5);
-lean_dec(x_5);
-return x_17;
+x_16 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_4);
+lean_dec(x_4);
+return x_16;
 }
 else
 {
-uint8_t x_18; 
-x_18 = !lean_is_exclusive(x_15);
-if (x_18 == 0)
+uint8_t x_17; 
+x_17 = !lean_is_exclusive(x_14);
+if (x_17 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_19 = lean_ctor_get(x_15, 0);
-x_20 = lean_ctor_get(x_15, 3);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_14, 0);
+x_19 = lean_ctor_get(x_14, 3);
+lean_dec(x_19);
+x_20 = lean_ctor_get(x_14, 1);
 lean_dec(x_20);
-x_21 = lean_ctor_get(x_15, 1);
-lean_dec(x_21);
-x_22 = l_Array_shrink___main___rarg(x_19, x_14);
-lean_dec(x_14);
-lean_inc(x_5);
-lean_ctor_set(x_15, 1, x_5);
-lean_ctor_set(x_15, 0, x_22);
-x_23 = l_Lean_Parser_mergeOrElseErrors(x_15, x_9, x_5);
-lean_dec(x_5);
-return x_23;
+x_21 = l_Array_shrink___main___rarg(x_18, x_13);
+lean_dec(x_13);
+lean_inc(x_4);
+lean_ctor_set(x_14, 1, x_4);
+lean_ctor_set(x_14, 0, x_21);
+x_22 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_4);
+lean_dec(x_4);
+return x_22;
 }
 else
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = lean_ctor_get(x_15, 0);
-x_25 = lean_ctor_get(x_15, 2);
-lean_inc(x_25);
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = lean_ctor_get(x_14, 0);
+x_24 = lean_ctor_get(x_14, 2);
 lean_inc(x_24);
-lean_dec(x_15);
-x_26 = l_Array_shrink___main___rarg(x_24, x_14);
+lean_inc(x_23);
 lean_dec(x_14);
-lean_inc(x_5);
-x_27 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_27, 0, x_26);
-lean_ctor_set(x_27, 1, x_5);
-lean_ctor_set(x_27, 2, x_25);
-lean_ctor_set(x_27, 3, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_9, x_5);
-lean_dec(x_5);
-return x_28;
+x_25 = l_Array_shrink___main___rarg(x_23, x_13);
+lean_dec(x_13);
+lean_inc(x_4);
+x_26 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_26, 0, x_25);
+lean_ctor_set(x_26, 1, x_4);
+lean_ctor_set(x_26, 2, x_24);
+lean_ctor_set(x_26, 3, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_8, x_4);
+lean_dec(x_4);
+return x_27;
 }
 }
 }
@@ -11020,7 +10679,7 @@ lean_object* _init_l_Lean_Parser_Command_macroHead___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroHead___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroHead___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -11044,349 +10703,348 @@ x_1 = l_Lean_Parser_Command_macroHead___closed__3;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_macroTailTactic___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macroTailTactic___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_25; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_72; lean_object* x_73; 
-x_44 = lean_ctor_get(x_3, 0);
-lean_inc(x_44);
-x_45 = lean_ctor_get(x_3, 1);
-lean_inc(x_45);
-x_46 = lean_array_get_size(x_44);
-lean_dec(x_44);
-lean_inc(x_2);
-x_72 = l_Lean_Parser_tokenFn(x_2, x_3);
-x_73 = lean_ctor_get(x_72, 3);
-lean_inc(x_73);
-if (lean_obj_tag(x_73) == 0)
+lean_object* x_3; lean_object* x_23; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_70; lean_object* x_71; 
+x_42 = lean_ctor_get(x_2, 0);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_2, 1);
+lean_inc(x_43);
+x_44 = lean_array_get_size(x_42);
+lean_dec(x_42);
+lean_inc(x_1);
+x_70 = l_Lean_Parser_tokenFn(x_1, x_2);
+x_71 = lean_ctor_get(x_70, 3);
+lean_inc(x_71);
+if (lean_obj_tag(x_71) == 0)
 {
-lean_object* x_74; lean_object* x_75; 
-x_74 = lean_ctor_get(x_72, 0);
+lean_object* x_72; lean_object* x_73; 
+x_72 = lean_ctor_get(x_70, 0);
+lean_inc(x_72);
+x_73 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_72);
+lean_dec(x_72);
+if (lean_obj_tag(x_73) == 2)
+{
+lean_object* x_74; lean_object* x_75; uint8_t x_76; 
+x_74 = lean_ctor_get(x_73, 1);
 lean_inc(x_74);
-x_75 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_74);
+lean_dec(x_73);
+x_75 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
+x_76 = lean_string_dec_eq(x_74, x_75);
 lean_dec(x_74);
-if (lean_obj_tag(x_75) == 2)
+if (x_76 == 0)
 {
-lean_object* x_76; lean_object* x_77; uint8_t x_78; 
-x_76 = lean_ctor_get(x_75, 1);
-lean_inc(x_76);
-lean_dec(x_75);
-x_77 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
-x_78 = lean_string_dec_eq(x_76, x_77);
-lean_dec(x_76);
-if (x_78 == 0)
-{
-lean_object* x_79; lean_object* x_80; 
-x_79 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_45);
-x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_79, x_45);
-x_47 = x_80;
-goto block_71;
+lean_object* x_77; lean_object* x_78; 
+x_77 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_43);
+x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_70, x_77, x_43);
+x_45 = x_78;
+goto block_69;
 }
 else
 {
-x_47 = x_72;
-goto block_71;
+x_45 = x_70;
+goto block_69;
+}
+}
+else
+{
+lean_object* x_79; lean_object* x_80; 
+lean_dec(x_73);
+x_79 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_43);
+x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_70, x_79, x_43);
+x_45 = x_80;
+goto block_69;
 }
 }
 else
 {
 lean_object* x_81; lean_object* x_82; 
-lean_dec(x_75);
+lean_dec(x_71);
 x_81 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_45);
-x_82 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_81, x_45);
-x_47 = x_82;
-goto block_71;
+lean_inc(x_43);
+x_82 = l_Lean_Parser_ParserState_mkErrorsAt(x_70, x_81, x_43);
+x_45 = x_82;
+goto block_69;
 }
+block_22:
+{
+lean_object* x_4; 
+x_4 = lean_ctor_get(x_3, 3);
+lean_inc(x_4);
+if (lean_obj_tag(x_4) == 0)
+{
+uint8_t x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = 1;
+lean_inc(x_1);
+x_6 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_5, x_5, x_1, x_3);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = l_Lean_Parser_tokenFn(x_1, x_6);
+x_10 = lean_ctor_get(x_9, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_object* x_11; lean_object* x_12; 
+x_11 = lean_ctor_get(x_9, 0);
+lean_inc(x_11);
+x_12 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_11);
+lean_dec(x_11);
+if (lean_obj_tag(x_12) == 2)
+{
+lean_object* x_13; lean_object* x_14; uint8_t x_15; 
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_15 = lean_string_dec_eq(x_13, x_14);
+lean_dec(x_13);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; 
+x_16 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_16, x_8);
+return x_17;
 }
 else
 {
-lean_object* x_83; lean_object* x_84; 
-lean_dec(x_73);
-x_83 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_45);
-x_84 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_83, x_45);
-x_47 = x_84;
-goto block_71;
+lean_dec(x_8);
+return x_9;
 }
-block_24:
-{
-lean_object* x_5; 
-x_5 = lean_ctor_get(x_4, 3);
-lean_inc(x_5);
-if (lean_obj_tag(x_5) == 0)
-{
-uint8_t x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; 
-x_6 = 0;
-x_7 = 1;
-lean_inc(x_2);
-x_8 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_6, x_7, x_7, x_1, x_2, x_4);
-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; 
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = l_Lean_Parser_tokenFn(x_2, x_8);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_11, 0);
-lean_inc(x_13);
-x_14 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_13);
-lean_dec(x_13);
-if (lean_obj_tag(x_14) == 2)
-{
-lean_object* x_15; lean_object* x_16; uint8_t x_17; 
-x_15 = lean_ctor_get(x_14, 1);
-lean_inc(x_15);
-lean_dec(x_14);
-x_16 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_17 = lean_string_dec_eq(x_15, x_16);
-lean_dec(x_15);
-if (x_17 == 0)
+}
+else
 {
 lean_object* x_18; lean_object* x_19; 
-x_18 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_18, x_10);
+lean_dec(x_12);
+x_18 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_18, x_8);
 return x_19;
 }
-else
-{
-lean_dec(x_10);
-return x_11;
-}
 }
 else
 {
 lean_object* x_20; lean_object* x_21; 
-lean_dec(x_14);
-x_20 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_20, x_10);
+lean_dec(x_10);
+x_20 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_20, x_8);
 return x_21;
 }
 }
 else
 {
-lean_object* x_22; lean_object* x_23; 
-lean_dec(x_12);
-x_22 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_22, x_10);
-return x_23;
+lean_dec(x_7);
+lean_dec(x_1);
+return x_6;
 }
 }
 else
 {
-lean_dec(x_9);
-lean_dec(x_2);
-return x_8;
+lean_dec(x_4);
+lean_dec(x_1);
+return x_3;
 }
 }
-else
+block_41:
 {
-lean_dec(x_5);
-lean_dec(x_2);
-return x_4;
-}
-}
-block_43:
+lean_object* x_24; 
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_26; 
+lean_object* x_25; lean_object* x_26; 
+lean_inc(x_1);
+x_25 = l_Lean_Parser_darrow___elambda__1(x_1, x_23);
 x_26 = lean_ctor_get(x_25, 3);
 lean_inc(x_26);
 if (lean_obj_tag(x_26) == 0)
 {
-lean_object* x_27; lean_object* x_28; 
-lean_inc(x_2);
-x_27 = l_Lean_Parser_darrow___elambda__1___rarg(x_2, x_25);
-x_28 = lean_ctor_get(x_27, 3);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = lean_ctor_get(x_27, 1);
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_27 = lean_ctor_get(x_25, 1);
+lean_inc(x_27);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_25);
+x_29 = lean_ctor_get(x_28, 3);
 lean_inc(x_29);
-lean_inc(x_2);
-x_30 = l_Lean_Parser_tokenFn(x_2, x_27);
-x_31 = lean_ctor_get(x_30, 3);
-lean_inc(x_31);
-if (lean_obj_tag(x_31) == 0)
+if (lean_obj_tag(x_29) == 0)
 {
-lean_object* x_32; lean_object* x_33; 
-x_32 = lean_ctor_get(x_30, 0);
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
+lean_inc(x_30);
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
+lean_dec(x_30);
+if (lean_obj_tag(x_31) == 2)
+{
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
 lean_inc(x_32);
-x_33 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
 lean_dec(x_32);
-if (lean_obj_tag(x_33) == 2)
+if (x_34 == 0)
 {
-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_stxQuot___elambda__1___closed__6;
-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_stxQuot___elambda__1___closed__9;
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_30, x_37, x_29);
-x_4 = x_38;
-goto block_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_27);
+x_3 = x_36;
+goto block_22;
 }
 else
 {
-lean_dec(x_29);
-x_4 = x_30;
-goto block_24;
+lean_dec(x_27);
+x_3 = x_28;
+goto block_22;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_27);
+x_3 = x_38;
+goto block_22;
 }
 }
 else
 {
 lean_object* x_39; lean_object* x_40; 
-lean_dec(x_33);
+lean_dec(x_29);
 x_39 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_30, x_39, x_29);
-x_4 = x_40;
-goto block_24;
-}
-}
-else
-{
-lean_object* x_41; lean_object* x_42; 
-lean_dec(x_31);
-x_41 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_30, x_41, x_29);
-x_4 = x_42;
-goto block_24;
-}
-}
-else
-{
-lean_dec(x_28);
-lean_dec(x_2);
-return x_27;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_27);
+x_3 = x_40;
+goto block_22;
 }
 }
 else
 {
 lean_dec(x_26);
-lean_dec(x_2);
+lean_dec(x_1);
 return x_25;
 }
 }
-block_71:
+else
 {
-lean_object* x_48; 
-x_48 = lean_ctor_get(x_47, 3);
-lean_inc(x_48);
-if (lean_obj_tag(x_48) == 0)
+lean_dec(x_24);
+lean_dec(x_1);
+return x_23;
+}
+}
+block_69:
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-x_49 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-lean_inc(x_2);
-x_50 = l_Lean_Parser_identEqFn___rarg(x_49, x_1, x_2, x_47);
-x_51 = lean_ctor_get(x_50, 3);
-lean_inc(x_51);
-if (lean_obj_tag(x_51) == 0)
+lean_object* x_46; 
+x_46 = lean_ctor_get(x_45, 3);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
 {
-lean_dec(x_46);
-lean_dec(x_45);
-x_25 = x_50;
-goto block_43;
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_47 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+lean_inc(x_1);
+x_48 = l_Lean_Parser_identEqFn(x_47, x_1, x_45);
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_dec(x_44);
+lean_dec(x_43);
+x_23 = x_48;
+goto block_41;
 }
 else
 {
-uint8_t x_52; 
-x_52 = !lean_is_exclusive(x_50);
-if (x_52 == 0)
+uint8_t x_50; 
+x_50 = !lean_is_exclusive(x_48);
+if (x_50 == 0)
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_53 = lean_ctor_get(x_50, 0);
-x_54 = lean_ctor_get(x_50, 3);
-lean_dec(x_54);
-x_55 = lean_ctor_get(x_50, 1);
-lean_dec(x_55);
-x_56 = l_Array_shrink___main___rarg(x_53, x_46);
-lean_dec(x_46);
-lean_ctor_set(x_50, 1, x_45);
-lean_ctor_set(x_50, 0, x_56);
-x_25 = x_50;
-goto block_43;
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_51 = lean_ctor_get(x_48, 0);
+x_52 = lean_ctor_get(x_48, 3);
+lean_dec(x_52);
+x_53 = lean_ctor_get(x_48, 1);
+lean_dec(x_53);
+x_54 = l_Array_shrink___main___rarg(x_51, x_44);
+lean_dec(x_44);
+lean_ctor_set(x_48, 1, x_43);
+lean_ctor_set(x_48, 0, x_54);
+x_23 = x_48;
+goto block_41;
 }
 else
 {
-lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_57 = lean_ctor_get(x_50, 0);
-x_58 = lean_ctor_get(x_50, 2);
-lean_inc(x_58);
-lean_inc(x_57);
-lean_dec(x_50);
-x_59 = l_Array_shrink___main___rarg(x_57, x_46);
-lean_dec(x_46);
-x_60 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_60, 0, x_59);
-lean_ctor_set(x_60, 1, x_45);
-lean_ctor_set(x_60, 2, x_58);
-lean_ctor_set(x_60, 3, x_51);
-x_25 = x_60;
-goto block_43;
-}
-}
-}
-else
-{
-lean_object* x_61; 
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_55 = lean_ctor_get(x_48, 0);
+x_56 = lean_ctor_get(x_48, 2);
+lean_inc(x_56);
+lean_inc(x_55);
 lean_dec(x_48);
-x_61 = lean_ctor_get(x_47, 3);
-lean_inc(x_61);
-if (lean_obj_tag(x_61) == 0)
+x_57 = l_Array_shrink___main___rarg(x_55, x_44);
+lean_dec(x_44);
+x_58 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_58, 0, x_57);
+lean_ctor_set(x_58, 1, x_43);
+lean_ctor_set(x_58, 2, x_56);
+lean_ctor_set(x_58, 3, x_49);
+x_23 = x_58;
+goto block_41;
+}
+}
+}
+else
 {
+lean_object* x_59; 
 lean_dec(x_46);
+x_59 = lean_ctor_get(x_45, 3);
+lean_inc(x_59);
+if (lean_obj_tag(x_59) == 0)
+{
+lean_dec(x_44);
+lean_dec(x_43);
+x_23 = x_45;
+goto block_41;
+}
+else
+{
+uint8_t x_60; 
+x_60 = !lean_is_exclusive(x_45);
+if (x_60 == 0)
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+x_61 = lean_ctor_get(x_45, 0);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 1);
+lean_dec(x_63);
+x_64 = l_Array_shrink___main___rarg(x_61, x_44);
+lean_dec(x_44);
+lean_ctor_set(x_45, 1, x_43);
+lean_ctor_set(x_45, 0, x_64);
+x_23 = x_45;
+goto block_41;
+}
+else
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+x_65 = lean_ctor_get(x_45, 0);
+x_66 = lean_ctor_get(x_45, 2);
+lean_inc(x_66);
+lean_inc(x_65);
 lean_dec(x_45);
-x_25 = x_47;
-goto block_43;
-}
-else
-{
-uint8_t x_62; 
-x_62 = !lean_is_exclusive(x_47);
-if (x_62 == 0)
-{
-lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
-x_63 = lean_ctor_get(x_47, 0);
-x_64 = lean_ctor_get(x_47, 3);
-lean_dec(x_64);
-x_65 = lean_ctor_get(x_47, 1);
-lean_dec(x_65);
-x_66 = l_Array_shrink___main___rarg(x_63, x_46);
-lean_dec(x_46);
-lean_ctor_set(x_47, 1, x_45);
-lean_ctor_set(x_47, 0, x_66);
-x_25 = x_47;
-goto block_43;
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
-x_67 = lean_ctor_get(x_47, 0);
-x_68 = lean_ctor_get(x_47, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_47);
-x_69 = l_Array_shrink___main___rarg(x_67, x_46);
-lean_dec(x_46);
-x_70 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_70, 1, x_45);
-lean_ctor_set(x_70, 2, x_68);
-lean_ctor_set(x_70, 3, x_61);
-x_25 = x_70;
-goto block_43;
+x_67 = l_Array_shrink___main___rarg(x_65, x_44);
+lean_dec(x_44);
+x_68 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_68, 0, x_67);
+lean_ctor_set(x_68, 1, x_43);
+lean_ctor_set(x_68, 2, x_66);
+lean_ctor_set(x_68, 3, x_59);
+x_23 = x_68;
+goto block_41;
 }
 }
 }
@@ -11449,7 +11107,7 @@ lean_object* _init_l_Lean_Parser_Command_macroTailTactic___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroTailTactic___elambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroTailTactic___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -11473,426 +11131,416 @@ x_1 = l_Lean_Parser_Command_macroTailTactic___closed__7;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_macroTailTactic___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macroTailCommand___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; 
-x_4 = l_Lean_Parser_Command_macroTailTactic___elambda__1(x_1, x_2, x_3);
-lean_dec(x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_Command_macroTailCommand___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
+lean_object* x_3; lean_object* x_20; lean_object* x_44; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_91; lean_object* x_92; 
+x_63 = lean_ctor_get(x_2, 0);
+lean_inc(x_63);
+x_64 = lean_ctor_get(x_2, 1);
+lean_inc(x_64);
+x_65 = lean_array_get_size(x_63);
+lean_dec(x_63);
+lean_inc(x_1);
+x_91 = l_Lean_Parser_tokenFn(x_1, x_2);
+x_92 = lean_ctor_get(x_91, 3);
+lean_inc(x_92);
+if (lean_obj_tag(x_92) == 0)
 {
-lean_object* x_4; lean_object* x_21; lean_object* x_46; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_93; lean_object* x_94; 
-x_65 = lean_ctor_get(x_3, 0);
-lean_inc(x_65);
-x_66 = lean_ctor_get(x_3, 1);
-lean_inc(x_66);
-x_67 = lean_array_get_size(x_65);
-lean_dec(x_65);
-lean_inc(x_2);
-x_93 = l_Lean_Parser_tokenFn(x_2, x_3);
-x_94 = lean_ctor_get(x_93, 3);
-lean_inc(x_94);
-if (lean_obj_tag(x_94) == 0)
+lean_object* x_93; lean_object* x_94; 
+x_93 = lean_ctor_get(x_91, 0);
+lean_inc(x_93);
+x_94 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_93);
+lean_dec(x_93);
+if (lean_obj_tag(x_94) == 2)
 {
-lean_object* x_95; lean_object* x_96; 
-x_95 = lean_ctor_get(x_93, 0);
+lean_object* x_95; lean_object* x_96; uint8_t x_97; 
+x_95 = lean_ctor_get(x_94, 1);
 lean_inc(x_95);
-x_96 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_95);
+lean_dec(x_94);
+x_96 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
+x_97 = lean_string_dec_eq(x_95, x_96);
 lean_dec(x_95);
-if (lean_obj_tag(x_96) == 2)
+if (x_97 == 0)
 {
-lean_object* x_97; lean_object* x_98; uint8_t x_99; 
-x_97 = lean_ctor_get(x_96, 1);
-lean_inc(x_97);
-lean_dec(x_96);
-x_98 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
-x_99 = lean_string_dec_eq(x_97, x_98);
-lean_dec(x_97);
-if (x_99 == 0)
-{
-lean_object* x_100; lean_object* x_101; 
-x_100 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_66);
-x_101 = l_Lean_Parser_ParserState_mkErrorsAt(x_93, x_100, x_66);
-x_68 = x_101;
-goto block_92;
+lean_object* x_98; lean_object* x_99; 
+x_98 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_64);
+x_99 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_98, x_64);
+x_66 = x_99;
+goto block_90;
 }
 else
 {
-x_68 = x_93;
-goto block_92;
+x_66 = x_91;
+goto block_90;
+}
+}
+else
+{
+lean_object* x_100; lean_object* x_101; 
+lean_dec(x_94);
+x_100 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_64);
+x_101 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_100, x_64);
+x_66 = x_101;
+goto block_90;
 }
 }
 else
 {
 lean_object* x_102; lean_object* x_103; 
-lean_dec(x_96);
+lean_dec(x_92);
 x_102 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_66);
-x_103 = l_Lean_Parser_ParserState_mkErrorsAt(x_93, x_102, x_66);
-x_68 = x_103;
-goto block_92;
+lean_inc(x_64);
+x_103 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_102, x_64);
+x_66 = x_103;
+goto block_90;
 }
-}
-else
+block_19:
 {
-lean_object* x_104; lean_object* x_105; 
-lean_dec(x_94);
-x_104 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_66);
-x_105 = l_Lean_Parser_ParserState_mkErrorsAt(x_93, x_104, x_66);
-x_68 = x_105;
-goto block_92;
-}
-block_20:
+lean_object* x_4; 
+x_4 = lean_ctor_get(x_3, 3);
+lean_inc(x_4);
+if (lean_obj_tag(x_4) == 0)
 {
-lean_object* x_5; 
-x_5 = lean_ctor_get(x_4, 3);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = lean_ctor_get(x_3, 1);
 lean_inc(x_5);
-if (lean_obj_tag(x_5) == 0)
+x_6 = l_Lean_Parser_tokenFn(x_1, x_3);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_6 = lean_ctor_get(x_4, 1);
-lean_inc(x_6);
-x_7 = l_Lean_Parser_tokenFn(x_2, x_4);
-x_8 = lean_ctor_get(x_7, 3);
+lean_object* x_8; lean_object* x_9; 
+x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; lean_object* x_10; 
-x_9 = lean_ctor_get(x_7, 0);
-lean_inc(x_9);
-x_10 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_9);
-lean_dec(x_9);
-if (lean_obj_tag(x_10) == 2)
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-lean_dec(x_10);
-x_12 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_13 = lean_string_dec_eq(x_11, x_12);
-lean_dec(x_11);
-if (x_13 == 0)
-{
-lean_object* x_14; lean_object* x_15; 
-x_14 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_15 = l_Lean_Parser_ParserState_mkErrorsAt(x_7, x_14, x_6);
-return x_15;
-}
-else
-{
-lean_dec(x_6);
-return x_7;
-}
-}
-else
-{
-lean_object* x_16; lean_object* x_17; 
-lean_dec(x_10);
-x_16 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_7, x_16, x_6);
-return x_17;
-}
-}
-else
-{
-lean_object* x_18; lean_object* x_19; 
+x_9 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_8);
 lean_dec(x_8);
-x_18 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_7, x_18, x_6);
-return x_19;
-}
+if (lean_obj_tag(x_9) == 2)
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 1);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_12 = lean_string_dec_eq(x_10, x_11);
+lean_dec(x_10);
+if (x_12 == 0)
+{
+lean_object* x_13; lean_object* x_14; 
+x_13 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_14 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_13, x_5);
+return x_14;
 }
 else
 {
 lean_dec(x_5);
-lean_dec(x_2);
-return x_4;
+return x_6;
 }
 }
-block_45:
+else
 {
-lean_object* x_22; 
-x_22 = lean_ctor_get(x_21, 3);
+lean_object* x_15; lean_object* x_16; 
+lean_dec(x_9);
+x_15 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_16 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_15, x_5);
+return x_16;
+}
+}
+else
+{
+lean_object* x_17; lean_object* x_18; 
+lean_dec(x_7);
+x_17 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_18 = l_Lean_Parser_ParserState_mkErrorsAt(x_6, x_17, x_5);
+return x_18;
+}
+}
+else
+{
+lean_dec(x_4);
+lean_dec(x_1);
+return x_3;
+}
+}
+block_43:
+{
+lean_object* x_21; 
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+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_20, 0);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_23 = lean_ctor_get(x_21, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
-lean_dec(x_23);
-x_25 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_26 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_27 = l_Lean_Parser_categoryParserFn(x_25, x_26, x_2, x_21);
-x_28 = lean_ctor_get(x_27, 3);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-uint8_t x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_29 = 0;
-lean_inc(x_2);
-x_30 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(x_29, x_1, x_2, x_27);
-x_31 = lean_ctor_get(x_30, 0);
-lean_inc(x_31);
-x_32 = lean_array_get_size(x_31);
-lean_dec(x_31);
-x_33 = lean_nat_sub(x_32, x_24);
-lean_dec(x_32);
-x_34 = lean_unsigned_to_nat(1u);
-x_35 = lean_nat_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_nullKind;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_30, x_36, x_24);
-x_4 = x_37;
-goto block_20;
-}
-else
-{
-lean_dec(x_24);
-x_4 = x_30;
-goto block_20;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; 
-lean_dec(x_28);
-x_38 = lean_ctor_get(x_27, 0);
-lean_inc(x_38);
-x_39 = lean_array_get_size(x_38);
-lean_dec(x_38);
-x_40 = lean_nat_sub(x_39, x_24);
-lean_dec(x_39);
-x_41 = lean_unsigned_to_nat(1u);
-x_42 = lean_nat_dec_eq(x_40, x_41);
-lean_dec(x_40);
-if (x_42 == 0)
-{
-lean_object* x_43; lean_object* x_44; 
-x_43 = l_Lean_nullKind;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_27, x_43, x_24);
-x_4 = x_44;
-goto block_20;
-}
-else
-{
-lean_dec(x_24);
-x_4 = x_27;
-goto block_20;
-}
-}
-}
-else
-{
+x_23 = lean_array_get_size(x_22);
 lean_dec(x_22);
-lean_dec(x_2);
-return x_21;
-}
-}
-block_64:
+x_24 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_25 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_26 = l_Lean_Parser_categoryParser___elambda__1(x_24, x_25, x_1, x_20);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
 {
-lean_object* x_47; 
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; 
+lean_inc(x_1);
+x_28 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(x_1, x_26);
+x_29 = lean_ctor_get(x_28, 0);
+lean_inc(x_29);
+x_30 = lean_array_get_size(x_29);
+lean_dec(x_29);
+x_31 = lean_nat_sub(x_30, x_23);
+lean_dec(x_30);
+x_32 = lean_unsigned_to_nat(1u);
+x_33 = lean_nat_dec_eq(x_31, x_32);
+lean_dec(x_31);
+if (x_33 == 0)
+{
+lean_object* x_34; lean_object* x_35; 
+x_34 = l_Lean_nullKind;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_28, x_34, x_23);
+x_3 = x_35;
+goto block_19;
+}
+else
+{
+lean_dec(x_23);
+x_3 = x_28;
+goto block_19;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; 
+lean_dec(x_27);
+x_36 = lean_ctor_get(x_26, 0);
+lean_inc(x_36);
+x_37 = lean_array_get_size(x_36);
+lean_dec(x_36);
+x_38 = lean_nat_sub(x_37, x_23);
+lean_dec(x_37);
+x_39 = lean_unsigned_to_nat(1u);
+x_40 = lean_nat_dec_eq(x_38, x_39);
+lean_dec(x_38);
+if (x_40 == 0)
+{
+lean_object* x_41; lean_object* x_42; 
+x_41 = l_Lean_nullKind;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_26, x_41, x_23);
+x_3 = x_42;
+goto block_19;
+}
+else
+{
+lean_dec(x_23);
+x_3 = x_26;
+goto block_19;
+}
+}
+}
+else
+{
+lean_dec(x_21);
+lean_dec(x_1);
+return x_20;
+}
+}
+block_62:
+{
+lean_object* x_45; 
+x_45 = lean_ctor_get(x_44, 3);
+lean_inc(x_45);
+if (lean_obj_tag(x_45) == 0)
+{
+lean_object* x_46; lean_object* x_47; 
+lean_inc(x_1);
+x_46 = l_Lean_Parser_darrow___elambda__1(x_1, x_44);
 x_47 = lean_ctor_get(x_46, 3);
 lean_inc(x_47);
 if (lean_obj_tag(x_47) == 0)
 {
-lean_object* x_48; lean_object* x_49; 
-lean_inc(x_2);
-x_48 = l_Lean_Parser_darrow___elambda__1___rarg(x_2, x_46);
-x_49 = lean_ctor_get(x_48, 3);
-lean_inc(x_49);
-if (lean_obj_tag(x_49) == 0)
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_50 = lean_ctor_get(x_48, 1);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_48 = lean_ctor_get(x_46, 1);
+lean_inc(x_48);
+lean_inc(x_1);
+x_49 = l_Lean_Parser_tokenFn(x_1, x_46);
+x_50 = lean_ctor_get(x_49, 3);
 lean_inc(x_50);
-lean_inc(x_2);
-x_51 = l_Lean_Parser_tokenFn(x_2, x_48);
-x_52 = lean_ctor_get(x_51, 3);
-lean_inc(x_52);
-if (lean_obj_tag(x_52) == 0)
+if (lean_obj_tag(x_50) == 0)
 {
-lean_object* x_53; lean_object* x_54; 
-x_53 = lean_ctor_get(x_51, 0);
+lean_object* x_51; lean_object* x_52; 
+x_51 = lean_ctor_get(x_49, 0);
+lean_inc(x_51);
+x_52 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_51);
+lean_dec(x_51);
+if (lean_obj_tag(x_52) == 2)
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; 
+x_53 = lean_ctor_get(x_52, 1);
 lean_inc(x_53);
-x_54 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_53);
+lean_dec(x_52);
+x_54 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__6;
+x_55 = lean_string_dec_eq(x_53, x_54);
 lean_dec(x_53);
-if (lean_obj_tag(x_54) == 2)
+if (x_55 == 0)
 {
-lean_object* x_55; lean_object* x_56; uint8_t x_57; 
-x_55 = lean_ctor_get(x_54, 1);
-lean_inc(x_55);
-lean_dec(x_54);
-x_56 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__6;
-x_57 = lean_string_dec_eq(x_55, x_56);
-lean_dec(x_55);
-if (x_57 == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-x_58 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_58, x_50);
-x_21 = x_59;
-goto block_45;
+lean_object* x_56; lean_object* x_57; 
+x_56 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
+x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_56, x_48);
+x_20 = x_57;
+goto block_43;
 }
 else
 {
-lean_dec(x_50);
-x_21 = x_51;
-goto block_45;
+lean_dec(x_48);
+x_20 = x_49;
+goto block_43;
+}
+}
+else
+{
+lean_object* x_58; lean_object* x_59; 
+lean_dec(x_52);
+x_58 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
+x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_58, x_48);
+x_20 = x_59;
+goto block_43;
 }
 }
 else
 {
 lean_object* x_60; lean_object* x_61; 
-lean_dec(x_54);
+lean_dec(x_50);
 x_60 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_60, x_50);
-x_21 = x_61;
-goto block_45;
-}
-}
-else
-{
-lean_object* x_62; lean_object* x_63; 
-lean_dec(x_52);
-x_62 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_62, x_50);
-x_21 = x_63;
-goto block_45;
-}
-}
-else
-{
-lean_dec(x_49);
-lean_dec(x_2);
-return x_48;
+x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_60, x_48);
+x_20 = x_61;
+goto block_43;
 }
 }
 else
 {
 lean_dec(x_47);
-lean_dec(x_2);
+lean_dec(x_1);
 return x_46;
 }
 }
-block_92:
+else
 {
-lean_object* x_69; 
-x_69 = lean_ctor_get(x_68, 3);
-lean_inc(x_69);
-if (lean_obj_tag(x_69) == 0)
+lean_dec(x_45);
+lean_dec(x_1);
+return x_44;
+}
+}
+block_90:
 {
-lean_object* x_70; lean_object* x_71; lean_object* x_72; 
-x_70 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-lean_inc(x_2);
-x_71 = l_Lean_Parser_identEqFn___rarg(x_70, x_1, x_2, x_68);
-x_72 = lean_ctor_get(x_71, 3);
-lean_inc(x_72);
-if (lean_obj_tag(x_72) == 0)
+lean_object* x_67; 
+x_67 = lean_ctor_get(x_66, 3);
+lean_inc(x_67);
+if (lean_obj_tag(x_67) == 0)
 {
-lean_dec(x_67);
-lean_dec(x_66);
-x_46 = x_71;
-goto block_64;
+lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+x_68 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+lean_inc(x_1);
+x_69 = l_Lean_Parser_identEqFn(x_68, x_1, x_66);
+x_70 = lean_ctor_get(x_69, 3);
+lean_inc(x_70);
+if (lean_obj_tag(x_70) == 0)
+{
+lean_dec(x_65);
+lean_dec(x_64);
+x_44 = x_69;
+goto block_62;
 }
 else
 {
-uint8_t x_73; 
-x_73 = !lean_is_exclusive(x_71);
-if (x_73 == 0)
+uint8_t x_71; 
+x_71 = !lean_is_exclusive(x_69);
+if (x_71 == 0)
 {
-lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; 
-x_74 = lean_ctor_get(x_71, 0);
-x_75 = lean_ctor_get(x_71, 3);
-lean_dec(x_75);
-x_76 = lean_ctor_get(x_71, 1);
-lean_dec(x_76);
-x_77 = l_Array_shrink___main___rarg(x_74, x_67);
-lean_dec(x_67);
-lean_ctor_set(x_71, 1, x_66);
-lean_ctor_set(x_71, 0, x_77);
-x_46 = x_71;
-goto block_64;
+lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
+x_72 = lean_ctor_get(x_69, 0);
+x_73 = lean_ctor_get(x_69, 3);
+lean_dec(x_73);
+x_74 = lean_ctor_get(x_69, 1);
+lean_dec(x_74);
+x_75 = l_Array_shrink___main___rarg(x_72, x_65);
+lean_dec(x_65);
+lean_ctor_set(x_69, 1, x_64);
+lean_ctor_set(x_69, 0, x_75);
+x_44 = x_69;
+goto block_62;
 }
 else
 {
-lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-x_78 = lean_ctor_get(x_71, 0);
-x_79 = lean_ctor_get(x_71, 2);
-lean_inc(x_79);
-lean_inc(x_78);
-lean_dec(x_71);
-x_80 = l_Array_shrink___main___rarg(x_78, x_67);
-lean_dec(x_67);
-x_81 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_81, 0, x_80);
-lean_ctor_set(x_81, 1, x_66);
-lean_ctor_set(x_81, 2, x_79);
-lean_ctor_set(x_81, 3, x_72);
-x_46 = x_81;
-goto block_64;
-}
-}
-}
-else
-{
-lean_object* x_82; 
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
+x_76 = lean_ctor_get(x_69, 0);
+x_77 = lean_ctor_get(x_69, 2);
+lean_inc(x_77);
+lean_inc(x_76);
 lean_dec(x_69);
-x_82 = lean_ctor_get(x_68, 3);
-lean_inc(x_82);
-if (lean_obj_tag(x_82) == 0)
+x_78 = l_Array_shrink___main___rarg(x_76, x_65);
+lean_dec(x_65);
+x_79 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_79, 0, x_78);
+lean_ctor_set(x_79, 1, x_64);
+lean_ctor_set(x_79, 2, x_77);
+lean_ctor_set(x_79, 3, x_70);
+x_44 = x_79;
+goto block_62;
+}
+}
+}
+else
 {
+lean_object* x_80; 
 lean_dec(x_67);
+x_80 = lean_ctor_get(x_66, 3);
+lean_inc(x_80);
+if (lean_obj_tag(x_80) == 0)
+{
+lean_dec(x_65);
+lean_dec(x_64);
+x_44 = x_66;
+goto block_62;
+}
+else
+{
+uint8_t x_81; 
+x_81 = !lean_is_exclusive(x_66);
+if (x_81 == 0)
+{
+lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+x_82 = lean_ctor_get(x_66, 0);
+x_83 = lean_ctor_get(x_66, 3);
+lean_dec(x_83);
+x_84 = lean_ctor_get(x_66, 1);
+lean_dec(x_84);
+x_85 = l_Array_shrink___main___rarg(x_82, x_65);
+lean_dec(x_65);
+lean_ctor_set(x_66, 1, x_64);
+lean_ctor_set(x_66, 0, x_85);
+x_44 = x_66;
+goto block_62;
+}
+else
+{
+lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; 
+x_86 = lean_ctor_get(x_66, 0);
+x_87 = lean_ctor_get(x_66, 2);
+lean_inc(x_87);
+lean_inc(x_86);
 lean_dec(x_66);
-x_46 = x_68;
-goto block_64;
-}
-else
-{
-uint8_t x_83; 
-x_83 = !lean_is_exclusive(x_68);
-if (x_83 == 0)
-{
-lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-x_84 = lean_ctor_get(x_68, 0);
-x_85 = lean_ctor_get(x_68, 3);
-lean_dec(x_85);
-x_86 = lean_ctor_get(x_68, 1);
-lean_dec(x_86);
-x_87 = l_Array_shrink___main___rarg(x_84, x_67);
-lean_dec(x_67);
-lean_ctor_set(x_68, 1, x_66);
-lean_ctor_set(x_68, 0, x_87);
-x_46 = x_68;
-goto block_64;
-}
-else
-{
-lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
-x_88 = lean_ctor_get(x_68, 0);
-x_89 = lean_ctor_get(x_68, 2);
-lean_inc(x_89);
-lean_inc(x_88);
-lean_dec(x_68);
-x_90 = l_Array_shrink___main___rarg(x_88, x_67);
-lean_dec(x_67);
-x_91 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_66);
-lean_ctor_set(x_91, 2, x_89);
-lean_ctor_set(x_91, 3, x_82);
-x_46 = x_91;
-goto block_64;
+x_88 = l_Array_shrink___main___rarg(x_86, x_65);
+lean_dec(x_65);
+x_89 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_89, 0, x_88);
+lean_ctor_set(x_89, 1, x_64);
+lean_ctor_set(x_89, 2, x_87);
+lean_ctor_set(x_89, 3, x_80);
+x_44 = x_89;
+goto block_62;
 }
 }
 }
@@ -11906,7 +11554,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4;
 x_1 = l_Lean_Parser_Term_stxQuot___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
@@ -11947,7 +11595,7 @@ lean_object* _init_l_Lean_Parser_Command_macroTailCommand___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroTailCommand___elambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroTailCommand___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -11971,418 +11619,404 @@ x_1 = l_Lean_Parser_Command_macroTailCommand___closed__6;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_macroTailCommand___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macroTailDefault___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
+lean_object* x_3; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_83; lean_object* x_84; 
+x_56 = lean_ctor_get(x_2, 0);
+lean_inc(x_56);
+x_57 = lean_ctor_get(x_2, 1);
+lean_inc(x_57);
+x_58 = lean_array_get_size(x_56);
+lean_dec(x_56);
+lean_inc(x_1);
+x_83 = l_Lean_Parser_tokenFn(x_1, x_2);
+x_84 = lean_ctor_get(x_83, 3);
+lean_inc(x_84);
+if (lean_obj_tag(x_84) == 0)
+{
+lean_object* x_85; lean_object* x_86; 
+x_85 = lean_ctor_get(x_83, 0);
+lean_inc(x_85);
+x_86 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_85);
+lean_dec(x_85);
+if (lean_obj_tag(x_86) == 2)
+{
+lean_object* x_87; lean_object* x_88; uint8_t x_89; 
+x_87 = lean_ctor_get(x_86, 1);
+lean_inc(x_87);
+lean_dec(x_86);
+x_88 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
+x_89 = lean_string_dec_eq(x_87, x_88);
+lean_dec(x_87);
+if (x_89 == 0)
+{
+lean_object* x_90; lean_object* x_91; 
+x_90 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_57);
+x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_90, x_57);
+x_59 = x_91;
+goto block_82;
+}
+else
+{
+x_59 = x_83;
+goto block_82;
+}
+}
+else
+{
+lean_object* x_92; lean_object* x_93; 
+lean_dec(x_86);
+x_92 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_57);
+x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_92, x_57);
+x_59 = x_93;
+goto block_82;
+}
+}
+else
+{
+lean_object* x_94; lean_object* x_95; 
+lean_dec(x_84);
+x_94 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_57);
+x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_94, x_57);
+x_59 = x_95;
+goto block_82;
+}
+block_55:
+{
 lean_object* x_4; 
-x_4 = l_Lean_Parser_Command_macroTailCommand___elambda__1(x_1, x_2, x_3);
-lean_dec(x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_Parser_Command_macroTailDefault___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
+x_4 = lean_ctor_get(x_3, 3);
+lean_inc(x_4);
+if (lean_obj_tag(x_4) == 0)
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_86; lean_object* x_87; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_59 = lean_ctor_get(x_3, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_3, 1);
-lean_inc(x_60);
-x_61 = lean_array_get_size(x_59);
-lean_dec(x_59);
-lean_inc(x_2);
-x_86 = l_Lean_Parser_tokenFn(x_2, x_3);
-x_87 = lean_ctor_get(x_86, 3);
-lean_inc(x_87);
-if (lean_obj_tag(x_87) == 0)
+lean_object* x_5; lean_object* x_6; 
+lean_inc(x_1);
+x_5 = l_Lean_Parser_darrow___elambda__1(x_1, x_3);
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
 {
-lean_object* x_88; lean_object* x_89; 
-x_88 = lean_ctor_get(x_86, 0);
-lean_inc(x_88);
-x_89 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_88);
-lean_dec(x_88);
-if (lean_obj_tag(x_89) == 2)
-{
-lean_object* x_90; lean_object* x_91; uint8_t x_92; 
-x_90 = lean_ctor_get(x_89, 1);
-lean_inc(x_90);
-lean_dec(x_89);
-x_91 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
-x_92 = lean_string_dec_eq(x_90, x_91);
-lean_dec(x_90);
-if (x_92 == 0)
-{
-lean_object* x_93; lean_object* x_94; 
-x_93 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_60);
-x_94 = l_Lean_Parser_ParserState_mkErrorsAt(x_86, x_93, x_60);
-x_62 = x_94;
-goto block_85;
-}
-else
-{
-x_62 = x_86;
-goto block_85;
-}
-}
-else
-{
-lean_object* x_95; lean_object* x_96; 
-lean_dec(x_89);
-x_95 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_60);
-x_96 = l_Lean_Parser_ParserState_mkErrorsAt(x_86, x_95, x_60);
-x_62 = x_96;
-goto block_85;
-}
-}
-else
-{
-lean_object* x_97; lean_object* x_98; 
-lean_dec(x_87);
-x_97 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_60);
-x_98 = l_Lean_Parser_ParserState_mkErrorsAt(x_86, x_97, x_60);
-x_62 = x_98;
-goto block_85;
-}
-block_58:
-{
-lean_object* x_7; 
-x_7 = lean_ctor_get(x_6, 3);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_21; lean_object* x_42; lean_object* x_43; 
+x_7 = lean_ctor_get(x_5, 0);
 lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
-{
-lean_object* x_8; lean_object* x_9; 
-lean_inc(x_2);
-x_8 = l_Lean_Parser_darrow___elambda__1___rarg(x_2, x_6);
-x_9 = lean_ctor_get(x_8, 3);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_5, 1);
 lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
+lean_inc(x_1);
+x_42 = l_Lean_Parser_tokenFn(x_1, x_5);
+x_43 = lean_ctor_get(x_42, 3);
+lean_inc(x_43);
+if (lean_obj_tag(x_43) == 0)
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_24; lean_object* x_45; lean_object* x_46; 
-x_10 = lean_ctor_get(x_8, 0);
-lean_inc(x_10);
-x_11 = lean_array_get_size(x_10);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_8, 1);
-lean_inc(x_12);
-lean_inc(x_2);
-x_45 = l_Lean_Parser_tokenFn(x_2, x_8);
-x_46 = lean_ctor_get(x_45, 3);
+lean_object* x_44; lean_object* x_45; 
+x_44 = lean_ctor_get(x_42, 0);
+lean_inc(x_44);
+x_45 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_44);
+lean_dec(x_44);
+if (lean_obj_tag(x_45) == 2)
+{
+lean_object* x_46; lean_object* x_47; uint8_t x_48; 
+x_46 = lean_ctor_get(x_45, 1);
 lean_inc(x_46);
-if (lean_obj_tag(x_46) == 0)
-{
-lean_object* x_47; lean_object* x_48; 
-x_47 = lean_ctor_get(x_45, 0);
-lean_inc(x_47);
-x_48 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_47);
-lean_dec(x_47);
-if (lean_obj_tag(x_48) == 2)
-{
-lean_object* x_49; lean_object* x_50; uint8_t x_51; 
-x_49 = lean_ctor_get(x_48, 1);
-lean_inc(x_49);
-lean_dec(x_48);
-x_50 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__6;
-x_51 = lean_string_dec_eq(x_49, x_50);
-lean_dec(x_49);
-if (x_51 == 0)
-{
-lean_object* x_52; lean_object* x_53; 
-x_52 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-lean_inc(x_12);
-x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_12);
-x_24 = x_53;
-goto block_44;
-}
-else
-{
-x_24 = x_45;
-goto block_44;
-}
-}
-else
-{
-lean_object* x_54; lean_object* x_55; 
-lean_dec(x_48);
-x_54 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-lean_inc(x_12);
-x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_12);
-x_24 = x_55;
-goto block_44;
-}
-}
-else
-{
-lean_object* x_56; lean_object* x_57; 
+lean_dec(x_45);
+x_47 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__6;
+x_48 = lean_string_dec_eq(x_46, x_47);
 lean_dec(x_46);
-x_56 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
-lean_inc(x_12);
-x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_12);
-x_24 = x_57;
-goto block_44;
-}
-block_23:
+if (x_48 == 0)
 {
-lean_object* x_14; 
-x_14 = lean_ctor_get(x_13, 3);
-lean_inc(x_14);
-if (lean_obj_tag(x_14) == 0)
-{
-lean_dec(x_12);
-lean_dec(x_11);
-lean_dec(x_2);
-return x_13;
+lean_object* x_49; lean_object* x_50; 
+x_49 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
+lean_inc(x_9);
+x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_49, x_9);
+x_21 = x_50;
+goto block_41;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; uint8_t x_17; 
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-lean_dec(x_14);
-x_16 = lean_ctor_get(x_13, 1);
-lean_inc(x_16);
-x_17 = lean_nat_dec_eq(x_16, x_12);
-lean_dec(x_16);
-if (x_17 == 0)
-{
-lean_dec(x_15);
-lean_dec(x_12);
-lean_dec(x_11);
-lean_dec(x_2);
-return x_13;
+x_21 = x_42;
+goto block_41;
+}
 }
 else
 {
-lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+lean_object* x_51; lean_object* x_52; 
+lean_dec(x_45);
+x_51 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
+lean_inc(x_9);
+x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_51, x_9);
+x_21 = x_52;
+goto block_41;
+}
+}
+else
+{
+lean_object* x_53; lean_object* x_54; 
+lean_dec(x_43);
+x_53 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__9;
+lean_inc(x_9);
+x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_53, x_9);
+x_21 = x_54;
+goto block_41;
+}
+block_20:
+{
+lean_object* x_11; 
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-x_18 = l_Lean_Parser_ParserState_restore(x_13, x_11, x_12);
 lean_dec(x_11);
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_18);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_15, x_12);
+x_13 = lean_ctor_get(x_10, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_13, x_9);
+lean_dec(x_13);
+if (x_14 == 0)
+{
 lean_dec(x_12);
-return x_22;
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_1);
+return x_10;
 }
-}
-}
-block_44:
+else
 {
-lean_object* x_25; 
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = l_Lean_Parser_termParser___closed__2;
+x_17 = lean_unsigned_to_nat(0u);
+x_18 = l_Lean_Parser_categoryParser___elambda__1(x_16, x_17, x_1, x_15);
+x_19 = l_Lean_Parser_mergeOrElseErrors(x_18, x_12, x_9);
+lean_dec(x_9);
+return x_19;
+}
+}
+}
+block_41:
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_26 = lean_unsigned_to_nat(2u);
-x_27 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_28 = l_Lean_Parser_categoryParserOfStackFn(x_26, x_27, x_2, x_24);
+lean_object* x_22; 
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+x_23 = lean_unsigned_to_nat(2u);
+x_24 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_25 = l_Lean_Parser_categoryParserOfStack___elambda__1(x_23, x_24, x_1, x_21);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_27 = lean_ctor_get(x_25, 1);
+lean_inc(x_27);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_25);
 x_29 = lean_ctor_get(x_28, 3);
 lean_inc(x_29);
 if (lean_obj_tag(x_29) == 0)
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_30 = lean_ctor_get(x_28, 1);
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-lean_inc(x_2);
-x_31 = l_Lean_Parser_tokenFn(x_2, x_28);
-x_32 = lean_ctor_get(x_31, 3);
-lean_inc(x_32);
-if (lean_obj_tag(x_32) == 0)
-{
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_31, 0);
-lean_inc(x_33);
-x_34 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_33);
-lean_dec(x_33);
-if (lean_obj_tag(x_34) == 2)
-{
-lean_object* x_35; lean_object* x_36; uint8_t x_37; 
-x_35 = lean_ctor_get(x_34, 1);
-lean_inc(x_35);
-lean_dec(x_34);
-x_36 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_37 = lean_string_dec_eq(x_35, x_36);
-lean_dec(x_35);
-if (x_37 == 0)
-{
-lean_object* x_38; lean_object* x_39; 
-x_38 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_30);
-x_13 = x_39;
-goto block_23;
-}
-else
-{
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_13 = x_31;
-goto block_23;
-}
-}
-else
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_40; lean_object* x_41; 
-lean_dec(x_34);
-x_40 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_30);
-x_13 = x_41;
-goto block_23;
-}
-}
-else
-{
-lean_object* x_42; lean_object* x_43; 
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_34 = lean_string_dec_eq(x_32, x_33);
 lean_dec(x_32);
-x_42 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_30);
-x_13 = x_43;
-goto block_23;
+if (x_34 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_27);
+x_10 = x_36;
+goto block_20;
+}
+else
+{
+lean_dec(x_27);
+x_10 = x_28;
+goto block_20;
 }
 }
 else
 {
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_27);
+x_10 = x_38;
+goto block_20;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
 lean_dec(x_29);
-x_13 = x_28;
-goto block_23;
+x_39 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_27);
+x_10 = x_40;
+goto block_20;
 }
 }
 else
 {
-lean_dec(x_25);
-x_13 = x_24;
-goto block_23;
+lean_dec(x_26);
+x_10 = x_25;
+goto block_20;
+}
+}
+else
+{
+lean_dec(x_22);
+x_10 = x_21;
+goto block_20;
 }
 }
 }
 else
 {
-lean_dec(x_9);
-lean_dec(x_2);
-return x_8;
-}
-}
-else
-{
-lean_dec(x_7);
-lean_dec(x_2);
-return x_6;
-}
-}
-block_85:
-{
-lean_object* x_63; 
-x_63 = lean_ctor_get(x_62, 3);
-lean_inc(x_63);
-if (lean_obj_tag(x_63) == 0)
-{
-lean_object* x_64; lean_object* x_65; 
-lean_inc(x_2);
-x_64 = lean_apply_3(x_5, x_1, x_2, x_62);
-x_65 = lean_ctor_get(x_64, 3);
-lean_inc(x_65);
-if (lean_obj_tag(x_65) == 0)
-{
-lean_dec(x_61);
-lean_dec(x_60);
-x_6 = x_64;
-goto block_58;
-}
-else
-{
-uint8_t x_66; 
-x_66 = !lean_is_exclusive(x_64);
-if (x_66 == 0)
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
-x_67 = lean_ctor_get(x_64, 0);
-x_68 = lean_ctor_get(x_64, 3);
-lean_dec(x_68);
-x_69 = lean_ctor_get(x_64, 1);
-lean_dec(x_69);
-x_70 = l_Array_shrink___main___rarg(x_67, x_61);
-lean_dec(x_61);
-lean_ctor_set(x_64, 1, x_60);
-lean_ctor_set(x_64, 0, x_70);
-x_6 = x_64;
-goto block_58;
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; 
-x_71 = lean_ctor_get(x_64, 0);
-x_72 = lean_ctor_get(x_64, 2);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_dec(x_64);
-x_73 = l_Array_shrink___main___rarg(x_71, x_61);
-lean_dec(x_61);
-x_74 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_74, 0, x_73);
-lean_ctor_set(x_74, 1, x_60);
-lean_ctor_set(x_74, 2, x_72);
-lean_ctor_set(x_74, 3, x_65);
-x_6 = x_74;
-goto block_58;
-}
-}
-}
-else
-{
-lean_object* x_75; 
-lean_dec(x_63);
-lean_dec(x_5);
+lean_dec(x_6);
 lean_dec(x_1);
-x_75 = lean_ctor_get(x_62, 3);
-lean_inc(x_75);
-if (lean_obj_tag(x_75) == 0)
+return x_5;
+}
+}
+else
 {
+lean_dec(x_4);
+lean_dec(x_1);
+return x_3;
+}
+}
+block_82:
+{
+lean_object* x_60; 
+x_60 = lean_ctor_get(x_59, 3);
+lean_inc(x_60);
+if (lean_obj_tag(x_60) == 0)
+{
+lean_object* x_61; lean_object* x_62; 
+lean_inc(x_1);
+x_61 = l_Lean_Parser_ident___elambda__1(x_1, x_59);
+x_62 = lean_ctor_get(x_61, 3);
+lean_inc(x_62);
+if (lean_obj_tag(x_62) == 0)
+{
+lean_dec(x_58);
+lean_dec(x_57);
+x_3 = x_61;
+goto block_55;
+}
+else
+{
+uint8_t x_63; 
+x_63 = !lean_is_exclusive(x_61);
+if (x_63 == 0)
+{
+lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_64 = lean_ctor_get(x_61, 0);
+x_65 = lean_ctor_get(x_61, 3);
+lean_dec(x_65);
+x_66 = lean_ctor_get(x_61, 1);
+lean_dec(x_66);
+x_67 = l_Array_shrink___main___rarg(x_64, x_58);
+lean_dec(x_58);
+lean_ctor_set(x_61, 1, x_57);
+lean_ctor_set(x_61, 0, x_67);
+x_3 = x_61;
+goto block_55;
+}
+else
+{
+lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+x_68 = lean_ctor_get(x_61, 0);
+x_69 = lean_ctor_get(x_61, 2);
+lean_inc(x_69);
+lean_inc(x_68);
 lean_dec(x_61);
+x_70 = l_Array_shrink___main___rarg(x_68, x_58);
+lean_dec(x_58);
+x_71 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_71, 0, x_70);
+lean_ctor_set(x_71, 1, x_57);
+lean_ctor_set(x_71, 2, x_69);
+lean_ctor_set(x_71, 3, x_62);
+x_3 = x_71;
+goto block_55;
+}
+}
+}
+else
+{
+lean_object* x_72; 
 lean_dec(x_60);
-x_6 = x_62;
-goto block_58;
+x_72 = lean_ctor_get(x_59, 3);
+lean_inc(x_72);
+if (lean_obj_tag(x_72) == 0)
+{
+lean_dec(x_58);
+lean_dec(x_57);
+x_3 = x_59;
+goto block_55;
 }
 else
 {
-uint8_t x_76; 
-x_76 = !lean_is_exclusive(x_62);
-if (x_76 == 0)
+uint8_t x_73; 
+x_73 = !lean_is_exclusive(x_59);
+if (x_73 == 0)
 {
-lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; 
-x_77 = lean_ctor_get(x_62, 0);
-x_78 = lean_ctor_get(x_62, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_62, 1);
-lean_dec(x_79);
-x_80 = l_Array_shrink___main___rarg(x_77, x_61);
-lean_dec(x_61);
-lean_ctor_set(x_62, 1, x_60);
-lean_ctor_set(x_62, 0, x_80);
-x_6 = x_62;
-goto block_58;
+lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; 
+x_74 = lean_ctor_get(x_59, 0);
+x_75 = lean_ctor_get(x_59, 3);
+lean_dec(x_75);
+x_76 = lean_ctor_get(x_59, 1);
+lean_dec(x_76);
+x_77 = l_Array_shrink___main___rarg(x_74, x_58);
+lean_dec(x_58);
+lean_ctor_set(x_59, 1, x_57);
+lean_ctor_set(x_59, 0, x_77);
+x_3 = x_59;
+goto block_55;
 }
 else
 {
-lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_62, 0);
-x_82 = lean_ctor_get(x_62, 2);
-lean_inc(x_82);
-lean_inc(x_81);
-lean_dec(x_62);
-x_83 = l_Array_shrink___main___rarg(x_81, x_61);
-lean_dec(x_61);
-x_84 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_84, 0, x_83);
-lean_ctor_set(x_84, 1, x_60);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_75);
-x_6 = x_84;
-goto block_58;
+lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
+x_78 = lean_ctor_get(x_59, 0);
+x_79 = lean_ctor_get(x_59, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_59);
+x_80 = l_Array_shrink___main___rarg(x_78, x_58);
+lean_dec(x_58);
+x_81 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_81, 0, x_80);
+lean_ctor_set(x_81, 1, x_57);
+lean_ctor_set(x_81, 2, x_79);
+lean_ctor_set(x_81, 3, x_72);
+x_3 = x_81;
+goto block_55;
 }
 }
 }
@@ -12392,12 +12026,11 @@ goto block_58;
 lean_object* _init_l_Lean_Parser_Command_macroTailDefault___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = lean_unsigned_to_nat(2u);
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_Lean_Parser_categoryParserOfStack(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_unsigned_to_nat(2u);
+x_2 = lean_unsigned_to_nat(0u);
+x_3 = l_Lean_Parser_categoryParserOfStack(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_macroTailDefault___closed__2() {
@@ -12407,7 +12040,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4;
 x_1 = l_Lean_Parser_Command_macroTailDefault___closed__1;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
@@ -12426,7 +12059,7 @@ lean_object* _init_l_Lean_Parser_Command_macroTailDefault___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Command_macroTailDefault___closed__3;
@@ -12460,7 +12093,7 @@ lean_object* _init_l_Lean_Parser_Command_macroTailDefault___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroTailDefault___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroTailDefault___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -12484,103 +12117,99 @@ x_1 = l_Lean_Parser_Command_macroTailDefault___closed__8;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Command_macroTail___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macroTail___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Command_macroTailTactic___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
 lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-lean_inc(x_2);
-x_7 = l_Lean_Parser_Command_macroTailTactic___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_7;
-}
-else
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_7, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_10, x_6);
-lean_dec(x_10);
-if (x_11 == 0)
-{
+x_10 = lean_nat_dec_eq(x_9, x_5);
 lean_dec(x_9);
-lean_dec(x_6);
+if (x_10 == 0)
+{
+lean_dec(x_8);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_6);
-x_12 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
-lean_dec(x_5);
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-x_14 = lean_array_get_size(x_13);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = lean_ctor_get(x_11, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+lean_inc(x_1);
+x_14 = l_Lean_Parser_Command_macroTailCommand___elambda__1(x_1, x_11);
+x_15 = lean_ctor_get(x_14, 3);
+lean_inc(x_15);
+if (lean_obj_tag(x_15) == 0)
+{
+lean_object* x_16; 
 lean_dec(x_13);
-lean_inc(x_2);
-x_15 = l_Lean_Parser_Command_macroTailCommand___elambda__1(x_1, x_2, x_12);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; 
-lean_dec(x_14);
-lean_dec(x_2);
 lean_dec(x_1);
-x_17 = l_Lean_Parser_mergeOrElseErrors(x_15, x_9, x_6);
-lean_dec(x_6);
-return x_17;
+x_16 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_5);
+lean_dec(x_5);
+return x_16;
 }
 else
 {
-lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_18 = lean_ctor_get(x_16, 0);
+lean_object* x_17; lean_object* x_18; uint8_t x_19; 
+x_17 = lean_ctor_get(x_15, 0);
+lean_inc(x_17);
+lean_dec(x_15);
+x_18 = lean_ctor_get(x_14, 1);
 lean_inc(x_18);
-lean_dec(x_16);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_20 = lean_nat_dec_eq(x_19, x_6);
-lean_dec(x_19);
-if (x_20 == 0)
-{
-lean_object* x_21; 
+x_19 = lean_nat_dec_eq(x_18, x_5);
 lean_dec(x_18);
-lean_dec(x_14);
-lean_dec(x_2);
+if (x_19 == 0)
+{
+lean_object* x_20; 
+lean_dec(x_17);
+lean_dec(x_13);
 lean_dec(x_1);
-x_21 = l_Lean_Parser_mergeOrElseErrors(x_15, x_9, x_6);
-lean_dec(x_6);
-return x_21;
+x_20 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_5);
+lean_dec(x_5);
+return x_20;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-lean_inc(x_6);
-x_22 = l_Lean_Parser_ParserState_restore(x_15, x_14, x_6);
-lean_dec(x_14);
-x_23 = l_Lean_Parser_Command_macroTailDefault___elambda__1(x_1, x_2, x_22);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_18, x_6);
-x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_9, x_6);
-lean_dec(x_6);
-return x_25;
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_inc(x_5);
+x_21 = l_Lean_Parser_ParserState_restore(x_14, x_13, x_5);
+lean_dec(x_13);
+x_22 = l_Lean_Parser_Command_macroTailDefault___elambda__1(x_1, x_21);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_17, x_5);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_8, x_5);
+lean_dec(x_5);
+return x_24;
 }
 }
 }
@@ -12617,7 +12246,7 @@ lean_object* _init_l_Lean_Parser_Command_macroTail___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroTail___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macroTail___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -12641,67 +12270,64 @@ x_1 = l_Lean_Parser_Command_macroTail___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_macro___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_macro___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-lean_inc(x_2);
-x_8 = l_Lean_Parser_Command_macroArg___elambda__1(x_2, x_3, x_4);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Command_macroArg___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_10; uint8_t x_11; 
-lean_dec(x_6);
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_7, x_10);
-lean_dec(x_10);
-lean_dec(x_7);
-if (x_11 == 0)
+lean_object* x_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
+lean_dec(x_5);
+if (x_9 == 0)
 {
-x_4 = x_8;
+x_2 = x_6;
 goto _start;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_13 = l_Lean_Parser_manyAux___main___closed__1;
-x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
-return x_14;
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_15; uint8_t x_16; 
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_15 = lean_ctor_get(x_8, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_7, x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+lean_object* x_13; uint8_t x_14; 
 lean_dec(x_7);
-lean_dec(x_6);
-return x_8;
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_17;
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+return x_15;
 }
 }
 }
@@ -12737,13 +12363,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Command_macro___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Command_macro___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Command_macro___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Command_macro___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Command_macro___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Command_macro___elambda__1___closed__5() {
@@ -12795,192 +12420,183 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Command_macro___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Command_macro___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Command_macro___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Command_macro___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_42; lean_object* x_43; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_42 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_43 = lean_ctor_get(x_42, 3);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_40; lean_object* x_41; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_40 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_41 = lean_ctor_get(x_40, 3);
+lean_inc(x_41);
+if (lean_obj_tag(x_41) == 0)
 {
-lean_object* x_44; lean_object* x_45; 
-x_44 = lean_ctor_get(x_42, 0);
+lean_object* x_42; lean_object* x_43; 
+x_42 = lean_ctor_get(x_40, 0);
+lean_inc(x_42);
+x_43 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_42);
+lean_dec(x_42);
+if (lean_obj_tag(x_43) == 2)
+{
+lean_object* x_44; lean_object* x_45; uint8_t x_46; 
+x_44 = lean_ctor_get(x_43, 1);
 lean_inc(x_44);
-x_45 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_44);
+lean_dec(x_43);
+x_45 = l_Lean_Parser_Command_macro___elambda__1___closed__6;
+x_46 = lean_string_dec_eq(x_44, x_45);
 lean_dec(x_44);
-if (lean_obj_tag(x_45) == 2)
+if (x_46 == 0)
 {
-lean_object* x_46; lean_object* x_47; uint8_t x_48; 
-x_46 = lean_ctor_get(x_45, 1);
-lean_inc(x_46);
-lean_dec(x_45);
-x_47 = l_Lean_Parser_Command_macro___elambda__1___closed__6;
-x_48 = lean_string_dec_eq(x_46, x_47);
-lean_dec(x_46);
-if (x_48 == 0)
+lean_object* x_47; lean_object* x_48; 
+x_47 = l_Lean_Parser_Command_macro___elambda__1___closed__9;
+lean_inc(x_7);
+x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_47, x_7);
+x_16 = x_48;
+goto block_39;
+}
+else
+{
+x_16 = x_40;
+goto block_39;
+}
+}
+else
 {
 lean_object* x_49; lean_object* x_50; 
+lean_dec(x_43);
 x_49 = l_Lean_Parser_Command_macro___elambda__1___closed__9;
-lean_inc(x_8);
-x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_49, x_8);
-x_17 = x_50;
-goto block_41;
-}
-else
-{
-x_17 = x_42;
-goto block_41;
+lean_inc(x_7);
+x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_49, x_7);
+x_16 = x_50;
+goto block_39;
 }
 }
 else
 {
 lean_object* x_51; lean_object* x_52; 
-lean_dec(x_45);
+lean_dec(x_41);
 x_51 = l_Lean_Parser_Command_macro___elambda__1___closed__9;
-lean_inc(x_8);
-x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_51, x_8);
-x_17 = x_52;
-goto block_41;
+lean_inc(x_7);
+x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_51, x_7);
+x_16 = x_52;
+goto block_39;
 }
-}
-else
+block_39:
 {
-lean_object* x_53; lean_object* x_54; 
-lean_dec(x_43);
-x_53 = l_Lean_Parser_Command_macro___elambda__1___closed__9;
-lean_inc(x_8);
-x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_53, x_8);
-x_17 = x_54;
-goto block_41;
-}
-block_41:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_18; lean_object* x_19; 
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Command_macroHead___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
+x_18 = l_Lean_Parser_Command_macroHead___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_20 = lean_ctor_get(x_18, 0);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = 0;
-lean_inc(x_2);
-lean_inc(x_1);
-x_24 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_macro___elambda__1___spec__1(x_23, x_1, x_2, x_19);
-x_25 = l_Lean_nullKind;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_22);
-x_27 = lean_ctor_get(x_26, 3);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_28 = l_Lean_Parser_Command_macroTail___elambda__1(x_1, x_2, x_26);
-x_29 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-lean_dec(x_27);
-lean_dec(x_2);
-lean_dec(x_1);
-x_32 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_26, x_32, x_16);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_8);
-lean_dec(x_8);
-return x_34;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_21 = lean_array_get_size(x_20);
 lean_dec(x_20);
-lean_dec(x_2);
+lean_inc(x_1);
+x_22 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_macro___elambda__1___spec__1(x_1, x_18);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_21);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_26 = l_Lean_Parser_Command_macroTail___elambda__1(x_1, x_24);
+x_27 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
+}
+else
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+lean_dec(x_25);
 lean_dec(x_1);
-x_35 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_19, x_35, x_16);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_11, x_8);
-lean_dec(x_8);
-return x_37;
+x_30 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_24, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
 }
 }
 else
 {
-lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_38 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_17, x_38, x_16);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_11, x_8);
-lean_dec(x_8);
-return x_40;
+x_33 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_18, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_36 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_16, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
 }
 }
 }
@@ -13068,7 +12684,7 @@ lean_object* _init_l_Lean_Parser_Command_macro___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macro___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_macro___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -13092,23 +12708,13 @@ x_1 = l_Lean_Parser_Command_macro___closed__9;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_macro___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_macro___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-return x_6;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Command_macro(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
-x_4 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
+x_3 = l_Lean_Parser_Command_macro___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Command_macro;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -13525,10 +13131,10 @@ lean_mark_persistent(l_Lean_Parser_Syntax_sepBy1);
 res = l___regBuiltinParser_Lean_Parser_Syntax_sepBy1(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__1);
-l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_Syntax_optional___elambda__1___rarg___closed__2);
+l_Lean_Parser_Syntax_optional___elambda__1___closed__1 = _init_l_Lean_Parser_Syntax_optional___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Syntax_optional___elambda__1___closed__1);
+l_Lean_Parser_Syntax_optional___elambda__1___closed__2 = _init_l_Lean_Parser_Syntax_optional___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_Syntax_optional___elambda__1___closed__2);
 l_Lean_Parser_Syntax_optional___closed__1 = _init_l_Lean_Parser_Syntax_optional___closed__1();
 lean_mark_persistent(l_Lean_Parser_Syntax_optional___closed__1);
 l_Lean_Parser_Syntax_optional___closed__2 = _init_l_Lean_Parser_Syntax_optional___closed__2();
@@ -13542,16 +13148,16 @@ lean_mark_persistent(l_Lean_Parser_Syntax_optional);
 res = l___regBuiltinParser_Lean_Parser_Syntax_optional(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__1);
-l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__2);
-l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__3 = _init_l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__3();
-lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__3);
-l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__4 = _init_l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__4();
-lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__4);
-l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__5 = _init_l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__5();
-lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___rarg___closed__5);
+l_Lean_Parser_Syntax_many___elambda__1___closed__1 = _init_l_Lean_Parser_Syntax_many___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___closed__1);
+l_Lean_Parser_Syntax_many___elambda__1___closed__2 = _init_l_Lean_Parser_Syntax_many___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___closed__2);
+l_Lean_Parser_Syntax_many___elambda__1___closed__3 = _init_l_Lean_Parser_Syntax_many___elambda__1___closed__3();
+lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___closed__3);
+l_Lean_Parser_Syntax_many___elambda__1___closed__4 = _init_l_Lean_Parser_Syntax_many___elambda__1___closed__4();
+lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___closed__4);
+l_Lean_Parser_Syntax_many___elambda__1___closed__5 = _init_l_Lean_Parser_Syntax_many___elambda__1___closed__5();
+lean_mark_persistent(l_Lean_Parser_Syntax_many___elambda__1___closed__5);
 l_Lean_Parser_Syntax_many___closed__1 = _init_l_Lean_Parser_Syntax_many___closed__1();
 lean_mark_persistent(l_Lean_Parser_Syntax_many___closed__1);
 l_Lean_Parser_Syntax_many___closed__2 = _init_l_Lean_Parser_Syntax_many___closed__2();
@@ -13563,10 +13169,10 @@ lean_mark_persistent(l_Lean_Parser_Syntax_many);
 res = l___regBuiltinParser_Lean_Parser_Syntax_many(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__1);
-l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_Syntax_many1___elambda__1___rarg___closed__2);
+l_Lean_Parser_Syntax_many1___elambda__1___closed__1 = _init_l_Lean_Parser_Syntax_many1___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Syntax_many1___elambda__1___closed__1);
+l_Lean_Parser_Syntax_many1___elambda__1___closed__2 = _init_l_Lean_Parser_Syntax_many1___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_Syntax_many1___elambda__1___closed__2);
 l_Lean_Parser_Syntax_many1___closed__1 = _init_l_Lean_Parser_Syntax_many1___closed__1();
 lean_mark_persistent(l_Lean_Parser_Syntax_many1___closed__1);
 l_Lean_Parser_Syntax_many1___closed__2 = _init_l_Lean_Parser_Syntax_many1___closed__2();
@@ -13580,8 +13186,8 @@ lean_mark_persistent(l_Lean_Parser_Syntax_many1);
 res = l___regBuiltinParser_Lean_Parser_Syntax_many1(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Syntax_orelse___elambda__1___rarg___closed__1);
+l_Lean_Parser_Syntax_orelse___elambda__1___closed__1 = _init_l_Lean_Parser_Syntax_orelse___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Syntax_orelse___elambda__1___closed__1);
 l_Lean_Parser_Syntax_orelse___closed__1 = _init_l_Lean_Parser_Syntax_orelse___closed__1();
 lean_mark_persistent(l_Lean_Parser_Syntax_orelse___closed__1);
 l_Lean_Parser_Syntax_orelse___closed__2 = _init_l_Lean_Parser_Syntax_orelse___closed__2();
@@ -13615,8 +13221,6 @@ l_Lean_Parser_Command_quotedSymbolPrec___closed__4 = _init_l_Lean_Parser_Command
 lean_mark_persistent(l_Lean_Parser_Command_quotedSymbolPrec___closed__4);
 l_Lean_Parser_Command_quotedSymbolPrec___closed__5 = _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__5();
 lean_mark_persistent(l_Lean_Parser_Command_quotedSymbolPrec___closed__5);
-l_Lean_Parser_Command_quotedSymbolPrec___closed__6 = _init_l_Lean_Parser_Command_quotedSymbolPrec___closed__6();
-lean_mark_persistent(l_Lean_Parser_Command_quotedSymbolPrec___closed__6);
 l_Lean_Parser_Command_quotedSymbolPrec = _init_l_Lean_Parser_Command_quotedSymbolPrec();
 lean_mark_persistent(l_Lean_Parser_Command_quotedSymbolPrec);
 l_Lean_Parser_Command_prefix___elambda__1___closed__1 = _init_l_Lean_Parser_Command_prefix___elambda__1___closed__1();
@@ -13816,8 +13420,6 @@ l_Lean_Parser_Command_mixfixSymbol___closed__2 = _init_l_Lean_Parser_Command_mix
 lean_mark_persistent(l_Lean_Parser_Command_mixfixSymbol___closed__2);
 l_Lean_Parser_Command_mixfixSymbol___closed__3 = _init_l_Lean_Parser_Command_mixfixSymbol___closed__3();
 lean_mark_persistent(l_Lean_Parser_Command_mixfixSymbol___closed__3);
-l_Lean_Parser_Command_mixfixSymbol___closed__4 = _init_l_Lean_Parser_Command_mixfixSymbol___closed__4();
-lean_mark_persistent(l_Lean_Parser_Command_mixfixSymbol___closed__4);
 l_Lean_Parser_Command_mixfixSymbol = _init_l_Lean_Parser_Command_mixfixSymbol();
 lean_mark_persistent(l_Lean_Parser_Command_mixfixSymbol);
 l_Lean_Parser_Command_mixfix___elambda__1___closed__1 = _init_l_Lean_Parser_Command_mixfix___elambda__1___closed__1();
diff --git a/stage0/stdlib/Init/Lean/Parser/Tactic.c b/stage0/stdlib/Init/Lean/Parser/Tactic.c
index d439dd236b..d141196b02 100644
--- a/stage0/stdlib/Init/Lean/Parser/Tactic.c
+++ b/stage0/stdlib/Init/Lean/Parser/Tactic.c
@@ -18,7 +18,7 @@ lean_object* l_Lean_Parser_Tactic_intros___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Tactic_apply___elambda__1___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_intro(lean_object*);
 extern lean_object* l_Lean_mkHole___closed__3;
-lean_object* l_Lean_Parser_Tactic_refine___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_refine___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_traceState___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Tactic_exact___closed__6;
 lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1___closed__2;
@@ -35,9 +35,8 @@ lean_object* l_Lean_Parser_andthenInfo(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Term_have___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Tactic_apply___closed__2;
 lean_object* l_Lean_Parser_regBuiltinTacticParserAttr___closed__1;
-lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
-lean_object* l_Lean_Parser_Tactic_underscoreFn___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_intros___elambda__1___closed__5;
 extern lean_object* l_Lean_nullKind;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__2;
@@ -45,16 +44,14 @@ lean_object* l_Lean_Parser_Tactic_intros___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Tactic_orelse___closed__1;
 lean_object* l_Lean_Parser_Tactic_nonEmptySeq___closed__2;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__5;
+lean_object* l_Lean_Parser_Tactic_underscore___closed__2;
 lean_object* l_Lean_Parser_Tactic_seq___elambda__1___closed__2;
 extern lean_object* l_Lean_Parser_Term_have___elambda__1___closed__10;
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__3;
 lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_seq;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 lean_object* l_Lean_Parser_Tactic_skip___closed__3;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5;
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_traceState___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Tactic_intro___closed__4;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__3;
@@ -62,39 +59,40 @@ lean_object* l_Lean_Parser_regTacticParserAttribute___closed__2;
 lean_object* l_Lean_Parser_Term_tacticBlock___closed__3;
 lean_object* l_Lean_Parser_Tactic_intro___elambda__1___closed__7;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_nestedTacticBlock(lean_object*);
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
 extern lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Tactic_assumption___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__4;
 extern lean_object* l_Lean_Parser_Term_have___closed__3;
 lean_object* l_Lean_Parser_ParserState_pushSyntax(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly;
+extern lean_object* l_Lean_Parser_ident;
+lean_object* l_Lean_Parser_Tactic_underscore___closed__1;
 extern lean_object* l_Lean_Parser_Term_subtype___closed__1;
 lean_object* l_Lean_Parser_Tactic_skip___closed__2;
 lean_object* l_Lean_Parser_ParserState_mkNode(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_apply___closed__4;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_tacticStxQuot___closed__3;
-lean_object* l_Lean_Parser_Tactic_underscore___boxed(lean_object*);
 lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Tactic_exact___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___closed__7;
 lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1___closed__1;
 lean_object* l_Lean_Parser_regTacticParserAttribute___closed__1;
-lean_object* l_Lean_Parser_Tactic_underscore(uint8_t);
+lean_object* l_Lean_Parser_Tactic_underscore;
 lean_object* l_Lean_Parser_Tactic_traceState___elambda__1___closed__4;
 lean_object* l_Lean_mkIdentFrom(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_traceState___elambda__1___closed__1;
 lean_object* l_Lean_Parser_registerBuiltinDynamicParserAttribute(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_regBuiltinTacticParserAttr(lean_object*);
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Tactic_paren___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_paren___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkTrailingNode(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Tactic_underscoreFn___rarg___closed__4;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Tactic_refine___closed__5;
-lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_exact___closed__1;
-lean_object* l_Lean_Parser_addBuiltinParser(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_addBuiltinParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Tactic_intro___elambda__1___closed__3;
@@ -102,9 +100,10 @@ lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_tokenFn(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_nestedTacticBlockCurly(lean_object*);
 lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_Tactic_intros___closed__5;
 lean_object* l_Lean_Parser_Tactic_assumption___elambda__1___closed__2;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_orelse___closed__3;
 lean_object* l_Lean_Parser_Tactic_nonEmptySeq;
 lean_object* l_Lean_Parser_Tactic_skip___closed__1;
@@ -114,24 +113,25 @@ extern lean_object* l_Lean_mkAppStx___closed__4;
 lean_object* l_Lean_Parser_ParserState_mkErrorsAt(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_orelse___closed__5;
 lean_object* l_Lean_Parser_Tactic_refine___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Tactic_ident_x27___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_ident_x27___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_refine___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Tactic_intros___closed__3;
 lean_object* l_Lean_Parser_Tactic_apply___closed__5;
 lean_object* l_Lean_Parser_Tactic_case___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Tactic_assumption___closed__4;
 lean_object* l_Lean_Parser_Tactic_intros___closed__6;
-lean_object* l_Lean_Parser_tacticParser(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_tacticParser(lean_object*);
 lean_object* l_Lean_Parser_Tactic_case___closed__4;
 lean_object* l_Lean_Parser_regBuiltinTacticParserAttr___closed__2;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__13;
 lean_object* l_Lean_Parser_Tactic_refine___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
 lean_object* l_Lean_Parser_Tactic_intro___elambda__1___closed__1;
+lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_tacticStxQuot;
 lean_object* l_Lean_Parser_Term_tacticStxQuot___closed__6;
 lean_object* l_Lean_Parser_Tactic_assumption;
-lean_object* l_Lean_Parser_Tactic_intros___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_intros___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_traceState___closed__5;
 extern lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Tactic_refine___elambda__1___closed__3;
@@ -139,7 +139,7 @@ extern lean_object* l_Lean_Parser_identNoAntiquot___closed__1;
 lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Tactic_assumption___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Tactic_skip___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Tactic_case___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_case___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_case;
 lean_object* l_Lean_Parser_Tactic_traceState___closed__1;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
@@ -167,7 +167,6 @@ lean_object* l_Lean_Parser_noFirstTokenInfo(lean_object*);
 lean_object* l_Lean_Parser_Tactic_skip___elambda__1___closed__7;
 lean_object* l_Lean_Parser_nonReservedSymbolInfo(lean_object*, uint8_t);
 lean_object* l_Lean_Parser_Tactic_ident_x27___closed__1;
-lean_object* l_Lean_Parser_Tactic_underscoreFn___rarg___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_intros(lean_object*);
 lean_object* l_Lean_Parser_Tactic_traceState___closed__2;
 lean_object* l_Lean_Parser_Tactic_ident_x27___closed__3;
@@ -175,7 +174,6 @@ lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__12;
 lean_object* l_Lean_Parser_Tactic_seq___elambda__1___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot(lean_object*);
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__6;
-lean_object* l_Lean_Parser_Tactic_nonEmptySeq___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_intro___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Tactic_intros___closed__2;
 lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1___closed__7;
@@ -187,11 +185,12 @@ lean_object* l___regBuiltinParser_Lean_Parser_Tactic_apply(lean_object*);
 lean_object* l_Lean_Parser_Tactic_apply___closed__6;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Tactic_intros___closed__1;
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1(lean_object*);
+lean_object* l_Lean_Parser_Tactic_orelse___elambda__1(lean_object*, lean_object*);
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
 extern lean_object* l_Char_HasRepr___closed__1;
 lean_object* l_Lean_Parser_Tactic_apply___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Tactic_intro___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_intro___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__1;
 lean_object* l_Lean_Parser_Tactic_exact___elambda__1___closed__1;
 lean_object* l_Lean_Parser_orelseInfo(lean_object*, lean_object*);
@@ -204,14 +203,12 @@ lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___closed__6;
 lean_object* l_Lean_Parser_Tactic_apply___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Tactic_exact___closed__3;
 lean_object* l_Lean_Parser_Tactic_paren___closed__5;
-extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__11;
 lean_object* l_Lean_Parser_Tactic_skip___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Tactic_assumption___closed__2;
 lean_object* l_Lean_Parser_Tactic_exact___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Tactic_ident_x27;
 lean_object* l_Lean_Parser_Tactic_exact___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Tactic_exact___closed__5;
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Parser_Tactic_skip___elambda__1___closed__2;
 extern lean_object* l_Lean_mkAppStx___closed__6;
 lean_object* l_Lean_Parser_Tactic_paren___closed__3;
@@ -228,18 +225,16 @@ lean_object* l_Lean_Parser_Tactic_refine___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Tactic_refine___closed__6;
 lean_object* l_Lean_Parser_Term_tacticBlock___closed__2;
-lean_object* l_Lean_Parser_Tactic_skip___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_skip___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_allGoals___closed__2;
 lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Tactic_exact___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__4;
+lean_object* l_Lean_Parser_Tactic_exact___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_apply;
 lean_object* l_Lean_Parser_Tactic_assumption___closed__5;
 lean_object* l_Lean_Parser_ParserState_restore(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_paren___closed__1;
 lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__7;
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__4;
 lean_object* l_Lean_Parser_Tactic_paren___closed__2;
 lean_object* l_Lean_Parser_ParserState_popSyntax(lean_object*);
 lean_object* l_Lean_Parser_Tactic_paren___elambda__1___closed__2;
@@ -248,23 +243,22 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot___closed__1;
 extern lean_object* l_Lean_Parser_Term_seq___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Tactic_intros___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Tactic_case___closed__5;
+lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Tactic_orelse;
 lean_object* l_Lean_Parser_Tactic_allGoals___closed__6;
 lean_object* l_Lean_Parser_Tactic_case___elambda__1___closed__2;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Tactic_intros___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_categoryParserFn(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Tactic_intros___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_intros___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot___closed__2;
 lean_object* l_Lean_Parser_sepBy1Info(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__2;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Tactic_apply___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Tactic_skip___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Tactic_underscoreFn(uint8_t, lean_object*);
+lean_object* l_Lean_Parser_ident___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_underscoreFn(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_case___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Tactic_refine___closed__1;
 lean_object* l_Lean_Parser_Tactic_paren___closed__4;
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___closed__2;
 lean_object* l_Lean_Parser_Tactic_refine___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_exact(lean_object*);
@@ -272,27 +266,27 @@ lean_object* l_Lean_Parser_Tactic_assumption___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Tactic_case___closed__3;
 lean_object* l_Lean_Parser_Tactic_skip___elambda__1___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_allGoals(lean_object*);
-lean_object* l_Lean_Parser_Tactic_underscoreFn___rarg___closed__3;
 lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 lean_object* l_Lean_Parser_Tactic_refine___closed__4;
-lean_object* l_Lean_Parser_categoryParser(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParser(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_exact;
 lean_object* l_Lean_Parser_Tactic_intro___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_case___closed__1;
 lean_object* l_Lean_Parser_regTacticParserAttribute(lean_object*);
 lean_object* l_Lean_Parser_Tactic_allGoals___closed__5;
 lean_object* l_Lean_Parser_Tactic_paren___closed__6;
 lean_object* l_Lean_Parser_Tactic_skip___elambda__1___closed__4;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
 lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Tactic_underscoreFn___rarg___closed__2;
 lean_object* l_Lean_Parser_Tactic_apply___elambda__1___closed__6;
+lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__4;
 lean_object* l_Lean_Parser_Tactic_assumption___closed__3;
 lean_object* l_Lean_Parser_Tactic_case___elambda__1___closed__7;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 extern lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_tacticBlock___closed__4;
 lean_object* l_Lean_Parser_Term_tacticBlock___closed__1;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___closed__8;
@@ -304,25 +298,24 @@ lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__3;
 lean_object* l_Lean_Parser_Tactic_traceState___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Tactic_intro___closed__6;
 lean_object* l_Lean_Parser_Tactic_traceState___elambda__1___closed__3;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_intros;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__5;
 lean_object* l_Lean_Parser_Tactic_case___closed__7;
-extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
-lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_exact___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_paren(lean_object*);
 lean_object* l_Lean_Parser_Tactic_exact___elambda__1___closed__2;
 lean_object* l_String_trim(lean_object*);
-lean_object* l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__8;
+lean_object* l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_apply___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_assumption(lean_object*);
-extern lean_object* l_Lean_Parser_Term_typeAscription___closed__2;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__6;
+lean_object* l_Lean_Parser_Tactic_underscoreFn___closed__2;
 lean_object* l_Lean_Parser_Tactic_seq___closed__2;
-lean_object* l_Lean_Parser_Tactic_apply___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_apply___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_paren___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Tactic_apply___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Tactic_seq___closed__1;
@@ -330,11 +323,11 @@ lean_object* l_Lean_Parser_Term_tacticBlock___closed__6;
 lean_object* l_Lean_Parser_Tactic_exact___closed__2;
 lean_object* l_Lean_Parser_Tactic_intro___closed__2;
 lean_object* l_Lean_Parser_regBuiltinTacticParserAttr___closed__3;
-lean_object* l_Lean_Parser_Tactic_underscoreFn___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_mkAntiquot(uint8_t, lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_Parser_mkAntiquot(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___closed__5;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Tactic_intros___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_underscoreFn___closed__1;
 lean_object* l_Lean_Parser_Tactic_assumption___elambda__1___closed__7;
+lean_object* l_Lean_Parser_Tactic_underscoreFn___closed__3;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___closed__3;
 lean_object* l_Lean_Parser_Tactic_allGoals___closed__4;
 lean_object* l_Lean_Parser_Tactic_intro___closed__1;
@@ -351,39 +344,39 @@ lean_object* l_Lean_Parser_Tactic_intros___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Tactic_refine___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Tactic_seq___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Tactic_seq___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___closed__3;
 lean_object* l_Lean_Parser_ParserState_mkUnexpectedError(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_skip;
 lean_object* l_Lean_Parser_Tactic_intros___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Tactic_apply___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Tactic_assumption___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_assumption___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Tactic_nonEmptySeq___closed__1;
 lean_object* l_Lean_Parser_Tactic_refine___elambda__1___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_orelse(lean_object*);
 lean_object* l_Lean_Parser_Tactic_traceState___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Tactic_allGoals___closed__1;
 lean_object* l_Lean_Parser_Tactic_traceState;
-lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_traceState(lean_object*);
 lean_object* l_Lean_Parser_Term_tacticBlock___closed__5;
 lean_object* l_Lean_Parser_Tactic_paren;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Tactic_intro;
-lean_object* l_Lean_Parser_tacticParser___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_refine;
 extern lean_object* l_Lean_Parser_Term_orelse___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Tactic_seq___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_seq___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Tactic_assumption___elambda__1___closed__3;
 extern lean_object* l_Lean_ppGoal___closed__7;
 lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1___closed__8;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_refine(lean_object*);
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_Tactic_assumption___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Tactic_skip___closed__4;
+lean_object* l_Lean_Parser_Tactic_underscoreFn___closed__4;
 lean_object* l_Lean_Parser_Tactic_case___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Tactic_seq___closed__4;
-lean_object* l_Lean_Parser_Tactic_traceState___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Tactic_traceState___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Level_paren___closed__1;
 lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1___closed__4;
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
@@ -462,26 +455,16 @@ x_4 = l_Lean_Parser_registerBuiltinDynamicParserAttribute(x_2, x_3, x_1);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_tacticParser(uint8_t x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_tacticParser(lean_object* x_1) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; 
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_3, x_2);
-return x_4;
+lean_object* x_2; lean_object* x_3; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_categoryParser(x_2, x_1);
+return x_3;
 }
 }
-lean_object* l_Lean_Parser_tacticParser___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_tacticParser(x_3, x_2);
-return x_4;
-}
-}
-lean_object* _init_l_Lean_Parser_Tactic_underscoreFn___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Tactic_underscoreFn___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -491,29 +474,29 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Tactic_underscoreFn___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_Tactic_underscoreFn___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Tactic_underscoreFn___rarg___closed__1;
+x_1 = l_Lean_Parser_Tactic_underscoreFn___closed__1;
 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_Tactic_underscoreFn___rarg___closed__3() {
+lean_object* _init_l_Lean_Parser_Tactic_underscoreFn___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Tactic_underscoreFn___rarg___closed__2;
+x_2 = l_Lean_Parser_Tactic_underscoreFn___closed__2;
 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_Tactic_underscoreFn___rarg___closed__4() {
+lean_object* _init_l_Lean_Parser_Tactic_underscoreFn___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -523,7 +506,7 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_underscoreFn___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Tactic_underscoreFn(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
@@ -537,7 +520,7 @@ if (lean_obj_tag(x_5) == 0)
 lean_object* x_14; lean_object* x_15; 
 x_14 = lean_ctor_get(x_4, 0);
 lean_inc(x_14);
-x_15 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_14);
+x_15 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_14);
 lean_dec(x_14);
 if (lean_obj_tag(x_15) == 2)
 {
@@ -551,7 +534,7 @@ lean_dec(x_16);
 if (x_18 == 0)
 {
 lean_object* x_19; lean_object* x_20; 
-x_19 = l_Lean_Parser_Tactic_underscoreFn___rarg___closed__3;
+x_19 = l_Lean_Parser_Tactic_underscoreFn___closed__3;
 x_20 = l_Lean_Parser_ParserState_mkErrorsAt(x_4, x_19, x_3);
 x_6 = x_20;
 goto block_13;
@@ -567,7 +550,7 @@ else
 {
 lean_object* x_21; lean_object* x_22; 
 lean_dec(x_15);
-x_21 = l_Lean_Parser_Tactic_underscoreFn___rarg___closed__3;
+x_21 = l_Lean_Parser_Tactic_underscoreFn___closed__3;
 x_22 = l_Lean_Parser_ParserState_mkErrorsAt(x_4, x_21, x_3);
 x_6 = x_22;
 goto block_13;
@@ -577,7 +560,7 @@ else
 {
 lean_object* x_23; lean_object* x_24; 
 lean_dec(x_5);
-x_23 = l_Lean_Parser_Tactic_underscoreFn___rarg___closed__3;
+x_23 = l_Lean_Parser_Tactic_underscoreFn___closed__3;
 x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_4, x_23, x_3);
 x_6 = x_24;
 goto block_13;
@@ -587,10 +570,10 @@ block_13:
 lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 x_7 = lean_ctor_get(x_6, 0);
 lean_inc(x_7);
-x_8 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_7);
+x_8 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_7);
 lean_dec(x_7);
 x_9 = l_Lean_Parser_ParserState_popSyntax(x_6);
-x_10 = l_Lean_Parser_Tactic_underscoreFn___rarg___closed__4;
+x_10 = l_Lean_Parser_Tactic_underscoreFn___closed__4;
 x_11 = l_Lean_mkIdentFrom(x_8, x_10);
 lean_dec(x_8);
 x_12 = l_Lean_Parser_ParserState_pushSyntax(x_9, x_11);
@@ -598,101 +581,83 @@ return x_12;
 }
 }
 }
-lean_object* l_Lean_Parser_Tactic_underscoreFn(uint8_t x_1, lean_object* x_2) {
+lean_object* _init_l_Lean_Parser_Tactic_underscore___closed__1() {
 _start:
 {
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_underscoreFn___rarg), 2, 0);
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_underscoreFn), 2, 0);
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Parser_Tactic_underscore___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_identNoAntiquot___closed__1;
+x_2 = l_Lean_Parser_Tactic_underscore___closed__1;
+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* l_Lean_Parser_Tactic_underscoreFn___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* _init_l_Lean_Parser_Tactic_underscore() {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_Parser_Tactic_underscoreFn(x_3, x_2);
-lean_dec(x_2);
-return x_4;
+lean_object* x_1; 
+x_1 = l_Lean_Parser_Tactic_underscore___closed__2;
+return x_1;
 }
 }
-lean_object* l_Lean_Parser_Tactic_underscore(uint8_t x_1) {
+lean_object* l_Lean_Parser_Tactic_ident_x27___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_underscoreFn___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_2);
-x_4 = l_Lean_Parser_identNoAntiquot___closed__1;
-x_5 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_Parser_Tactic_underscore___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_Parser_Tactic_underscore(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_Parser_Tactic_ident_x27___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_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
+lean_inc(x_1);
+x_6 = l_Lean_Parser_ident___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
 }
 else
 {
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
-lean_dec(x_11);
-lean_dec(x_8);
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
+lean_inc(x_8);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+x_10 = lean_nat_dec_eq(x_9, x_5);
+lean_dec(x_9);
+if (x_10 == 0)
+{
+lean_dec(x_8);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = l_Lean_Parser_Tactic_underscoreFn___rarg(x_2, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = l_Lean_Parser_Tactic_underscoreFn(x_1, x_11);
+x_13 = l_Lean_Parser_mergeOrElseErrors(x_12, x_8, x_5);
+lean_dec(x_5);
+return x_13;
 }
 }
 }
@@ -701,7 +666,7 @@ lean_object* _init_l_Lean_Parser_Tactic_ident_x27___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_identNoAntiquot___closed__1;
@@ -713,7 +678,7 @@ lean_object* _init_l_Lean_Parser_Tactic_ident_x27___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_ident_x27___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_ident_x27___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -737,215 +702,215 @@ x_1 = l_Lean_Parser_Tactic_ident_x27___closed__3;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-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; 
-x_9 = lean_ctor_get(x_8, 0);
+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; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
+x_10 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_11 = lean_unsigned_to_nat(0u);
+lean_inc(x_5);
+x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_5, x_6);
+x_13 = lean_ctor_get(x_12, 3);
+lean_inc(x_13);
+if (lean_obj_tag(x_13) == 0)
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_31; lean_object* x_32; 
 lean_dec(x_9);
-x_11 = lean_ctor_get(x_8, 1);
-lean_inc(x_11);
-x_12 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_13 = lean_unsigned_to_nat(0u);
-lean_inc(x_7);
-x_14 = l_Lean_Parser_categoryParserFn(x_12, x_13, x_7, x_8);
-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_33; lean_object* x_34; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_16 = lean_ctor_get(x_14, 0);
+lean_dec(x_8);
+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 = lean_ctor_get(x_12, 1);
 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_inc(x_18);
-lean_inc(x_7);
-x_33 = l_Lean_Parser_tokenFn(x_7, x_14);
-x_34 = lean_ctor_get(x_33, 3);
-lean_inc(x_34);
-if (lean_obj_tag(x_34) == 0)
+lean_inc(x_5);
+x_31 = l_Lean_Parser_tokenFn(x_5, x_12);
+x_32 = lean_ctor_get(x_31, 3);
+lean_inc(x_32);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_35; lean_object* x_36; 
-x_35 = lean_ctor_get(x_33, 0);
+lean_object* x_33; lean_object* x_34; 
+x_33 = lean_ctor_get(x_31, 0);
+lean_inc(x_33);
+x_34 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_33);
+lean_dec(x_33);
+if (lean_obj_tag(x_34) == 2)
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = lean_ctor_get(x_34, 1);
 lean_inc(x_35);
-x_36 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_35);
+lean_dec(x_34);
+x_36 = l_Lean_Parser_Term_have___elambda__1___closed__7;
+x_37 = lean_string_dec_eq(x_35, x_36);
 lean_dec(x_35);
-if (lean_obj_tag(x_36) == 2)
+if (x_37 == 0)
 {
-lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_37 = lean_ctor_get(x_36, 1);
-lean_inc(x_37);
-lean_dec(x_36);
-x_38 = l_Lean_Parser_Term_have___elambda__1___closed__7;
-x_39 = lean_string_dec_eq(x_37, x_38);
-lean_dec(x_37);
-if (x_39 == 0)
-{
-lean_object* x_40; lean_object* x_41; 
-x_40 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-lean_inc(x_18);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_18);
-x_19 = x_41;
-goto block_32;
+lean_object* x_38; lean_object* x_39; 
+x_38 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+lean_inc(x_16);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_16);
+x_17 = x_39;
+goto block_30;
 }
 else
 {
-x_19 = x_33;
-goto block_32;
+x_17 = x_31;
+goto block_30;
+}
+}
+else
+{
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_34);
+x_40 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+lean_inc(x_16);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_16);
+x_17 = x_41;
+goto block_30;
 }
 }
 else
 {
 lean_object* x_42; lean_object* x_43; 
-lean_dec(x_36);
+lean_dec(x_32);
 x_42 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+lean_inc(x_16);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_16);
+x_17 = x_43;
+goto block_30;
+}
+block_30:
+{
+lean_object* x_18; 
+x_18 = lean_ctor_get(x_17, 3);
 lean_inc(x_18);
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_42, x_18);
-x_19 = x_43;
-goto block_32;
-}
-}
-else
+if (lean_obj_tag(x_18) == 0)
 {
-lean_object* x_44; lean_object* x_45; 
-lean_dec(x_34);
-x_44 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-lean_inc(x_18);
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_44, x_18);
-x_19 = x_45;
-goto block_32;
-}
-block_32:
+lean_dec(x_16);
+lean_dec(x_15);
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_dec(x_18);
-lean_dec(x_17);
-{
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_19;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_17;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
-lean_dec(x_20);
-lean_dec(x_7);
-x_22 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
-lean_dec(x_17);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+lean_dec(x_18);
+lean_dec(x_5);
+x_20 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
+lean_dec(x_15);
+x_21 = lean_ctor_get(x_20, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_nat_sub(x_22, x_2);
+lean_dec(x_22);
+x_24 = lean_unsigned_to_nat(1u);
+x_25 = lean_nat_dec_eq(x_23, x_24);
 lean_dec(x_23);
-x_25 = lean_nat_sub(x_24, x_3);
-lean_dec(x_24);
-x_26 = lean_unsigned_to_nat(1u);
-x_27 = lean_nat_dec_eq(x_25, x_26);
-lean_dec(x_25);
-if (x_27 == 0)
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; 
+x_26 = l_Lean_nullKind;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_2);
+return x_27;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_28; lean_object* x_29; 
 x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_3);
+x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_2);
 return x_29;
 }
 else
 {
+lean_dec(x_2);
+return x_20;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_13);
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Lean_nullKind;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_3);
-return x_31;
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_44 = lean_box(0);
+x_45 = l_Lean_Parser_ParserState_pushSyntax(x_12, x_44);
+x_46 = l_Lean_nullKind;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_2);
+return x_47;
 }
 else
 {
-lean_dec(x_3);
-return x_22;
-}
-}
-}
-}
-}
-else
-{
-lean_dec(x_15);
-lean_dec(x_7);
-if (x_5 == 0)
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_46 = lean_box(0);
-x_47 = l_Lean_Parser_ParserState_pushSyntax(x_14, x_46);
-x_48 = l_Lean_nullKind;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_3);
-return x_49;
-}
-else
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_50 = l_Lean_Parser_ParserState_restore(x_14, x_10, x_11);
-lean_dec(x_10);
-x_51 = lean_ctor_get(x_50, 0);
-lean_inc(x_51);
-x_52 = lean_array_get_size(x_51);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
+x_48 = l_Lean_Parser_ParserState_restore(x_12, x_8, x_9);
+lean_dec(x_8);
+x_49 = lean_ctor_get(x_48, 0);
+lean_inc(x_49);
+x_50 = lean_array_get_size(x_49);
+lean_dec(x_49);
+x_51 = lean_nat_sub(x_50, x_2);
+lean_dec(x_50);
+x_52 = lean_unsigned_to_nat(2u);
+x_53 = lean_nat_dec_eq(x_51, x_52);
 lean_dec(x_51);
-x_53 = lean_nat_sub(x_52, x_3);
-lean_dec(x_52);
-x_54 = lean_unsigned_to_nat(2u);
-x_55 = lean_nat_dec_eq(x_53, x_54);
-lean_dec(x_53);
-if (x_55 == 0)
+if (x_53 == 0)
+{
+lean_object* x_54; lean_object* x_55; 
+x_54 = l_Lean_nullKind;
+x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_2);
+return x_55;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_56; lean_object* x_57; 
 x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_50, x_56, x_3);
+x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_2);
 return x_57;
 }
 else
 {
-if (x_4 == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-x_58 = l_Lean_nullKind;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_50, x_58, x_3);
-return x_59;
-}
-else
-{
-lean_object* x_60; 
-lean_dec(x_3);
-x_60 = l_Lean_Parser_ParserState_popSyntax(x_50);
-return x_60;
+lean_object* x_58; 
+lean_dec(x_2);
+x_58 = l_Lean_Parser_ParserState_popSyntax(x_48);
+return x_58;
 }
 }
 }
 }
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = 0;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2(x_1, x_2, x_8, x_3, x_9, x_4, x_5, x_6);
-return x_10;
+lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = 0;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2(x_1, x_6, x_2, x_7, x_3, x_4);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_seq___elambda__1___closed__1() {
@@ -976,32 +941,30 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_seq___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_seq___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; uint8_t x_6; uint8_t x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
-lean_dec(x_4);
+lean_object* x_3; lean_object* x_4; uint8_t x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+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_5 = 1;
 x_6 = 0;
-x_7 = 1;
-x_8 = 0;
-x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_6, x_7, x_8, x_1, x_2, x_3);
-x_10 = l_Lean_Parser_Tactic_seq___elambda__1___closed__3;
-x_11 = l_Lean_Parser_ParserState_mkNode(x_9, x_10, x_5);
-return x_11;
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_5, x_6, x_1, x_2);
+x_8 = l_Lean_Parser_Tactic_seq___elambda__1___closed__3;
+x_9 = l_Lean_Parser_ParserState_mkNode(x_7, x_8, x_4);
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_seq___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_2 = lean_unsigned_to_nat(0u);
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_seq___closed__2() {
@@ -1030,7 +993,7 @@ lean_object* _init_l_Lean_Parser_Tactic_seq___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_seq___elambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_seq___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1054,69 +1017,53 @@ x_1 = l_Lean_Parser_Tactic_seq___closed__5;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
-lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-lean_dec(x_6);
-return x_13;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
 x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_8 = lean_unbox(x_2);
-lean_dec(x_2);
-x_9 = lean_unbox(x_3);
+x_8 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_7, x_8, x_9, x_4, x_5, x_6);
+x_9 = lean_unbox(x_4);
 lean_dec(x_4);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
 return x_10;
 }
 }
-lean_object* l_Lean_Parser_Tactic_seq___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_4; 
-x_4 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_2, x_3);
+uint8_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox(x_1);
 lean_dec(x_1);
-return x_4;
+x_6 = lean_unbox(x_2);
+lean_dec(x_2);
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_5, x_6, x_3, x_4);
+return x_7;
 }
 }
-lean_object* l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; uint8_t x_6; uint8_t x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
-lean_dec(x_4);
+lean_object* x_3; lean_object* x_4; uint8_t x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+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_5 = 1;
 x_6 = 0;
-x_7 = 1;
-x_8 = 0;
-x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_6, x_7, x_8, x_1, x_2, x_3);
-x_10 = l_Lean_Parser_Tactic_seq___elambda__1___closed__3;
-x_11 = l_Lean_Parser_ParserState_mkNode(x_9, x_10, x_5);
-return x_11;
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_5, x_6, x_1, x_2);
+x_8 = l_Lean_Parser_Tactic_seq___elambda__1___closed__3;
+x_9 = l_Lean_Parser_ParserState_mkNode(x_7, x_8, x_4);
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_nonEmptySeq___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_nonEmptySeq___elambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_nonEmptySeq___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1140,15 +1087,6 @@ x_1 = l_Lean_Parser_Tactic_nonEmptySeq___closed__2;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Tactic_nonEmptySeq___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_2, x_3);
-lean_dec(x_1);
-return x_4;
-}
-}
 lean_object* _init_l_Lean_Parser_Tactic_intro___elambda__1___closed__1() {
 _start:
 {
@@ -1180,13 +1118,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_intro___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_intro___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_intro___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_intro___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_intro___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_intro___elambda__1___closed__5() {
@@ -1226,136 +1163,132 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_intro___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_intro___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_intro___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_intro___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Tactic_intro___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Tactic_intro___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = lean_ctor_get(x_19, 3);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_intro___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Tactic_intro___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_20 = lean_ctor_get(x_18, 0);
 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_24; lean_object* x_25; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = lean_ctor_get(x_19, 1);
-lean_inc(x_23);
-x_24 = l_Lean_Parser_Tactic_ident_x27___elambda__1(x_1, x_2, x_19);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_23);
-x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_22);
-x_28 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_16);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_11, x_8);
-lean_dec(x_8);
-return x_30;
-}
-else
-{
-lean_object* x_31; uint8_t x_32; 
-lean_dec(x_25);
-x_31 = lean_ctor_get(x_24, 1);
-lean_inc(x_31);
-x_32 = lean_nat_dec_eq(x_31, x_23);
-lean_dec(x_31);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_23);
-x_33 = l_Lean_nullKind;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_24, x_33, x_22);
-x_35 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_16);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_11, x_8);
-lean_dec(x_8);
-return x_37;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_38 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
-x_39 = l_Lean_nullKind;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_22);
-x_41 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_21 = lean_array_get_size(x_20);
 lean_dec(x_20);
-lean_dec(x_2);
+x_22 = lean_ctor_get(x_18, 1);
+lean_inc(x_22);
+x_23 = l_Lean_Parser_Tactic_ident_x27___elambda__1(x_1, x_18);
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_22);
+x_25 = l_Lean_nullKind;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_23, x_25, x_21);
+x_27 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
+}
+else
+{
+lean_object* x_30; uint8_t x_31; 
+lean_dec(x_24);
+x_30 = lean_ctor_get(x_23, 1);
+lean_inc(x_30);
+x_31 = lean_nat_dec_eq(x_30, x_22);
+lean_dec(x_30);
+if (x_31 == 0)
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_22);
+x_32 = l_Lean_nullKind;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_23, x_32, x_21);
+x_34 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
+}
+else
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_37 = l_Lean_Parser_ParserState_restore(x_23, x_21, x_22);
+x_38 = l_Lean_nullKind;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_21);
+x_40 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_15);
+x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_10, x_7);
+lean_dec(x_7);
+return x_42;
+}
+}
+}
+else
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_44 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_19, x_44, x_16);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_11, x_8);
-lean_dec(x_8);
-return x_46;
+x_43 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_18, x_43, x_15);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_10, x_7);
+lean_dec(x_7);
+return x_45;
 }
 }
 }
@@ -1418,7 +1351,7 @@ lean_object* _init_l_Lean_Parser_Tactic_intro___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_intro___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_intro___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1445,76 +1378,73 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_intro(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_intro___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_intro;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Tactic_intros___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Tactic_intros___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-lean_inc(x_2);
-x_8 = l_Lean_Parser_Tactic_ident_x27___elambda__1(x_2, x_3, x_4);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Tactic_ident_x27___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_10; uint8_t x_11; 
-lean_dec(x_6);
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_7, x_10);
-lean_dec(x_10);
-lean_dec(x_7);
-if (x_11 == 0)
+lean_object* x_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
+lean_dec(x_5);
+if (x_9 == 0)
 {
-x_4 = x_8;
+x_2 = x_6;
 goto _start;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_13 = l_Lean_Parser_manyAux___main___closed__1;
-x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
-return x_14;
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_15; uint8_t x_16; 
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_15 = lean_ctor_get(x_8, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_7, x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+lean_object* x_13; uint8_t x_14; 
 lean_dec(x_7);
-lean_dec(x_6);
-return x_8;
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_17;
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+return x_15;
 }
 }
 }
@@ -1550,13 +1480,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_intros___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_intros___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_intros___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_intros___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_intros___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_intros___elambda__1___closed__5() {
@@ -1596,95 +1525,90 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_intros___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_intros___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_intros___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_intros___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Tactic_intros___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Tactic_intros___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = lean_ctor_get(x_19, 3);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_intros___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Tactic_intros___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+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; 
+x_20 = lean_ctor_get(x_18, 0);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_object* x_21; lean_object* x_22; uint8_t 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; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = 0;
-x_24 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Tactic_intros___elambda__1___spec__1(x_23, x_1, x_2, x_19);
-x_25 = l_Lean_nullKind;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_22);
-x_27 = l_Lean_Parser_Tactic_intros___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+x_21 = lean_array_get_size(x_20);
+lean_dec(x_20);
+x_22 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Tactic_intros___elambda__1___spec__1(x_1, x_18);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_21);
+x_25 = l_Lean_Parser_Tactic_intros___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
 }
 else
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_30 = l_Lean_Parser_Tactic_intros___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
+x_28 = l_Lean_Parser_Tactic_intros___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_18, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
 }
 }
 }
@@ -1747,7 +1671,7 @@ lean_object* _init_l_Lean_Parser_Tactic_intros___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_intros___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_intros___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1771,23 +1695,13 @@ x_1 = l_Lean_Parser_Tactic_intros___closed__7;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Tactic_intros___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Tactic_intros___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-return x_6;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_intros(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_intros___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_intros___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_intros;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -1824,13 +1738,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_assumption___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_assumption___elambda__1___closed__5() {
@@ -1862,66 +1775,66 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_assumption___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_assumption___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_assumption___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__5;
+x_17 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__7;
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__5;
-x_18 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__7;
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+return x_21;
 }
 }
 }
@@ -1962,7 +1875,7 @@ lean_object* _init_l_Lean_Parser_Tactic_assumption___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_assumption___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_assumption___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -1989,10 +1902,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_assumption(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_assumption___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_assumption;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2029,13 +1942,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_apply___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_apply___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_apply___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_apply___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_apply___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_apply___elambda__1___closed__5() {
@@ -2075,86 +1987,86 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_apply___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_apply___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_apply___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_apply___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Tactic_apply___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Tactic_apply___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_apply___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Tactic_apply___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_21 = l_Lean_Parser_termParser___closed__2;
-x_22 = lean_unsigned_to_nat(0u);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = l_Lean_Parser_Tactic_apply___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_20 = l_Lean_Parser_termParser___closed__2;
+x_21 = lean_unsigned_to_nat(0u);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+x_23 = l_Lean_Parser_Tactic_apply___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_27 = l_Lean_Parser_Tactic_apply___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_19, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_26 = l_Lean_Parser_Tactic_apply___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 }
@@ -2174,7 +2086,7 @@ lean_object* _init_l_Lean_Parser_Tactic_apply___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Tactic_apply___closed__1;
@@ -2208,7 +2120,7 @@ lean_object* _init_l_Lean_Parser_Tactic_apply___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_apply___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_apply___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2235,10 +2147,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_apply(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_apply___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_apply___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_apply;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2275,13 +2187,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_exact___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_exact___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_exact___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_exact___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_exact___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_exact___elambda__1___closed__5() {
@@ -2321,86 +2232,86 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_exact___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_exact___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_exact___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_exact___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Tactic_exact___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Tactic_exact___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_exact___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Tactic_exact___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_21 = l_Lean_Parser_termParser___closed__2;
-x_22 = lean_unsigned_to_nat(0u);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = l_Lean_Parser_Tactic_exact___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_20 = l_Lean_Parser_termParser___closed__2;
+x_21 = lean_unsigned_to_nat(0u);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+x_23 = l_Lean_Parser_Tactic_exact___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_27 = l_Lean_Parser_Tactic_exact___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_19, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_26 = l_Lean_Parser_Tactic_exact___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 }
@@ -2420,7 +2331,7 @@ lean_object* _init_l_Lean_Parser_Tactic_exact___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Tactic_exact___closed__1;
@@ -2454,7 +2365,7 @@ lean_object* _init_l_Lean_Parser_Tactic_exact___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_exact___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_exact___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2481,10 +2392,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_exact(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_exact___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_exact___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_exact;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2521,13 +2432,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_refine___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_refine___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_refine___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_refine___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_refine___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_refine___elambda__1___closed__5() {
@@ -2567,86 +2477,86 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_refine___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_refine___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_refine___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_refine___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Tactic_refine___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Tactic_refine___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_refine___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Tactic_refine___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_21 = l_Lean_Parser_termParser___closed__2;
-x_22 = lean_unsigned_to_nat(0u);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = l_Lean_Parser_Tactic_refine___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_20 = l_Lean_Parser_termParser___closed__2;
+x_21 = lean_unsigned_to_nat(0u);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+x_23 = l_Lean_Parser_Tactic_refine___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_27 = l_Lean_Parser_Tactic_refine___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_19, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_26 = l_Lean_Parser_Tactic_refine___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 }
@@ -2666,7 +2576,7 @@ lean_object* _init_l_Lean_Parser_Tactic_refine___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Tactic_refine___closed__1;
@@ -2700,7 +2610,7 @@ lean_object* _init_l_Lean_Parser_Tactic_refine___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_refine___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_refine___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2727,10 +2637,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_refine(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_refine___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_refine___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_refine;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -2767,13 +2677,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_case___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_case___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_case___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_case___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_case___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_case___elambda__1___closed__5() {
@@ -2805,115 +2714,105 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_case___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_case___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_case___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Tactic_case___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-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_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = l_Lean_Parser_Tactic_case___elambda__1___closed__5;
-x_20 = l_Lean_Parser_Tactic_case___elambda__1___closed__7;
-lean_inc(x_2);
-x_21 = l_Lean_Parser_nonReservedSymbolFnAux(x_19, x_20, x_2, x_16);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_23; lean_object* x_24; 
-lean_inc(x_2);
-x_23 = lean_apply_3(x_5, x_1, x_2, x_21);
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-x_25 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_26 = lean_unsigned_to_nat(0u);
-x_27 = l_Lean_Parser_categoryParserFn(x_25, x_26, x_2, x_23);
-x_28 = l_Lean_Parser_Tactic_case___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_18);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_13, x_10);
 lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_case___elambda__1___closed__5;
+x_17 = l_Lean_Parser_Tactic_case___elambda__1___closed__7;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; 
+lean_inc(x_1);
+x_20 = l_Lean_Parser_ident___elambda__1(x_1, x_18);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+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 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_23 = lean_unsigned_to_nat(0u);
+x_24 = l_Lean_Parser_categoryParser___elambda__1(x_22, x_23, x_1, x_20);
+x_25 = l_Lean_Parser_Tactic_case___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_21);
+lean_dec(x_1);
+x_28 = l_Lean_Parser_Tactic_case___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
 return x_30;
 }
+}
 else
 {
 lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-lean_dec(x_24);
-lean_dec(x_2);
-x_31 = l_Lean_Parser_Tactic_case___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_18);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_13, x_10);
-lean_dec(x_10);
-return x_33;
-}
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_22);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_19);
 lean_dec(x_1);
-x_34 = l_Lean_Parser_Tactic_case___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_21, x_34, x_18);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
-lean_dec(x_10);
-return x_36;
+x_31 = l_Lean_Parser_Tactic_case___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_18, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
 }
 }
 }
@@ -2933,7 +2832,7 @@ lean_object* _init_l_Lean_Parser_Tactic_case___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Tactic_seq___closed__1;
@@ -2979,7 +2878,7 @@ lean_object* _init_l_Lean_Parser_Tactic_case___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_case___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_case___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3006,10 +2905,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_case(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_case___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_case___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_case;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -3046,13 +2945,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_allGoals___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_allGoals___elambda__1___closed__5() {
@@ -3092,86 +2990,86 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_allGoals___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__8;
-lean_inc(x_2);
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__8;
+lean_inc(x_1);
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_21 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_22 = lean_unsigned_to_nat(0u);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_20 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_21 = lean_unsigned_to_nat(0u);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+x_23 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_27 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_19, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_26 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 }
@@ -3225,7 +3123,7 @@ lean_object* _init_l_Lean_Parser_Tactic_allGoals___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_allGoals___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_allGoals___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3252,10 +3150,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_allGoals(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_allGoals___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_allGoals;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -3292,13 +3190,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_skip___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_skip___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_skip___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_skip___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_skip___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_skip___elambda__1___closed__5() {
@@ -3330,66 +3227,66 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_skip___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_skip___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_skip___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_skip___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_skip___elambda__1___closed__5;
+x_17 = l_Lean_Parser_Tactic_skip___elambda__1___closed__7;
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = l_Lean_Parser_Tactic_skip___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Tactic_skip___elambda__1___closed__5;
-x_18 = l_Lean_Parser_Tactic_skip___elambda__1___closed__7;
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = l_Lean_Parser_Tactic_skip___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+return x_21;
 }
 }
 }
@@ -3430,7 +3327,7 @@ lean_object* _init_l_Lean_Parser_Tactic_skip___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_skip___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_skip___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3457,10 +3354,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_skip(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_skip___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_skip___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_skip;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -3497,13 +3394,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_traceState___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_traceState___elambda__1___closed__5() {
@@ -3535,66 +3431,66 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_traceState___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_traceState___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_traceState___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__5;
+x_17 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__7;
+x_18 = l_Lean_Parser_nonReservedSymbolFnAux(x_16, x_17, x_1, x_13);
+x_19 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__5;
-x_18 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__7;
-x_19 = l_Lean_Parser_nonReservedSymbolFnAux(x_17, x_18, x_2, x_14);
-x_20 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+return x_21;
 }
 }
 }
@@ -3635,7 +3531,7 @@ lean_object* _init_l_Lean_Parser_Tactic_traceState___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_traceState___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_traceState___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3662,10 +3558,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_traceState(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_traceState___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_traceState;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -3694,234 +3590,228 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_paren___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_paren___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_paren___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Tactic_paren___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_paren___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_paren___elambda__1___closed__3;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_paren___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_54; lean_object* x_55; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_54 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_55 = lean_ctor_get(x_54, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_53; lean_object* x_54; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_53 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_54 = lean_ctor_get(x_53, 3);
+lean_inc(x_54);
+if (lean_obj_tag(x_54) == 0)
+{
+lean_object* x_55; lean_object* x_56; 
+x_55 = lean_ctor_get(x_53, 0);
 lean_inc(x_55);
-if (lean_obj_tag(x_55) == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = lean_ctor_get(x_54, 0);
-lean_inc(x_56);
-x_57 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_56);
-lean_dec(x_56);
-if (lean_obj_tag(x_57) == 2)
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_58 = lean_ctor_get(x_57, 1);
-lean_inc(x_58);
-lean_dec(x_57);
-x_59 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_60 = lean_string_dec_eq(x_58, x_59);
-lean_dec(x_58);
-if (x_60 == 0)
-{
-lean_object* x_61; lean_object* x_62; 
-x_61 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_8);
-x_17 = x_62;
-goto block_53;
-}
-else
-{
-x_17 = x_54;
-goto block_53;
-}
-}
-else
-{
-lean_object* x_63; lean_object* x_64; 
-lean_dec(x_57);
-x_63 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_63, x_8);
-x_17 = x_64;
-goto block_53;
-}
-}
-else
-{
-lean_object* x_65; lean_object* x_66; 
+x_56 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_55);
 lean_dec(x_55);
-x_65 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_65, x_8);
-x_17 = x_66;
-goto block_53;
+if (lean_obj_tag(x_56) == 2)
+{
+lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+x_57 = lean_ctor_get(x_56, 1);
+lean_inc(x_57);
+lean_dec(x_56);
+x_58 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_59 = lean_string_dec_eq(x_57, x_58);
+lean_dec(x_57);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_60, x_7);
+x_16 = x_61;
+goto block_52;
 }
-block_53:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_53;
+goto block_52;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
-x_19 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_2, x_17);
-lean_dec(x_1);
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_62; lean_object* x_63; 
+lean_dec(x_56);
+x_62 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_62, x_7);
+x_16 = x_63;
+goto block_52;
+}
+}
+else
+{
+lean_object* x_64; lean_object* x_65; 
+lean_dec(x_54);
+x_64 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_64, x_7);
+x_16 = x_65;
+goto block_52;
+}
+block_52:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_21 = l_Lean_Parser_tokenFn(x_1, x_18);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_21 = lean_ctor_get(x_19, 1);
-lean_inc(x_21);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_23 = lean_ctor_get(x_22, 3);
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_21, 0);
 lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
-{
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_29 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
-x_31 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_16);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_11, x_8);
-lean_dec(x_8);
-return x_33;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_21);
-x_34 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_25);
-x_37 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
-x_39 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
-}
-}
-else
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_24 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_23);
 lean_dec(x_23);
-x_42 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
-x_44 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_16);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_11, x_8);
-lean_dec(x_8);
-return x_46;
-}
+if (lean_obj_tag(x_24) == 2)
+{
+lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_25 = lean_ctor_get(x_24, 1);
+lean_inc(x_25);
+lean_dec(x_24);
+x_26 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_27 = lean_string_dec_eq(x_25, x_26);
+lean_dec(x_25);
+if (x_27 == 0)
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_28 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20);
+x_30 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
 lean_dec(x_20);
-lean_dec(x_2);
-x_47 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_16);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_11, x_8);
-lean_dec(x_8);
-return x_49;
+x_33 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_21, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
 }
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_24);
+x_36 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_36, x_20);
+x_38 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_22);
+x_41 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_41, x_20);
+x_43 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_15);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_10, x_7);
+lean_dec(x_7);
+return x_45;
+}
+}
+else
+{
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_50 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_17, x_50, x_16);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_11, x_8);
-lean_dec(x_8);
-return x_52;
+x_46 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_18, x_46, x_15);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_7);
+lean_dec(x_7);
+return x_48;
+}
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_49 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_16, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
+return x_51;
 }
 }
 }
@@ -3935,7 +3825,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4;
 x_1 = l_Lean_Parser_Tactic_nonEmptySeq;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
@@ -3944,7 +3834,7 @@ lean_object* _init_l_Lean_Parser_Tactic_paren___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 x_2 = l_Lean_Parser_Tactic_paren___closed__1;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
@@ -3976,7 +3866,7 @@ lean_object* _init_l_Lean_Parser_Tactic_paren___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_paren___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_paren___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4003,10 +3893,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_paren(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_paren;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -4043,13 +3933,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__5() {
@@ -4150,225 +4039,220 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_nestedTacticBlock___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_54; lean_object* x_55; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_54 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_55 = lean_ctor_get(x_54, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_53; lean_object* x_54; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_53 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_54 = lean_ctor_get(x_53, 3);
+lean_inc(x_54);
+if (lean_obj_tag(x_54) == 0)
+{
+lean_object* x_55; lean_object* x_56; 
+x_55 = lean_ctor_get(x_53, 0);
 lean_inc(x_55);
-if (lean_obj_tag(x_55) == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = lean_ctor_get(x_54, 0);
-lean_inc(x_56);
-x_57 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_56);
-lean_dec(x_56);
-if (lean_obj_tag(x_57) == 2)
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_58 = lean_ctor_get(x_57, 1);
-lean_inc(x_58);
-lean_dec(x_57);
-x_59 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__6;
-x_60 = lean_string_dec_eq(x_58, x_59);
-lean_dec(x_58);
-if (x_60 == 0)
-{
-lean_object* x_61; lean_object* x_62; 
-x_61 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
-lean_inc(x_8);
-x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_8);
-x_17 = x_62;
-goto block_53;
-}
-else
-{
-x_17 = x_54;
-goto block_53;
-}
-}
-else
-{
-lean_object* x_63; lean_object* x_64; 
-lean_dec(x_57);
-x_63 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_63, x_8);
-x_17 = x_64;
-goto block_53;
-}
-}
-else
-{
-lean_object* x_65; lean_object* x_66; 
+x_56 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_55);
 lean_dec(x_55);
-x_65 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_65, x_8);
-x_17 = x_66;
-goto block_53;
+if (lean_obj_tag(x_56) == 2)
+{
+lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+x_57 = lean_ctor_get(x_56, 1);
+lean_inc(x_57);
+lean_dec(x_56);
+x_58 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__6;
+x_59 = lean_string_dec_eq(x_57, x_58);
+lean_dec(x_57);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
+lean_inc(x_7);
+x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_60, x_7);
+x_16 = x_61;
+goto block_52;
 }
-block_53:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_53;
+goto block_52;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
-x_19 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_2, x_17);
-lean_dec(x_1);
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_62; lean_object* x_63; 
+lean_dec(x_56);
+x_62 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
+lean_inc(x_7);
+x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_62, x_7);
+x_16 = x_63;
+goto block_52;
+}
+}
+else
+{
+lean_object* x_64; lean_object* x_65; 
+lean_dec(x_54);
+x_64 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
+lean_inc(x_7);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_64, x_7);
+x_16 = x_65;
+goto block_52;
+}
+block_52:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_21 = l_Lean_Parser_tokenFn(x_1, x_18);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_21 = lean_ctor_get(x_19, 1);
-lean_inc(x_21);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_23 = lean_ctor_get(x_22, 3);
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_21, 0);
 lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
-{
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__8;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_29 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
-x_31 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_16);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_11, x_8);
-lean_dec(x_8);
-return x_33;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_21);
-x_34 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_25);
-x_37 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
-x_39 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
-}
-}
-else
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_24 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_23);
 lean_dec(x_23);
-x_42 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
-x_44 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_16);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_11, x_8);
-lean_dec(x_8);
-return x_46;
-}
+if (lean_obj_tag(x_24) == 2)
+{
+lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_25 = lean_ctor_get(x_24, 1);
+lean_inc(x_25);
+lean_dec(x_24);
+x_26 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__8;
+x_27 = lean_string_dec_eq(x_25, x_26);
+lean_dec(x_25);
+if (x_27 == 0)
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_28 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
+x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20);
+x_30 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
 lean_dec(x_20);
-lean_dec(x_2);
-x_47 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_16);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_11, x_8);
-lean_dec(x_8);
-return x_49;
+x_33 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_21, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
 }
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_24);
+x_36 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_36, x_20);
+x_38 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_22);
+x_41 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
+x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_41, x_20);
+x_43 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_15);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_10, x_7);
+lean_dec(x_7);
+return x_45;
+}
+}
+else
+{
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_50 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_17, x_50, x_16);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_11, x_8);
-lean_dec(x_8);
-return x_52;
+x_46 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_18, x_46, x_15);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_7);
+lean_dec(x_7);
+return x_48;
+}
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_49 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_16, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
+return x_51;
 }
 }
 }
@@ -4443,7 +4327,7 @@ lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4470,10 +4354,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_nestedTacticBlock(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_nestedTacticBlock;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -4510,234 +4394,228 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Tactic_nestedTacticBlockCurly___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_54; lean_object* x_55; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_54 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_55 = lean_ctor_get(x_54, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_53; lean_object* x_54; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_53 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_54 = lean_ctor_get(x_53, 3);
+lean_inc(x_54);
+if (lean_obj_tag(x_54) == 0)
+{
+lean_object* x_55; lean_object* x_56; 
+x_55 = lean_ctor_get(x_53, 0);
 lean_inc(x_55);
-if (lean_obj_tag(x_55) == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = lean_ctor_get(x_54, 0);
-lean_inc(x_56);
-x_57 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_56);
-lean_dec(x_56);
-if (lean_obj_tag(x_57) == 2)
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_58 = lean_ctor_get(x_57, 1);
-lean_inc(x_58);
-lean_dec(x_57);
-x_59 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
-x_60 = lean_string_dec_eq(x_58, x_59);
-lean_dec(x_58);
-if (x_60 == 0)
-{
-lean_object* x_61; lean_object* x_62; 
-x_61 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_8);
-x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_8);
-x_17 = x_62;
-goto block_53;
-}
-else
-{
-x_17 = x_54;
-goto block_53;
-}
-}
-else
-{
-lean_object* x_63; lean_object* x_64; 
-lean_dec(x_57);
-x_63 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_63, x_8);
-x_17 = x_64;
-goto block_53;
-}
-}
-else
-{
-lean_object* x_65; lean_object* x_66; 
+x_56 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_55);
 lean_dec(x_55);
-x_65 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_65, x_8);
-x_17 = x_66;
-goto block_53;
+if (lean_obj_tag(x_56) == 2)
+{
+lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+x_57 = lean_ctor_get(x_56, 1);
+lean_inc(x_57);
+lean_dec(x_56);
+x_58 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
+x_59 = lean_string_dec_eq(x_57, x_58);
+lean_dec(x_57);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_60, x_7);
+x_16 = x_61;
+goto block_52;
 }
-block_53:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_53;
+goto block_52;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
-x_19 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_2, x_17);
-lean_dec(x_1);
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_62; lean_object* x_63; 
+lean_dec(x_56);
+x_62 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_62, x_7);
+x_16 = x_63;
+goto block_52;
+}
+}
+else
+{
+lean_object* x_64; lean_object* x_65; 
+lean_dec(x_54);
+x_64 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_64, x_7);
+x_16 = x_65;
+goto block_52;
+}
+block_52:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_21 = l_Lean_Parser_tokenFn(x_1, x_18);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_21 = lean_ctor_get(x_19, 1);
-lean_inc(x_21);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_23 = lean_ctor_get(x_22, 3);
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_21, 0);
 lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
-{
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_29 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
-x_31 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_16);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_11, x_8);
-lean_dec(x_8);
-return x_33;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_21);
-x_34 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_25);
-x_37 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
-x_39 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
-}
-}
-else
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_24 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_23);
 lean_dec(x_23);
-x_42 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
-x_44 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_16);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_11, x_8);
-lean_dec(x_8);
-return x_46;
-}
+if (lean_obj_tag(x_24) == 2)
+{
+lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_25 = lean_ctor_get(x_24, 1);
+lean_inc(x_25);
+lean_dec(x_24);
+x_26 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
+x_27 = lean_string_dec_eq(x_25, x_26);
+lean_dec(x_25);
+if (x_27 == 0)
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_28 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20);
+x_30 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
 lean_dec(x_20);
-lean_dec(x_2);
-x_47 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_16);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_11, x_8);
-lean_dec(x_8);
-return x_49;
+x_33 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_21, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
 }
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_24);
+x_36 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_36, x_20);
+x_38 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_22);
+x_41 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_41, x_20);
+x_43 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_15);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_10, x_7);
+lean_dec(x_7);
+return x_45;
+}
+}
+else
+{
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_50 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_17, x_50, x_16);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_11, x_8);
-lean_dec(x_8);
-return x_52;
+x_46 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_18, x_46, x_15);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_7);
+lean_dec(x_7);
+return x_48;
+}
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_49 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_16, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
+return x_51;
 }
 }
 }
@@ -4792,7 +4670,7 @@ lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4819,16 +4697,16 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_nestedTacticBlockCurly(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Tactic_nestedTacticBlockCurly;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* _init_l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -4838,7 +4716,7 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -4847,39 +4725,39 @@ x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__3() {
+lean_object* _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__3() {
 _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_Tactic_orelse___elambda__1___rarg___closed__2;
+x_2 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__2;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__4() {
+lean_object* _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__3;
+x_1 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__3;
 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_Tactic_orelse___elambda__1___rarg___closed__5() {
+lean_object* _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__4;
+x_2 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__4;
 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* l_Lean_Parser_Tactic_orelse___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Tactic_orelse___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
@@ -4898,7 +4776,7 @@ if (lean_obj_tag(x_17) == 0)
 lean_object* x_18; lean_object* x_19; 
 x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-x_19 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_18);
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
 if (lean_obj_tag(x_19) == 2)
 {
@@ -4906,13 +4784,13 @@ lean_object* x_20; lean_object* x_21; uint8_t x_22;
 x_20 = lean_ctor_get(x_19, 1);
 lean_inc(x_20);
 lean_dec(x_19);
-x_21 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__2;
+x_21 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__2;
 x_22 = lean_string_dec_eq(x_20, x_21);
 lean_dec(x_20);
 if (x_22 == 0)
 {
 lean_object* x_23; lean_object* x_24; 
-x_23 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5;
+x_23 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5;
 x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_15);
 x_5 = x_24;
 goto block_14;
@@ -4928,7 +4806,7 @@ else
 {
 lean_object* x_25; lean_object* x_26; 
 lean_dec(x_19);
-x_25 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5;
+x_25 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5;
 x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_25, x_15);
 x_5 = x_26;
 goto block_14;
@@ -4938,7 +4816,7 @@ else
 {
 lean_object* x_27; lean_object* x_28; 
 lean_dec(x_17);
-x_27 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5;
+x_27 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5;
 x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_27, x_15);
 x_5 = x_28;
 goto block_14;
@@ -4953,8 +4831,8 @@ if (lean_obj_tag(x_6) == 0)
 lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_7 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
 x_8 = lean_unsigned_to_nat(1u);
-x_9 = l_Lean_Parser_categoryParserFn(x_7, x_8, x_1, x_5);
-x_10 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1;
+x_9 = l_Lean_Parser_categoryParser___elambda__1(x_7, x_8, x_1, x_5);
+x_10 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__1;
 x_11 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_10, x_4);
 lean_dec(x_4);
 return x_11;
@@ -4964,7 +4842,7 @@ else
 lean_object* x_12; lean_object* x_13; 
 lean_dec(x_6);
 lean_dec(x_1);
-x_12 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1;
+x_12 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__1;
 x_13 = l_Lean_Parser_ParserState_mkTrailingNode(x_5, x_12, x_4);
 lean_dec(x_4);
 return x_13;
@@ -4972,20 +4850,12 @@ return x_13;
 }
 }
 }
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_orelse___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__2;
+x_2 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__2;
 x_3 = l_Lean_Parser_symbolInfo(x_2, x_1);
 return x_3;
 }
@@ -4993,12 +4863,11 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 1;
-x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_3 = lean_unsigned_to_nat(1u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_2 = lean_unsigned_to_nat(1u);
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__3() {
@@ -5017,7 +4886,7 @@ lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1;
+x_1 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__1;
 x_2 = l_Lean_Parser_Tactic_orelse___closed__3;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
@@ -5027,7 +4896,7 @@ lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_orelse___elambda__1___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_orelse___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5051,22 +4920,13 @@ x_1 = l_Lean_Parser_Tactic_orelse___closed__6;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Tactic_orelse___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Tactic_orelse___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Tactic_orelse(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
-x_4 = l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4;
+x_3 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__1;
+x_4 = 0;
 x_5 = l_Lean_Parser_Tactic_orelse;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -5103,234 +4963,228 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_tacticBlock___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_tacticBlock___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_54; lean_object* x_55; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_54 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_55 = lean_ctor_get(x_54, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_53; lean_object* x_54; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_53 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_54 = lean_ctor_get(x_53, 3);
+lean_inc(x_54);
+if (lean_obj_tag(x_54) == 0)
+{
+lean_object* x_55; lean_object* x_56; 
+x_55 = lean_ctor_get(x_53, 0);
 lean_inc(x_55);
-if (lean_obj_tag(x_55) == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = lean_ctor_get(x_54, 0);
-lean_inc(x_56);
-x_57 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_56);
-lean_dec(x_56);
-if (lean_obj_tag(x_57) == 2)
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_58 = lean_ctor_get(x_57, 1);
-lean_inc(x_58);
-lean_dec(x_57);
-x_59 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__6;
-x_60 = lean_string_dec_eq(x_58, x_59);
-lean_dec(x_58);
-if (x_60 == 0)
-{
-lean_object* x_61; lean_object* x_62; 
-x_61 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
-lean_inc(x_8);
-x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_8);
-x_17 = x_62;
-goto block_53;
-}
-else
-{
-x_17 = x_54;
-goto block_53;
-}
-}
-else
-{
-lean_object* x_63; lean_object* x_64; 
-lean_dec(x_57);
-x_63 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_63, x_8);
-x_17 = x_64;
-goto block_53;
-}
-}
-else
-{
-lean_object* x_65; lean_object* x_66; 
+x_56 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_55);
 lean_dec(x_55);
-x_65 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_65, x_8);
-x_17 = x_66;
-goto block_53;
+if (lean_obj_tag(x_56) == 2)
+{
+lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+x_57 = lean_ctor_get(x_56, 1);
+lean_inc(x_57);
+lean_dec(x_56);
+x_58 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__6;
+x_59 = lean_string_dec_eq(x_57, x_58);
+lean_dec(x_57);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
+lean_inc(x_7);
+x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_60, x_7);
+x_16 = x_61;
+goto block_52;
 }
-block_53:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_53;
+goto block_52;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
-x_19 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_2, x_17);
-lean_dec(x_1);
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_62; lean_object* x_63; 
+lean_dec(x_56);
+x_62 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
+lean_inc(x_7);
+x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_62, x_7);
+x_16 = x_63;
+goto block_52;
+}
+}
+else
+{
+lean_object* x_64; lean_object* x_65; 
+lean_dec(x_54);
+x_64 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__14;
+lean_inc(x_7);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_64, x_7);
+x_16 = x_65;
+goto block_52;
+}
+block_52:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_21 = l_Lean_Parser_tokenFn(x_1, x_18);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_21 = lean_ctor_get(x_19, 1);
-lean_inc(x_21);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_23 = lean_ctor_get(x_22, 3);
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_21, 0);
 lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
-{
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__8;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_29 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
-x_31 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_16);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_11, x_8);
-lean_dec(x_8);
-return x_33;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_21);
-x_34 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_25);
-x_37 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
-x_39 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
-}
-}
-else
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_24 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_23);
 lean_dec(x_23);
-x_42 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
-x_44 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_16);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_11, x_8);
-lean_dec(x_8);
-return x_46;
-}
+if (lean_obj_tag(x_24) == 2)
+{
+lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_25 = lean_ctor_get(x_24, 1);
+lean_inc(x_25);
+lean_dec(x_24);
+x_26 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__8;
+x_27 = lean_string_dec_eq(x_25, x_26);
+lean_dec(x_25);
+if (x_27 == 0)
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_28 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
+x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20);
+x_30 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
 lean_dec(x_20);
-lean_dec(x_2);
-x_47 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_16);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_11, x_8);
-lean_dec(x_8);
-return x_49;
+x_33 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_21, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
 }
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_24);
+x_36 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_36, x_20);
+x_38 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
+}
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_22);
+x_41 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__11;
+x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_41, x_20);
+x_43 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_15);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_10, x_7);
+lean_dec(x_7);
+return x_45;
+}
+}
+else
+{
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_50 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_17, x_50, x_16);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_11, x_8);
-lean_dec(x_8);
-return x_52;
+x_46 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_18, x_46, x_15);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_7);
+lean_dec(x_7);
+return x_48;
+}
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_49 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_16, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
+return x_51;
 }
 }
 }
@@ -5383,7 +5237,7 @@ lean_object* _init_l_Lean_Parser_Term_tacticBlock___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tacticBlock___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tacticBlock___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5410,10 +5264,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_tacticBlock(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_tacticBlock;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -5486,168 +5340,167 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
-lean_dec(x_4);
-x_39 = lean_ctor_get(x_3, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+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_37 = lean_ctor_get(x_2, 1);
+lean_inc(x_37);
+lean_inc(x_1);
+x_38 = l_Lean_Parser_tokenFn(x_1, x_2);
+x_39 = lean_ctor_get(x_38, 3);
 lean_inc(x_39);
-lean_inc(x_2);
-x_40 = l_Lean_Parser_tokenFn(x_2, x_3);
-x_41 = lean_ctor_get(x_40, 3);
-lean_inc(x_41);
-if (lean_obj_tag(x_41) == 0)
+if (lean_obj_tag(x_39) == 0)
 {
-lean_object* x_42; lean_object* x_43; 
-x_42 = lean_ctor_get(x_40, 0);
+lean_object* x_40; lean_object* x_41; 
+x_40 = lean_ctor_get(x_38, 0);
+lean_inc(x_40);
+x_41 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_40);
+lean_dec(x_40);
+if (lean_obj_tag(x_41) == 2)
+{
+lean_object* x_42; lean_object* x_43; uint8_t x_44; 
+x_42 = lean_ctor_get(x_41, 1);
 lean_inc(x_42);
-x_43 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_42);
+lean_dec(x_41);
+x_43 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__4;
+x_44 = lean_string_dec_eq(x_42, x_43);
 lean_dec(x_42);
-if (lean_obj_tag(x_43) == 2)
+if (x_44 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; 
-x_44 = lean_ctor_get(x_43, 1);
-lean_inc(x_44);
-lean_dec(x_43);
-x_45 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__4;
-x_46 = lean_string_dec_eq(x_44, x_45);
-lean_dec(x_44);
-if (x_46 == 0)
-{
-lean_object* x_47; lean_object* x_48; 
-x_47 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__7;
-x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_47, x_39);
-x_6 = x_48;
-goto block_38;
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__7;
+x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_38, x_45, x_37);
+x_5 = x_46;
+goto block_36;
 }
 else
 {
-lean_dec(x_39);
-x_6 = x_40;
-goto block_38;
+lean_dec(x_37);
+x_5 = x_38;
+goto block_36;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; 
+lean_dec(x_41);
+x_47 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__7;
+x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_38, x_47, x_37);
+x_5 = x_48;
+goto block_36;
 }
 }
 else
 {
 lean_object* x_49; lean_object* x_50; 
-lean_dec(x_43);
+lean_dec(x_39);
 x_49 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__7;
-x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_49, x_39);
-x_6 = x_50;
-goto block_38;
+x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_38, x_49, x_37);
+x_5 = x_50;
+goto block_36;
 }
+block_36:
+{
+lean_object* x_6; 
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
+{
+uint8_t x_7; lean_object* x_8; lean_object* x_9; 
+x_7 = 1;
+lean_inc(x_1);
+x_8 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_7, 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; 
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+x_11 = l_Lean_Parser_tokenFn(x_1, x_8);
+x_12 = lean_ctor_get(x_11, 3);
+lean_inc(x_12);
+if (lean_obj_tag(x_12) == 0)
+{
+lean_object* x_13; lean_object* x_14; 
+x_13 = lean_ctor_get(x_11, 0);
+lean_inc(x_13);
+x_14 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_13);
+lean_dec(x_13);
+if (lean_obj_tag(x_14) == 2)
+{
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+lean_dec(x_14);
+x_16 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_17 = lean_string_dec_eq(x_15, x_16);
+lean_dec(x_15);
+if (x_17 == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_18, x_10);
+x_20 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
+x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_4);
+return x_21;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; 
-lean_dec(x_41);
-x_51 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__7;
-x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_51, x_39);
-x_6 = x_52;
-goto block_38;
-}
-block_38:
-{
-lean_object* x_7; 
-x_7 = lean_ctor_get(x_6, 3);
-lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
-{
-uint8_t x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = 0;
-x_9 = 1;
-lean_inc(x_2);
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_seq___elambda__1___spec__1(x_8, x_9, x_9, x_1, x_2, x_6);
-x_11 = lean_ctor_get(x_10, 3);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-x_13 = l_Lean_Parser_tokenFn(x_2, x_10);
-x_14 = lean_ctor_get(x_13, 3);
-lean_inc(x_14);
-if (lean_obj_tag(x_14) == 0)
-{
-lean_object* x_15; lean_object* x_16; 
-x_15 = lean_ctor_get(x_13, 0);
-lean_inc(x_15);
-x_16 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_15);
-lean_dec(x_15);
-if (lean_obj_tag(x_16) == 2)
-{
-lean_object* x_17; lean_object* x_18; uint8_t x_19; 
-x_17 = lean_ctor_get(x_16, 1);
-lean_inc(x_17);
-lean_dec(x_16);
-x_18 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_19 = lean_string_dec_eq(x_17, x_18);
-lean_dec(x_17);
-if (x_19 == 0)
-{
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_20 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12);
+lean_object* x_22; lean_object* x_23; 
+lean_dec(x_10);
 x_22 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_5);
+x_23 = l_Lean_Parser_ParserState_mkNode(x_11, x_22, x_4);
 return x_23;
 }
-else
-{
-lean_object* x_24; lean_object* x_25; 
-lean_dec(x_12);
-x_24 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_13, x_24, x_5);
-return x_25;
-}
 }
 else
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_16);
-x_26 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12);
-x_28 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_5);
-return x_29;
-}
-}
-else
-{
-lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
 lean_dec(x_14);
-x_30 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12);
+x_24 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_24, x_10);
+x_26 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_4);
+return x_27;
+}
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_12);
+x_28 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_28, x_10);
+x_30 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
+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_dec(x_9);
+lean_dec(x_1);
 x_32 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_5);
+x_33 = l_Lean_Parser_ParserState_mkNode(x_8, x_32, x_4);
 return x_33;
 }
 }
 else
 {
 lean_object* x_34; lean_object* x_35; 
-lean_dec(x_11);
-lean_dec(x_2);
+lean_dec(x_6);
+lean_dec(x_1);
 x_34 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_10, x_34, x_5);
+x_35 = l_Lean_Parser_ParserState_mkNode(x_5, x_34, x_4);
 return x_35;
 }
 }
-else
-{
-lean_object* x_36; lean_object* x_37; 
-lean_dec(x_7);
-lean_dec(x_2);
-x_36 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_6, x_36, x_5);
-return x_37;
-}
-}
 }
 }
 lean_object* _init_l_Lean_Parser_Term_tacticStxQuot___closed__1() {
@@ -5665,7 +5518,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Tactic_seq___closed__2;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
@@ -5694,7 +5547,7 @@ lean_object* _init_l_Lean_Parser_Term_tacticStxQuot___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tacticStxQuot___elambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tacticStxQuot___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5718,15 +5571,6 @@ x_1 = l_Lean_Parser_Term_tacticStxQuot___closed__6;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Lean_Parser_Term_tacticStxQuot___elambda__1(x_1, x_2, x_3);
-lean_dec(x_1);
-return x_4;
-}
-}
 lean_object* _init_l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot___closed__1() {
 _start:
 {
@@ -5748,10 +5592,10 @@ return x_3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_tacticStxQuot;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -5784,14 +5628,20 @@ lean_mark_persistent(l_Lean_Parser_regTacticParserAttribute___closed__2);
 res = l_Lean_Parser_regTacticParserAttribute(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_Tactic_underscoreFn___rarg___closed__1 = _init_l_Lean_Parser_Tactic_underscoreFn___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Tactic_underscoreFn___rarg___closed__1);
-l_Lean_Parser_Tactic_underscoreFn___rarg___closed__2 = _init_l_Lean_Parser_Tactic_underscoreFn___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_Tactic_underscoreFn___rarg___closed__2);
-l_Lean_Parser_Tactic_underscoreFn___rarg___closed__3 = _init_l_Lean_Parser_Tactic_underscoreFn___rarg___closed__3();
-lean_mark_persistent(l_Lean_Parser_Tactic_underscoreFn___rarg___closed__3);
-l_Lean_Parser_Tactic_underscoreFn___rarg___closed__4 = _init_l_Lean_Parser_Tactic_underscoreFn___rarg___closed__4();
-lean_mark_persistent(l_Lean_Parser_Tactic_underscoreFn___rarg___closed__4);
+l_Lean_Parser_Tactic_underscoreFn___closed__1 = _init_l_Lean_Parser_Tactic_underscoreFn___closed__1();
+lean_mark_persistent(l_Lean_Parser_Tactic_underscoreFn___closed__1);
+l_Lean_Parser_Tactic_underscoreFn___closed__2 = _init_l_Lean_Parser_Tactic_underscoreFn___closed__2();
+lean_mark_persistent(l_Lean_Parser_Tactic_underscoreFn___closed__2);
+l_Lean_Parser_Tactic_underscoreFn___closed__3 = _init_l_Lean_Parser_Tactic_underscoreFn___closed__3();
+lean_mark_persistent(l_Lean_Parser_Tactic_underscoreFn___closed__3);
+l_Lean_Parser_Tactic_underscoreFn___closed__4 = _init_l_Lean_Parser_Tactic_underscoreFn___closed__4();
+lean_mark_persistent(l_Lean_Parser_Tactic_underscoreFn___closed__4);
+l_Lean_Parser_Tactic_underscore___closed__1 = _init_l_Lean_Parser_Tactic_underscore___closed__1();
+lean_mark_persistent(l_Lean_Parser_Tactic_underscore___closed__1);
+l_Lean_Parser_Tactic_underscore___closed__2 = _init_l_Lean_Parser_Tactic_underscore___closed__2();
+lean_mark_persistent(l_Lean_Parser_Tactic_underscore___closed__2);
+l_Lean_Parser_Tactic_underscore = _init_l_Lean_Parser_Tactic_underscore();
+lean_mark_persistent(l_Lean_Parser_Tactic_underscore);
 l_Lean_Parser_Tactic_ident_x27___closed__1 = _init_l_Lean_Parser_Tactic_ident_x27___closed__1();
 lean_mark_persistent(l_Lean_Parser_Tactic_ident_x27___closed__1);
 l_Lean_Parser_Tactic_ident_x27___closed__2 = _init_l_Lean_Parser_Tactic_ident_x27___closed__2();
@@ -6243,16 +6093,16 @@ lean_mark_persistent(l_Lean_Parser_Tactic_nestedTacticBlockCurly);
 res = l___regBuiltinParser_Lean_Parser_Tactic_nestedTacticBlockCurly(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__1);
-l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__2);
-l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__3 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__3();
-lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__3);
-l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__4 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__4();
-lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__4);
-l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5();
-lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___rarg___closed__5);
+l_Lean_Parser_Tactic_orelse___elambda__1___closed__1 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___closed__1);
+l_Lean_Parser_Tactic_orelse___elambda__1___closed__2 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___closed__2);
+l_Lean_Parser_Tactic_orelse___elambda__1___closed__3 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__3();
+lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___closed__3);
+l_Lean_Parser_Tactic_orelse___elambda__1___closed__4 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__4();
+lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___closed__4);
+l_Lean_Parser_Tactic_orelse___elambda__1___closed__5 = _init_l_Lean_Parser_Tactic_orelse___elambda__1___closed__5();
+lean_mark_persistent(l_Lean_Parser_Tactic_orelse___elambda__1___closed__5);
 l_Lean_Parser_Tactic_orelse___closed__1 = _init_l_Lean_Parser_Tactic_orelse___closed__1();
 lean_mark_persistent(l_Lean_Parser_Tactic_orelse___closed__1);
 l_Lean_Parser_Tactic_orelse___closed__2 = _init_l_Lean_Parser_Tactic_orelse___closed__2();
diff --git a/stage0/stdlib/Init/Lean/Parser/Term.c b/stage0/stdlib/Init/Lean/Parser/Term.c
index 1924a48955..de5ef5e0eb 100644
--- a/stage0/stdlib/Init/Lean/Parser/Term.c
+++ b/stage0/stdlib/Init/Lean/Parser/Term.c
@@ -16,7 +16,6 @@ extern "C" {
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__15;
 lean_object* l_Lean_Parser_Term_subst___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_do___closed__4;
-lean_object* l_Lean_Parser_optionalFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_fcomp___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_orelse___elambda__1___closed__4;
@@ -35,27 +34,28 @@ lean_object* l_Lean_Parser_Term_letIdDecl;
 lean_object* l_Lean_Parser_Term_heq___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_parser_x21___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_matchAlts___closed__3;
-lean_object* l_Lean_Parser_Term_infixL___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_dollar___elambda__1___boxed(lean_object*);
+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___regBuiltinParser_Lean_Parser_Term_suffices(lean_object*);
 lean_object* l_Lean_Parser_Term_arrayLit___closed__3;
 lean_object* l_Lean_Parser_Term_explicit___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_subst;
+lean_object* l_Lean_Parser_darrow___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_quotedName___closed__4;
 lean_object* l_Lean_Parser_Term_andthen___elambda__1___closed__2;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__3;
-lean_object* l_Lean_Parser_Term_bindOp___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_bindOp___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_manyAux___main___closed__1;
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Term_if___closed__13;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_sub(lean_object*);
+lean_object* l_Lean_Parser_darrow___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_andthen___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Term_or___closed__1;
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_namedPattern___elambda__1___closed__2;
 extern lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_cdot___closed__2;
@@ -72,10 +72,10 @@ lean_object* l_Lean_Parser_Term_simpleBinder___closed__2;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__18;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_structInst(lean_object*);
 lean_object* l_Lean_Parser_Term_gt___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_haveAssign___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_structInstField___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_haveAssign___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_structInstField___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_optIdent___closed__3;
-lean_object* l_Lean_Parser_Term_lt___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_lt___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_tupleTail___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_not___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_andthen___elambda__1___closed__4;
@@ -83,22 +83,19 @@ lean_object* l_Lean_Parser_andthenInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_explicit___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_bnot___closed__4;
-lean_object* l_Lean_Parser_Term_sub___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2(lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_sub___elambda__1(lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkError(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_optType___closed__2;
-extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__7;
 lean_object* l_Lean_Parser_Term_sort___elambda__1___closed__8;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_dollarProj(lean_object*);
-lean_object* l_Lean_Parser_darrow___elambda__1___boxed(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__3;
-lean_object* l_Lean_Parser_Term_binderType___elambda__1___boxed(lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_borrowed___closed__4;
 lean_object* l_Lean_Parser_Term_bracktedBinder(uint8_t);
 lean_object* l_Lean_Parser_Term_mapRev___elambda__1___closed__3;
+lean_object* l_Lean_Parser_darrow___elambda__1___closed__1;
 lean_object* l_Lean_Parser_sepByInfo(lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_explicit___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_ge(lean_object*);
 lean_object* l_Lean_Parser_Term_nomatch___elambda__1___closed__3;
@@ -106,18 +103,17 @@ lean_object* l_Lean_Parser_Term_doPat___closed__3;
 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_andM___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_proj;
-lean_object* l_Lean_Parser_Term_dollar___elambda__1(lean_object*);
+lean_object* l_Lean_Parser_Term_dollar___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_addParenHeuristic___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_add(lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_mapConstRev(lean_object*);
-lean_object* l_Lean_Parser_orelseFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_mapConstRev___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_show;
 lean_object* l_Lean_Parser_Term_ne___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_band;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_sub___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_show___elambda__1___closed__5;
 extern lean_object* l_Array_iterateMAux___main___at_Lean_ppGoal___spec__6___closed__3;
@@ -129,7 +125,6 @@ lean_object* l_Lean_Parser_Term_instBinder;
 lean_object* l_Lean_Parser_Term_fun___closed__7;
 lean_object* l_Lean_Parser_Term_parser_x21___elambda__1___closed__6;
 extern lean_object* l_Lean_Parser_Level_paren___closed__2;
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__5;
 lean_object* l_Lean_Parser_Term_inaccessible___closed__1;
 lean_object* l_Lean_Parser_Term_not___closed__6;
 lean_object* l_Lean_Parser_Term_matchAlts(uint8_t);
@@ -140,24 +135,24 @@ lean_object* l_Lean_Parser_Term_namedArgument___closed__7;
 lean_object* l_Lean_Parser_Term_bne___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_suffices___closed__2;
 lean_object* l_Lean_Parser_Term_doExpr___closed__2;
-lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_unicodeSymbolCheckPrecFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_explicit___closed__1;
 lean_object* l_Lean_Parser_Term_str___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_andthen___closed__3;
 lean_object* l_Lean_Parser_Term_not___elambda__1___closed__7;
-lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Term_structInst___closed__6;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_explicit(lean_object*);
 lean_object* l_Lean_Parser_Term_letEqnsDecl___closed__2;
 lean_object* l_Lean_Parser_Term_type___closed__3;
 lean_object* l_Lean_Parser_Term_subtype___closed__6;
-lean_object* l_Lean_Parser_Term_proj___elambda__1___closed__7;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_append(lean_object*);
 lean_object* l_Lean_Parser_Term_nomatch___elambda__1___closed__5;
+lean_object* l_Lean_Parser_darrow___elambda__1___closed__8;
 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_structInstSource___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_forall___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_structInstSource___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_not___closed__5;
 lean_object* l_Lean_Parser_Term_pow___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_char___closed__3;
@@ -176,7 +171,7 @@ lean_object* l_Lean_Parser_Term_subst___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_inaccessible___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_seqLeft___closed__2;
 lean_object* l_Lean_Parser_Term_namedArgument___closed__5;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_show___elambda__1___closed__8;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 lean_object* l_Lean_Parser_Term_match;
@@ -184,7 +179,7 @@ lean_object* l_Lean_Parser_Term_depArrow;
 lean_object* l_Lean_Parser_Term_heq___elambda__1___closed__1;
 extern lean_object* l_Lean_List_format___rarg___closed__2;
 lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__9;
-lean_object* l_Lean_Parser_Term_iff___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_iff___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_have___closed__2;
 lean_object* l_Lean_Parser_Term_implicitBinder___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_do___elambda__1___closed__1;
@@ -192,7 +187,7 @@ lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_lt(lean_object*);
 lean_object* l_Lean_Parser_Term_explicitUniv;
 extern lean_object* l_Int_repr___closed__1;
-lean_object* l_Lean_Parser_charLit(uint8_t);
+extern lean_object* l_Lean_Parser_charLit;
 lean_object* l_Lean_Parser_Term_bnot___closed__1;
 lean_object* l_Lean_Parser_Term_andthen___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_inaccessible___closed__4;
@@ -200,29 +195,27 @@ lean_object* l_Lean_Parser_Term_arrayLit___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_show___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_match__syntax___closed__7;
 lean_object* l_Lean_Parser_Term_matchAlt___closed__8;
-lean_object* l_Lean_Parser_Term_prod___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_prod___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_darrow___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_eq___elambda__1___closed__1;
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_type___elambda__1___closed__7;
-lean_object* l_Lean_Parser_Term_and___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_doSeq___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_and___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_doSeq___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_parser_x21___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_div;
 lean_object* l_Lean_Parser_Term_simpleBinder___closed__1;
 lean_object* l_Lean_Parser_Term_do___closed__3;
-lean_object* l_Lean_Parser_Term_div___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_div___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_if___closed__10;
-extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__3;
 lean_object* l_Lean_Parser_Term_namedPattern___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__5;
 lean_object* l_Lean_Parser_Term_prop;
 lean_object* l_Lean_Parser_Term_seqLeft___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_hole___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_hole___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_seqRight___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_do___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_binderTactic___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__3;
 lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_type___elambda__1___closed__2;
@@ -231,38 +224,38 @@ lean_object* l_Lean_Parser_Term_where___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_letPatDecl;
 lean_object* l_Lean_Parser_Term_sortApp___closed__4;
 lean_object* l_Lean_Parser_Term_bnot___closed__2;
-lean_object* l_Lean_Parser_Term_typeAscription___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_typeAscription___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_band___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_and___closed__3;
 lean_object* l_Lean_Parser_Term_antiquot;
 lean_object* l_Lean_Parser_Term_tupleTail___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Term_parenSpecial___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_parenSpecial___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_seqLeft___elambda__1___closed__2;
+extern lean_object* l_Lean_Parser_pushNone;
 lean_object* l_Lean_Parser_Term_subst___elambda__1___closed__1;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__8;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_show___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_cdot___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_cdot___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_andM___closed__2;
 lean_object* l_Lean_Parser_Term_doId___closed__5;
 lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_instBinder___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_instBinder___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+lean_object* l_Lean_Parser_darrow___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_have___closed__3;
 lean_object* l_Lean_Parser_ParserState_pushSyntax(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__6;
-lean_object* l_Lean_Parser_Term_binderTactic___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_binderTactic___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__4;
 lean_object* l_Lean_Parser_Term_anonymousCtor___closed__8;
-lean_object* l_Lean_Parser_Term_dollarProj___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_dollarProj___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doPat;
 lean_object* l_Lean_Parser_Term_proj___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Term_sort___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_sort___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_heq___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_namedPattern___closed__3;
 lean_object* l_Lean_Parser_Term_sortApp___closed__1;
@@ -272,27 +265,24 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_emptyC(lean_object*);
 lean_object* l_Lean_Parser_Term_quotedName___closed__3;
 extern lean_object* l_Lean_Parser_dollarSymbol___closed__1;
 lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__10;
-lean_object* l_Lean_Parser_ident(uint8_t);
+extern lean_object* l_Lean_Parser_ident;
 lean_object* l_Lean_Parser_Term_seq___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_sortApp___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_quotedName(lean_object*);
 lean_object* l_Lean_Parser_Term_show___elambda__1___closed__6;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_simpleBinder___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_simpleBinder___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_letIdLhs___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_optIdent___closed__1;
 lean_object* l_Lean_Parser_Term_lt___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_arrow___closed__1;
 lean_object* l_Lean_Parser_Term_forall___closed__3;
-extern lean_object* l_Lean_fieldIdxKind___closed__1;
 lean_object* l_Lean_Parser_Term_subtype___closed__1;
 lean_object* l_Lean_Parser_Term_anonymousCtor___closed__4;
 lean_object* l_Lean_Parser_Term_or___closed__2;
-lean_object* l_Lean_Parser_Term_proj___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__6;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_fromTerm___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_quotedName___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_beq___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_subtype___closed__2;
 lean_object* l_Lean_Parser_Term_modN;
@@ -302,22 +292,22 @@ lean_object* l_Lean_Parser_ParserState_mkNode(lean_object*, lean_object*, lean_o
 lean_object* l_Lean_Parser_Term_equiv___closed__2;
 lean_object* l_Lean_Parser_Term_suffices___closed__9;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_andthen(lean_object*);
-lean_object* l_Lean_Parser_Term_ge___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_ge___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_darrow;
 lean_object* l_Lean_Parser_Term_arrow___closed__2;
 lean_object* l_Lean_Parser_Term_nomatch___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_uminus___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_uminus___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doPat___closed__2;
 lean_object* l_Lean_Parser_Term_heq___closed__2;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_do___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_andM___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_seq___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_seq___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_matchAlts___closed__6;
 lean_object* l_Lean_Parser_Term_namedArgument___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_namedArgument___closed__3;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_do(lean_object*);
 lean_object* l_Lean_Parser_Term_num___elambda__1___closed__2;
 extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__1;
@@ -330,7 +320,7 @@ lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__12;
 lean_object* l_Lean_Parser_Term_match__syntax___closed__3;
 extern lean_object* l_Lean_Parser_symbolNoWsFn___closed__1;
 lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Term_bor___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_bor___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_hole___closed__2;
 lean_object* l_Lean_Parser_Term_pow___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_seqLeft___elambda__1___closed__4;
@@ -342,6 +332,7 @@ lean_object* l_Lean_Parser_Term_parser_x21___elambda__1___closed__2;
 extern lean_object* l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
 lean_object* l_Lean_Parser_Term_not___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_cdot___closed__4;
+lean_object* l_Lean_Parser_orelseFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_doLet___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_doPat___closed__4;
@@ -349,18 +340,18 @@ lean_object* l_Lean_Parser_Term_doId___closed__2;
 lean_object* l_Lean_Parser_Term_nomatch___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_arrayLit___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_listLit___closed__2;
-lean_object* l_Lean_Parser_Term_band___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_band___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkTrailingNode(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__20;
 lean_object* l_Lean_Parser_Term_seqRight___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__11;
 lean_object* l_Lean_Parser_Term_let___elambda__1___closed__7;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14(lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_not___closed__3;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_addBuiltinParser(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_addBuiltinParser(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_optIdent___closed__4;
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Lean_Parser_Term_doId___closed__1;
@@ -369,12 +360,12 @@ lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_cons___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_matchAlt___closed__7;
 lean_object* l_Lean_Parser_Term_suffices___closed__8;
-lean_object* l_Lean_Parser_Term_app___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_app___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_arrayLit___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_nomatch___elambda__1___closed__8;
 lean_object* lean_string_append(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_explicit___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_explicit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_sorry___closed__2;
 lean_object* l_Lean_Parser_Term_if___closed__11;
 lean_object* l_Lean_Parser_Term_num___elambda__1___closed__1;
@@ -394,13 +385,13 @@ lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_optType___closed__1;
 lean_object* l_Lean_Parser_Term_match__syntax___closed__5;
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Term_mod___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_mod___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__6;
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_Term_instBinder___closed__3;
-lean_object* l_Lean_Parser_Term_binderType___elambda__2___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_and;
-lean_object* l_Lean_Parser_Term_gt___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_bracketedDoSeq___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_gt___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_bracketedDoSeq___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_suffices___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_parenSpecial___closed__1;
 lean_object* l_Lean_Parser_Term_not___elambda__1___closed__5;
@@ -408,7 +399,7 @@ lean_object* l_Lean_Parser_Term_listLit___closed__9;
 lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_namedPattern___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_show___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Term_tupleTail___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_tupleTail___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Level_paren___closed__3;
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_forall___closed__7;
@@ -418,10 +409,9 @@ lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1___rarg(lean_object*);
 lean_object* l_Lean_Parser_Term_eq___elambda__1___closed__3;
 extern lean_object* l_List_repr___rarg___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_antiquot___closed__1;
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__8;
 lean_object* l_Lean_Parser_Term_quotedName___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_bracktedBinder___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_bracktedBinder___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__13;
 lean_object* l_Lean_Parser_Term_anonymousCtor___closed__9;
 lean_object* l_Lean_Parser_Term_sorry___closed__1;
@@ -430,12 +420,10 @@ lean_object* l_Lean_Parser_Term_ge___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_simpleBinder___closed__3;
 lean_object* l_Lean_Parser_Term_heq___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_parser_x21___closed__5;
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__4;
 lean_object* l_Lean_Parser_Term_proj___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_bnot___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_instBinder___closed__7;
 lean_object* lean_string_utf8_byte_size(lean_object*);
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_if;
 lean_object* l_Lean_Parser_Term_paren;
 lean_object* l_Lean_Parser_Term_anonymousCtor___closed__1;
@@ -443,17 +431,17 @@ lean_object* l_Lean_Parser_Term_structInstSource___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_heq___closed__3;
 lean_object* l_Lean_Parser_ParserState_mkErrorsAt(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_andM___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_mul___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_mul___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_tupleTail___elambda__1___closed__2;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_binderType(uint8_t);
 lean_object* l_Lean_Parser_Term_cons___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_letDecl___closed__2;
 lean_object* l_Lean_Parser_Term_optIdent___closed__2;
 lean_object* l_Lean_Parser_Term_simpleBinder___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_listLit___closed__8;
-lean_object* l_Lean_Parser_Term_eq___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_doPat___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_eq___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_doPat___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_have___closed__7;
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_sort___elambda__1___closed__2;
@@ -466,17 +454,14 @@ lean_object* l_Lean_Parser_Term_where___closed__6;
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__9;
 lean_object* l_Lean_Parser_Term_prod___closed__3;
 lean_object* l_Lean_Parser_Term_doId___closed__4;
 lean_object* l_Lean_Parser_Term_lt___elambda__1___closed__2;
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__8;
 lean_object* l_Lean_Parser_Term_pow___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_uminus___closed__7;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__4;
 lean_object* l_Lean_Parser_Term_suffices___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__8;
-lean_object* l_Lean_Parser_symbolFn___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_borrowed;
 lean_object* l_Lean_Parser_Term_and___closed__1;
 lean_object* l_Lean_Parser_Term_paren___closed__7;
@@ -488,6 +473,7 @@ extern lean_object* l_Lean_mkAppStx___closed__8;
 lean_object* l_Lean_Parser_Term_explicit___closed__4;
 lean_object* l_Lean_Parser_Term_cdot___closed__1;
 lean_object* l_Lean_Parser_Term_namedPattern___closed__7;
+extern lean_object* l_Lean_Parser_fieldIdx___closed__4;
 lean_object* l_Lean_Parser_Term_fromTerm___elambda__1___closed__4;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__2;
 lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__13;
@@ -516,7 +502,7 @@ lean_object* l_Lean_Parser_Term_subtype___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_where___closed__4;
 lean_object* l_Lean_Parser_Term_prod___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_paren___closed__5;
-lean_object* l_Lean_Parser_Term_infixR___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_infixR___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_div___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_sort___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_arrayLit___closed__6;
@@ -524,40 +510,39 @@ lean_object* l_Lean_Parser_Term_str;
 lean_object* l_Lean_Parser_Term_binderTactic___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_depArrow___closed__8;
 lean_object* l_Lean_Parser_Term_dollarProj___elambda__1___closed__3;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__2;
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_sorry(lean_object*);
 lean_object* l_Lean_Parser_Term_nomatch___closed__4;
 lean_object* l_Lean_Parser_Term_or___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_listLit___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_listLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_ge___closed__1;
 lean_object* l_Lean_Parser_Term_borrowed___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Term_arrayRef___closed__5;
+lean_object* l_Lean_Parser_strLit___elambda__1(lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_checkStackTopFn___closed__1;
 lean_object* l_Lean_Parser_Term_bindOp___closed__3;
-lean_object* l_Lean_Parser_Term_add___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_add___elambda__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_mkTermIdFromIdent___closed__2;
-lean_object* l_Lean_Parser_Term_parser_x21___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_beq___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_parser_x21___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_beq___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_dollar;
 lean_object* l_Lean_Parser_Term_cdot___closed__3;
 lean_object* l_Lean_Parser_Term_simpleBinder___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_mul___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__15;
-extern lean_object* l_Lean_Parser_unicodeSymbolFn___rarg___closed__1;
-lean_object* l_Lean_Parser_Term_str___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_listLit___closed__6;
 lean_object* l_Lean_Parser_Term_proj___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_paren___closed__1;
 lean_object* l_Lean_Parser_Term_add___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_letPatDecl___closed__1;
-lean_object* l_Lean_Parser_Term_binderType___elambda__1(lean_object*);
+lean_object* l_Lean_Parser_Term_binderType___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_letIdDecl___closed__10;
 lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_suffices___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_add___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__6;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_seqRight___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_id(lean_object*);
 lean_object* l_Lean_Parser_Term_doElem___closed__3;
@@ -576,11 +561,9 @@ lean_object* l_Lean_Parser_Term_fun___closed__6;
 lean_object* l_Lean_Parser_Term_num___closed__2;
 lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_binderDefault;
-lean_object* l_Lean_Parser_unicodeSymbolFn___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_namedPattern___elambda__1___closed__5;
-lean_object* l_Lean_Parser_tryFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__9;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_uminus___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_sort___closed__1;
 extern lean_object* l_Lean_Parser_termParser___closed__1;
@@ -588,14 +571,13 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_arrayLit(lean_object*);
 lean_object* l_Lean_Parser_Term_do___closed__1;
 lean_object* l_Lean_Parser_Term_bracketedDoSeq;
 lean_object* l_Lean_Parser_Term_paren___closed__3;
-extern lean_object* l_Lean_Parser_fieldIdx___closed__1;
 lean_object* l_Lean_Parser_Term_eq;
 lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_prod___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_sort___closed__2;
 lean_object* l_Lean_Parser_Term_uminus___closed__3;
 lean_object* l_Lean_Parser_Term_let___closed__1;
-lean_object* l_Lean_Parser_Term_namedHole___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_namedHole___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_subtype___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_typeAscription;
 lean_object* l_Lean_Parser_Term_sortApp;
@@ -618,21 +600,18 @@ lean_object* l_Lean_Parser_Term_seqLeft___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_anonymousCtor___closed__3;
 lean_object* l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__3;
 lean_object* l_Lean_Parser_Term_arrow;
 lean_object* l_Lean_Parser_Term_letIdLhs___closed__5;
 lean_object* l_Lean_Parser_Term_emptyC___elambda__1___closed__1;
-lean_object* l_Lean_Parser_manyAux___main(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__14;
 lean_object* l_Lean_Parser_Term_mapConstRev___closed__3;
 lean_object* l_Lean_Parser_Term_match___closed__6;
-lean_object* l_Lean_Parser_Term_binderType___elambda__2___boxed(lean_object*);
 lean_object* l_Lean_Parser_Term_uminus___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Term_dollar___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_mapRev___closed__1;
 lean_object* l_Lean_Parser_Term_do___closed__2;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
@@ -645,14 +624,14 @@ lean_object* l_Lean_Parser_Term_paren___closed__2;
 lean_object* l_Lean_Parser_Term_suffices___elambda__1___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_mapRev(lean_object*);
 lean_object* l_Lean_Parser_Term_structInst___closed__8;
-lean_object* l_Lean_Parser_Term_matchAlts___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_matchAlts___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_append___closed__3;
 lean_object* l_Lean_Parser_Term_show___closed__1;
 lean_object* l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__1;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_subtype___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_modN___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1(lean_object*);
 lean_object* l_Lean_Parser_Term_uminus___closed__4;
 lean_object* l_Lean_Parser_Term_prod;
 lean_object* l_Lean_Parser_Term_sorry___elambda__1___closed__1;
@@ -660,11 +639,11 @@ lean_object* l_Lean_Parser_Term_let___closed__8;
 lean_object* l_Lean_Parser_Term_optType;
 lean_object* l_Lean_Parser_Term_binderTactic___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_tupleTail___closed__1;
-lean_object* l_Lean_Parser_Term_not___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_not___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_le___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_structInstSource___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_letEqnsDecl___closed__3;
-lean_object* l_Lean_Parser_Term_str___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_str___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_bracketedDoSeq___closed__5;
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__11;
 lean_object* l_Lean_Parser_Term_band___elambda__1___closed__2;
@@ -675,7 +654,7 @@ lean_object* l_Lean_Parser_Term_namedHole___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_parenSpecial;
 lean_object* l_Lean_Parser_Term_mapConst___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_proj___closed__4;
-lean_object* l_Lean_Parser_Term_pow___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_pow___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_char___closed__1;
 lean_object* l_Lean_Parser_Term_fun;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__1;
@@ -683,14 +662,15 @@ lean_object* l_Lean_Parser_nodeInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_eq___closed__1;
 lean_object* l_Lean_Parser_Term_structInst___closed__4;
 lean_object* l_Lean_Parser_Term_num___closed__4;
-lean_object* l_Lean_Parser_dollarSymbol(uint8_t);
-lean_object* l_Lean_Parser_Term_suffices___elambda__1(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_dollarSymbol;
+lean_object* l_Lean_Parser_Term_suffices___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_fromTerm___closed__2;
+lean_object* l_Lean_Parser_symbolFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_id___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_type___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_let___closed__4;
 lean_object* l_Lean_Parser_Term_nomatch___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_ge___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_have___closed__11;
 lean_object* l_Lean_Parser_Term_doSeq___closed__1;
@@ -698,20 +678,19 @@ lean_object* l_Lean_Parser_Term_or___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_namedPattern___elambda__1___closed__7;
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_binderTactic;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_namedArgument___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_mapRev___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_forall(lean_object*);
 lean_object* l_Lean_Parser_Term_proj___closed__8;
 lean_object* l_Lean_Parser_Term_bor___closed__3;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_modN___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_implicitBinder___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_ge___closed__2;
 lean_object* l_Lean_Parser_Term_typeSpec___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_andM(lean_object*);
-lean_object* l_Lean_Parser_Term_proj___closed__9;
 lean_object* l_Lean_Parser_Term_parenSpecial___closed__3;
 lean_object* l_Lean_Parser_Term_ne___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_doId___elambda__1___closed__4;
@@ -722,9 +701,7 @@ lean_object* l_Lean_Parser_Term_letDecl;
 lean_object* l_Lean_Parser_Term_id___closed__2;
 lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_sorry___elambda__1___closed__8;
-extern lean_object* l_Lean_Parser_checkLeadingFn___closed__1;
 lean_object* l_Lean_Parser_Term_explicitUniv___closed__6;
-lean_object* l_Lean_Parser_Term_arrayRef___closed__7;
 lean_object* l_Lean_Parser_Term_equiv;
 lean_object* l_Lean_Parser_Term_doId___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_sort;
@@ -732,8 +709,7 @@ lean_object* l_Lean_Parser_Term_ne___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_mul___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_add___elambda__1___closed__4;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 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;
@@ -745,10 +721,10 @@ lean_object* l_Lean_Parser_Term_match___closed__5;
 lean_object* l_Lean_Parser_checkWsBeforeFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_le___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_div___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_borrowed___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_borrowed___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_where___closed__9;
 lean_object* l_Lean_Parser_Term_bracketedDoSeq___closed__4;
-lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_binderIdent___closed__3;
 lean_object* l_Lean_Parser_Term_band___elambda__1___closed__1;
 lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*);
@@ -757,13 +733,12 @@ lean_object* l_Lean_Parser_Term_quotedName___elambda__1___closed__2;
 extern lean_object* l_Lean_getBuiltinSearchPath___closed__1;
 lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_dollar(lean_object*);
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__7;
 lean_object* l_Lean_Parser_Term_explicitUniv___closed__5;
 lean_object* l_Lean_Parser_Term_let___closed__6;
 lean_object* l_Lean_Parser_Term_lt___closed__2;
 lean_object* l_Lean_Parser_Term_sorry___closed__3;
 lean_object* l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_ge___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_structInstField___closed__2;
 lean_object* l_Lean_Parser_Term_have;
@@ -788,13 +763,12 @@ lean_object* l_Lean_Parser_Term_sub___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_equiv___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_not___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_doElem___closed__4;
-lean_object* l_Lean_Parser_Term_seqLeft___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_seqLeft___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_eq(lean_object*);
 lean_object* l_Lean_Parser_Term_explicitBinder___closed__3;
 lean_object* l_Lean_Parser_Term_parser_x21___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_suffices___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_bnot;
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__3;
 lean_object* l_Lean_Parser_Term_doLet___closed__3;
 lean_object* l_Lean_Parser_Term_seq___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_bnot___closed__5;
@@ -823,7 +797,7 @@ lean_object* l_Lean_Parser_Term_sorry___closed__5;
 lean_object* l_Lean_Parser_Term_sub___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_fromTerm___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_show___closed__4;
-lean_object* l_Lean_Parser_nameLit(uint8_t);
+extern lean_object* l_Lean_Parser_nameLit;
 lean_object* l_Lean_Parser_Term_subtype;
 lean_object* l_Lean_Parser_Term_suffices___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_emptyC___elambda__1___closed__9;
@@ -834,40 +808,37 @@ lean_object* l_Lean_Parser_Term_explicitUniv___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_bne(lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_inaccessible(lean_object*);
 lean_object* l_Lean_Parser_Term_depArrow___closed__2;
-lean_object* l_Lean_Parser_Term_structInst___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_structInst___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__13;
 lean_object* l_Lean_Parser_Term_andM___closed__1;
 lean_object* l_Lean_Parser_Term_listLit___closed__5;
 lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__14;
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Parser_checkTailNoWs(lean_object*);
 lean_object* l_Lean_Parser_Term_subtype___elambda__1___closed__9;
-lean_object* l_Lean_Parser_Term_emptyC___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_emptyC___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_orelse___closed__1;
 lean_object* l_Lean_Parser_Term_fromTerm;
 lean_object* l_Lean_Parser_Term_anonymousCtor___closed__6;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__14;
 lean_object* l_Lean_Parser_Term_ne___closed__3;
-lean_object* l_Lean_Parser_andthenFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_show___closed__2;
 lean_object* l_Lean_Parser_Term_uminus___elambda__1___closed__4;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_orelse___closed__2;
 lean_object* l_Lean_Parser_Term_explicitBinder___closed__5;
-lean_object* l_Lean_Parser_Term_implicitBinder___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_implicitBinder___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_bnot___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_namedPattern___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_orM;
 lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_heq;
-lean_object* l_Lean_Parser_nodeFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_inaccessible___closed__6;
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_Term_structInst___closed__5;
 lean_object* l_Lean_Parser_Term_le___closed__3;
 lean_object* l_Lean_Parser_Term_fcomp;
 lean_object* l_Lean_Parser_Term_fromTerm___elambda__1___closed__5;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_depArrow___closed__4;
 lean_object* l_Lean_Parser_Term_subtype___closed__5;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_bindOp(lean_object*);
@@ -875,7 +846,7 @@ lean_object* l_Lean_Parser_Term_seqRight___closed__2;
 lean_object* l_Lean_Parser_Term_sort___closed__4;
 lean_object* l_Lean_Parser_Term_namedHole;
 lean_object* l_Lean_Parser_Term_prod___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Term_heq___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_heq___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_paren___closed__6;
 lean_object* l_Lean_Parser_Term_subst___elambda__1___closed__3;
 extern lean_object* l_Char_HasRepr___closed__1;
@@ -890,35 +861,33 @@ lean_object* l_Lean_Parser_Term_seqLeft;
 lean_object* l_Lean_Parser_Term_have___closed__6;
 lean_object* l_Lean_Parser_Term_mod___closed__3;
 lean_object* l_Lean_Parser_Term_id___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4(lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_bnot___elambda__1___closed__8;
 lean_object* l_Lean_Parser_strAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_fun___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_fun___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_fromTerm___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__9;
-lean_object* l_Lean_Parser_Term_char___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_cdot___closed__5;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_num___closed__1;
 lean_object* l_Lean_Parser_Term_namedHole___elambda__1___closed__2;
 lean_object* l_Lean_Parser_orelseInfo(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_dollarSymbol___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_suffices___elambda__1___closed__8;
 extern lean_object* l_Lean_Parser_fieldIdx___closed__2;
-lean_object* l_Lean_Parser_Term_andthen___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_andthen___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_fcomp___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_cons;
 lean_object* l_Lean_Parser_Term_dollarProj___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Term_nomatch___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_nomatch___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_type(lean_object*);
 lean_object* l_Lean_Parser_Term_binderIdent___closed__1;
 lean_object* l_Lean_Parser_Term_structInstSource___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_ge___closed__3;
 lean_object* l_Lean_Parser_Term_structInstSource;
-lean_object* l_Lean_Parser_Term_quotedName___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_quotedName___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doSeq___closed__2;
 lean_object* l_Lean_Parser_Term_doElem___closed__1;
 lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__13;
@@ -935,7 +904,7 @@ lean_object* lean_name_mk_string(lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__2;
 lean_object* l_Lean_Parser_Term_match___closed__2;
 lean_object* l_Lean_Parser_Term_binderIdent___closed__2;
-extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__5;
+lean_object* l_Lean_Parser_darrow___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_instBinder___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_append___closed__1;
@@ -944,12 +913,11 @@ lean_object* l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__4;
 extern lean_object* l_List_reprAux___main___rarg___closed__1;
 lean_object* l_Lean_Parser_Term_id___closed__6;
 lean_object* l_Lean_Parser_Term_map___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Term_namedArgument___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_namedArgument___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_add___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_doElem___closed__2;
 lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__1;
-lean_object* l_Lean_Parser_Term_or___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_or___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_structInstSource___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_seq(lean_object*);
 lean_object* l_Lean_Parser_Term_sub___elambda__1___closed__3;
@@ -957,7 +925,7 @@ lean_object* l_Lean_Parser_Term_bindOp___closed__2;
 lean_object* l_Lean_Parser_Term_uminus___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_uminus___closed__5;
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_fcomp___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_fcomp___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_mapConst;
 lean_object* l_Lean_Parser_Term_andM___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
@@ -966,10 +934,10 @@ lean_object* l_Lean_Parser_Term_fromTerm___elambda__1___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_num(lean_object*);
 lean_object* l_Lean_Parser_Term_ne___closed__2;
 lean_object* l_Lean_Parser_Term_fcomp___elambda__1___closed__1;
-extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__11;
 lean_object* l_Lean_Parser_Term_binderDefault___elambda__1___closed__3;
 lean_object* l_Lean_Parser_pushNone___elambda__1___rarg(lean_object*);
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1(lean_object*);
+lean_object* l_Lean_Parser_Term_arrayRef___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_darrow___elambda__1___closed__5;
 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_lt___closed__1;
@@ -978,6 +946,7 @@ lean_object* l_Lean_Parser_Term_seq;
 lean_object* l_Lean_Parser_Term_depArrow___closed__1;
 lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_proj___closed__5;
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_binderDefault___closed__2;
 lean_object* l_Lean_Parser_Term_orM___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_structInstField___closed__1;
@@ -999,11 +968,11 @@ lean_object* l_Lean_Parser_Term_implicitBinder(uint8_t);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_seqLeft(lean_object*);
 lean_object* l_Lean_Parser_Term_orM___closed__3;
 lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1___closed__7;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_matchAlts___closed__4;
 lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_namedPattern___closed__6;
-lean_object* l_Lean_Parser_Term_match__syntax___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_match__syntax___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_modN___closed__2;
 lean_object* l_Lean_Parser_Term_bnot___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_depArrow___closed__5;
@@ -1020,10 +989,10 @@ lean_object* l_Lean_Parser_Term_beq___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_uminus___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_namedHole___elambda__1___closed__3;
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_char___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___closed__4;
+lean_object* l_Lean_Parser_Term_char___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_explicitBinder___closed__1;
-lean_object* l_Lean_Parser_Term_sortApp___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_Term_dollarProj___closed__1;
 lean_object* l_Lean_Parser_Term_do;
 lean_object* l_Lean_Parser_Term_seqRight___closed__3;
@@ -1038,17 +1007,16 @@ lean_object* l_Lean_Parser_Term_tupleTail___closed__3;
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_structInstField___elambda__1___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_fcomp(lean_object*);
-lean_object* l_Lean_Parser_Term_bne___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_bne___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_let___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_namedHole___closed__5;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_mod___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_structInst___closed__2;
 lean_object* l_Lean_Parser_Term_explicitUniv___closed__9;
 lean_object* l_Lean_Parser_Term_match___closed__1;
 lean_object* l_Lean_Parser_symbolNoWsInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_explicitUniv___closed__4;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12(lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_append___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_proj___closed__2;
 lean_object* l_Lean_FileMap_toPosition(lean_object*, lean_object*);
@@ -1058,7 +1026,7 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_heq(lean_object*);
 lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_namedArgument___closed__1;
 lean_object* l_Lean_Parser_Term_namedHole___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Term_arrow___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_arrow___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_uminus___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_namedPattern___closed__5;
 lean_object* l_Lean_Parser_Term_mod___closed__1;
@@ -1070,7 +1038,7 @@ lean_object* l_Lean_Parser_Term_mapConstRev___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__2;
 extern lean_object* l_Lean_Parser_Error_toString___closed__2;
 lean_object* l_Lean_Parser_Term_orM___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Term_equiv___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_equiv___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_subtype___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_arrayRef(lean_object*);
@@ -1090,7 +1058,7 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_sort(lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__3;
 lean_object* l_Lean_Parser_Term_id___closed__3;
 lean_object* l_Lean_Parser_Term_let___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_sortApp___elambda__1(lean_object*);
+lean_object* l_Lean_Parser_Term_sortApp___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_unicodeInfixL(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_hole___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_structInstSource___closed__6;
@@ -1099,7 +1067,6 @@ lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_letEqnsDecl;
 lean_object* l_Lean_Parser_Term_cons___closed__2;
 lean_object* l_Lean_Parser_Term_dollarProj___closed__2;
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__4;
 lean_object* l_Lean_Parser_Term_bnot___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_binderDefault___closed__1;
 lean_object* l_Lean_Parser_Term_have___closed__8;
@@ -1109,64 +1076,65 @@ lean_object* l_Lean_Parser_Term_num___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_and___closed__2;
 lean_object* l_Lean_Parser_Term_prop___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_mul(lean_object*);
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_subtype___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Term_letEqnsDecl___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_binderType___elambda__2(lean_object*);
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___boxed(lean_object*);
-extern lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__4;
+lean_object* l_Lean_Parser_Term_letEqnsDecl___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_sortApp___elambda__1___closed__1;
+lean_object* l_Lean_Parser_Term_binderType___elambda__2(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_bracketedDoSeq___closed__2;
 lean_object* l_Lean_Parser_Term_andthen;
+lean_object* l_Lean_Parser_Term_matchAlt___closed__11;
 lean_object* l_Lean_Parser_Term_or___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_mapConst___closed__3;
 lean_object* l_Lean_Parser_Term_doPat___closed__9;
 lean_object* l_Lean_Parser_Term_doId;
 lean_object* l_Lean_Parser_Term_structInst___closed__12;
-lean_object* l_Lean_Parser_Term_subtype___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_subtype___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_nomatch___closed__6;
 lean_object* l_Lean_Parser_Term_prod___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_mod(lean_object*);
 lean_object* l_Lean_Parser_Term_emptyC___closed__1;
 lean_object* l_Lean_Parser_Term_not___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_match__syntax___closed__4;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_show___closed__7;
 lean_object* l_Lean_Parser_ParserState_restore(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___closed__1;
 extern lean_object* l_Lean_formatEntry___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_have(lean_object*);
 lean_object* l_Lean_Parser_Term_structInstSource___closed__5;
 lean_object* l_Lean_Parser_Term_typeSpec___elambda__1___closed__3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_cdot(lean_object*);
-lean_object* l_Lean_Parser_Term_mapRev___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_mapRev___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_if___closed__12;
 lean_object* l_Lean_Parser_Term_forall;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_str(lean_object*);
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
-lean_object* l_Lean_Parser_Term_where___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_map___closed__3;
 lean_object* l_Lean_Parser_Term_borrowed___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__11;
 lean_object* l_Lean_Parser_ParserState_popSyntax(lean_object*);
 lean_object* l_Lean_Parser_Term_parser_x21;
 extern lean_object* l_Lean_Parser_FirstTokens_toStr___closed__3;
 lean_object* l_Lean_Parser_Term_mapConstRev___elambda__1___closed__2;
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_inaccessible___elambda__1___closed__9;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_nomatch(lean_object*);
 lean_object* l_Lean_Parser_Term_structInstField;
 lean_object* l_Lean_Parser_Term_iff___elambda__1___closed__4;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16(lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_borrowed___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_typeAscription___closed__3;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
 lean_object* l_Lean_Parser_Term_have___closed__10;
-lean_object* l_Lean_Parser_Term_arrayRef___closed__6;
 lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__15;
 lean_object* l_Lean_Parser_Term_borrowed___closed__7;
 lean_object* l_Lean_Parser_Term_doLet___closed__5;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_prod(lean_object*);
 lean_object* l_Lean_Parser_Term_arrow___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_seq___elambda__1___closed__1;
+lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_fun___closed__8;
@@ -1175,7 +1143,7 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_fun(lean_object*);
 lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_bracktedBinder___boxed(lean_object*);
 lean_object* l_Lean_Parser_Term_not___elambda__1___closed__9;
-lean_object* l_Lean_Parser_Term_doElem___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_doElem___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_id___closed__5;
 lean_object* l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1___closed__3;
@@ -1184,10 +1152,10 @@ lean_object* l_Lean_Parser_Term_proj___closed__1;
 lean_object* l_Lean_Parser_Term_letIdLhs___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_equiv(lean_object*);
 lean_object* l_Lean_Parser_Term_sort___closed__5;
-lean_object* l_Lean_Parser_Term_optType___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_sorry___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_optType___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_sorry___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__12;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_beq(lean_object*);
 lean_object* l_Lean_Parser_Term_tparser_x21___closed__5;
@@ -1197,8 +1165,8 @@ lean_object* l_Lean_Parser_Term_dollarProj___closed__5;
 lean_object* l_Lean_Parser_Term_append___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_letDecl___closed__4;
 lean_object* l_Lean_Parser_Term_prod___elambda__1___closed__3;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_if___closed__2;
 lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__11;
@@ -1210,7 +1178,6 @@ lean_object* l_Lean_Parser_Term_have___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_fromTerm___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_namedHole___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_letIdLhs___closed__2;
-lean_object* l_Lean_Parser_categoryParserFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doPat___closed__1;
 lean_object* l_Lean_Parser_Term_show___closed__3;
 lean_object* l_Lean_Parser_Term_le___elambda__1___closed__1;
@@ -1218,25 +1185,24 @@ lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Term_cons___closed__1;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_binderDefault___closed__4;
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_str___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_heq___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__16;
-lean_object* l_Lean_Parser_Term_if___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_if___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__1;
+lean_object* l_Lean_Parser_darrow___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_explicitBinder___closed__6;
 lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__7;
 lean_object* l_Lean_Parser_sepBy1Info(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_borrowed___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Term_typeAscription___closed__7;
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__3;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_nomatch___closed__1;
-lean_object* l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Parser_Term_matchAlt___closed__10;
 lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_fcomp___closed__1;
 lean_object* l_Lean_Parser_Term_where___closed__5;
-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_tparser_x21___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_explicit___closed__3;
@@ -1259,6 +1225,7 @@ lean_object* l_Lean_Parser_Term_cons___closed__3;
 lean_object* l_Lean_Parser_Term_dollarProj___closed__3;
 lean_object* l_Lean_Parser_Term_id;
 lean_object* l_Lean_Parser_Term_arrow___elambda__1___closed__1;
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_match__syntax___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_beq___closed__3;
@@ -1267,13 +1234,14 @@ lean_object* l_Lean_Parser_Term_haveAssign___closed__6;
 lean_object* l_Lean_Parser_Term_arrayRef___closed__2;
 extern lean_object* l_Lean_Parser_appPrec;
 lean_object* l_Lean_Parser_Term_bnot___elambda__1___closed__1;
+lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_dollarProj___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_do___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_sort___closed__3;
 lean_object* l_Lean_Parser_Term_let___closed__7;
 lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_mul___closed__1;
-lean_object* l_Lean_Parser_nodeWithAntiquot(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_nodeWithAntiquot(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_proj___closed__7;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__2;
@@ -1281,10 +1249,12 @@ lean_object* l_Lean_Parser_Term_tupleTail;
 lean_object* l_Lean_Parser_Term_typeAscription___closed__5;
 lean_object* l_Lean_Parser_Term_le___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_eq___closed__2;
+lean_object* l_Lean_Parser_ident___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_binderIdent;
-lean_object* l_Lean_Parser_Term_simpleBinder___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_simpleBinder___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_infixR(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_seqLeft___closed__3;
+lean_object* l_Lean_Parser_charLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__4;
 lean_object* l_Lean_Parser_Term_uminus___closed__2;
@@ -1294,9 +1264,10 @@ lean_object* l_Lean_Parser_Term_fromTerm___closed__4;
 lean_object* l_Lean_Parser_Term_matchAlt___closed__9;
 lean_object* l_Lean_Parser_Term_arrayLit;
 lean_object* l_Lean_Parser_Term_mul___closed__2;
+extern lean_object* l_Lean_Parser_numLit;
 lean_object* l_Lean_Parser_Term_mod___closed__2;
 lean_object* l_Lean_Parser_Term_leftArrow;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_inaccessible___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_namedPattern___closed__4;
@@ -1309,22 +1280,23 @@ lean_object* l_Lean_Parser_Term_forall___closed__1;
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Term_haveAssign___closed__1;
 lean_object* l_Lean_Parser_Term_emptyC___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Term_modN___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_map___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_modN___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_map___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_le(lean_object*);
 lean_object* l_Lean_Parser_Term_seqRight;
 lean_object* l_Lean_Parser_Term_bindOp;
 lean_object* l_Lean_Parser_Term_doPat___closed__10;
 lean_object* l_Lean_Parser_Term_simpleBinder;
 lean_object* l_Lean_Parser_Term_bor___elambda__1___closed__3;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_div___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Term_doExpr___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_doExpr___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_let___closed__5;
 lean_object* l_Lean_Parser_Term_sub___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_proj(lean_object*);
 extern lean_object* l_PersistentArray_Stats_toString___closed__4;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_band(lean_object*);
+lean_object* l_Lean_Parser_numLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_uminus___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_bor___closed__2;
 lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__4;
@@ -1342,33 +1314,34 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_show(lean_object*);
 lean_object* l_Lean_Parser_Term_do___closed__7;
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_append___elambda__1___closed__3;
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_le___closed__1;
 lean_object* l_Lean_Parser_Term_sorry;
 lean_object* l_Lean_Parser_Term_tparser_x21___closed__3;
 lean_object* l_Lean_Parser_Term_matchAlt;
 lean_object* l_Lean_Parser_Term_or___closed__3;
 lean_object* l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_binderDefault___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_binderDefault___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_nomatch___closed__2;
-lean_object* l_Lean_Parser_Term_type___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_type___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_not(lean_object*);
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__7;
 lean_object* l_Lean_Parser_Term_prop___closed__1;
-lean_object* l_Lean_Parser_Term_subst___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_subst___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_binderType___boxed(lean_object*);
 lean_object* l_Lean_Parser_Term_binderType___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_match__syntax(lean_object*);
 lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_match__syntax___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Term_have___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_have___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_orelse(lean_object*);
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_tupleTail___closed__6;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__2;
 lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_structInstSource___elambda__1___closed__1;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_prod___closed__1;
+lean_object* l_Lean_Parser_tryFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_subst___closed__3;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 lean_object* l_Lean_Parser_Term_arrayLit___closed__5;
@@ -1385,12 +1358,12 @@ lean_object* l_Lean_Parser_Term_emptyC___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_instBinder___closed__8;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_bor(lean_object*);
 lean_object* l_Lean_Parser_darrow___closed__1;
-lean_object* l_Lean_Parser_Term_matchAlts___elambda__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_matchAlts___elambda__1(uint8_t, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
 lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_paren___elambda__1___closed__2;
-lean_object* l_Lean_Parser_categoryParser(uint8_t, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_letIdLhs___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_categoryParser(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_letIdLhs___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_forall___closed__2;
 lean_object* l_Lean_Parser_Term_num;
 lean_object* l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
@@ -1408,7 +1381,6 @@ lean_object* l_Lean_Parser_Term_parser_x21___closed__1;
 lean_object* l_Lean_Parser_Term_inaccessible___closed__3;
 lean_object* l_Lean_Parser_Term_match__syntax___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_str___elambda__1___closed__4;
-extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__4;
 lean_object* l_Lean_Parser_Term_let___closed__3;
 lean_object* l_Lean_Parser_Term_suffices___closed__7;
 lean_object* l_Lean_Parser_Term_hole___elambda__1___closed__2;
@@ -1443,7 +1415,8 @@ lean_object* l_Lean_Parser_Term_explicitBinder___closed__2;
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_have___closed__1;
 lean_object* l_Lean_Parser_darrow___closed__2;
-lean_object* l_Lean_Parser_Term_show___elambda__1(lean_object*, lean_object*, lean_object*);
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+lean_object* l_Lean_Parser_Term_show___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_emptyC___elambda__1___closed__6;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_uminus(lean_object*);
 lean_object* l_Lean_Parser_Term_instBinder___elambda__1___closed__3;
@@ -1458,9 +1431,7 @@ lean_object* l_Lean_Parser_Term_sub___closed__3;
 lean_object* l_Lean_Parser_Term_typeSpec___closed__3;
 lean_object* l_Lean_Parser_Term_iff___closed__1;
 lean_object* l_Lean_Parser_Term_orelse___closed__3;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_fun___closed__3;
-lean_object* l_Lean_Parser_Term_sortApp___closed__5;
 lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_match___closed__9;
 lean_object* l_Lean_Parser_Term_tupleTail___closed__5;
@@ -1475,6 +1446,7 @@ lean_object* l_Lean_Parser_Term_fun___closed__5;
 lean_object* l_Lean_Parser_Term_seqRight___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_explicitUniv___closed__2;
 extern lean_object* l_Lean_Parser_epsilonInfo;
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_have___closed__4;
 lean_object* l_Lean_Parser_Term_mod___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_append___elambda__1___closed__2;
@@ -1483,22 +1455,22 @@ lean_object* l_Lean_Parser_Term_letIdDecl___closed__5;
 lean_object* l_Lean_Parser_Term_match___closed__4;
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Term_app___closed__5;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_explicitUniv___closed__1;
 lean_object* l_Lean_Parser_Term_where___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_typeAscription___closed__1;
 lean_object* l_Lean_Parser_Term_gt___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-lean_object* l_Lean_Parser_Term_letDecl___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_letDecl___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_letEqnsDecl___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_letIdLhs___closed__4;
-lean_object* l_Lean_Parser_Term_doLet___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_doLet___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__17;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
 extern lean_object* l_Lean_mkHole___closed__1;
 lean_object* l_Lean_Parser_Term_forall___closed__4;
 lean_object* l_Lean_Parser_Term_add___closed__1;
+lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_letIdDecl___closed__3;
 lean_object* l_Lean_Parser_Term_le___closed__2;
 lean_object* l_Lean_Parser_Term_match___closed__8;
@@ -1510,30 +1482,33 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_namedHole(lean_object*);
 lean_object* l_Lean_Parser_Term_type;
 lean_object* l_Lean_Parser_Term_pow___closed__1;
 extern lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__7;
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_binderType___closed__4;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_let___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_bne___closed__2;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_letIdDecl___closed__7;
-lean_object* l_Lean_Parser_Term_where___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_where___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_subtype___closed__10;
-lean_object* l_Lean_Parser_Term_append___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_append___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_tupleTail___closed__2;
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__12;
 lean_object* l_Lean_Parser_Term_dollar___closed__4;
 lean_object* l_Lean_Parser_Term_arrayRef___closed__1;
 lean_object* l_Lean_Parser_Term_fromTerm___closed__5;
+lean_object* l_Lean_Parser_dollarSymbol___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_mapConst___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_map___closed__2;
 lean_object* l_Lean_Parser_Term_or;
-lean_object* l_Lean_Parser_Term_orM___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_orM___elambda__1(lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_unicodeSymbolFn___closed__1;
 lean_object* l_Lean_Parser_Term_pow___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_binderDefault___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_id___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_id___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_cons___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__11;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_borrowed___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_if___closed__6;
 lean_object* l_Lean_Parser_Term_letIdDecl___closed__2;
@@ -1549,7 +1524,7 @@ lean_object* l_Lean_Parser_Term_uminus___closed__1;
 lean_object* l_Lean_Parser_Term_map___closed__1;
 lean_object* l_Lean_Parser_Term_doLet___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_subst___closed__2;
-lean_object* l_Lean_Parser_Term_arrayLit___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_arrayLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_and___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_match__syntax___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__1;
@@ -1562,27 +1537,27 @@ lean_object* l_Lean_Parser_Term_subst___closed__1;
 lean_object* l_Lean_Parser_Term_beq___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_binderDefault___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_haveAssign;
+lean_object* l_Lean_Parser_Term_dollar___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_explicit___closed__6;
 lean_object* l_Lean_Parser_Term_suffices___closed__5;
 lean_object* l_Lean_Parser_Term_parser_x21___closed__2;
 lean_object* l_Lean_Parser_Term_emptyC___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_typeSpec___closed__4;
 lean_object* l_Lean_Parser_Term_mapRev___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__1;
 lean_object* l_Lean_Parser_Term_hole;
 lean_object* l_Lean_Parser_Term_app___closed__1;
 lean_object* l_Lean_Parser_Term_emptyC___closed__5;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_if___closed__4;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__3;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__1;
-extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
 lean_object* l_Lean_Parser_Term_haveAssign___closed__5;
 lean_object* l_Lean_Parser_Term_letIdDecl___closed__1;
 lean_object* l_Lean_Parser_Term_arrayLit___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_sorry___elambda__1___closed__7;
+lean_object* l_Lean_Parser_Term_explicitBinder___closed__8;
 lean_object* l_Lean_Parser_Term_matchAlt___closed__2;
 lean_object* l_Lean_Parser_Term_parenSpecial___closed__2;
 lean_object* l_Lean_Parser_Term_arrayLit___elambda__1___closed__4;
@@ -1593,23 +1568,26 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_prop(lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_antiquot(lean_object*);
 lean_object* l_Lean_Parser_Term_doExpr___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_bindOp___elambda__1___closed__4;
-lean_object* l_Lean_Parser_darrow___elambda__1(lean_object*);
-extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__8;
+lean_object* l_Lean_Parser_Term_explicitBinder___closed__9;
+lean_object* l_Lean_Parser_darrow___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_pow___closed__3;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10(lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_not___closed__8;
 lean_object* l_Lean_Parser_Term_implicitBinder___boxed(lean_object*);
 lean_object* l_Lean_Parser_Term_mapConst___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_if___closed__9;
+lean_object* l_Lean_Parser_nodeFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doLet___closed__1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_modN(lean_object*);
 lean_object* l_Lean_Parser_Term_typeSpec___closed__1;
 lean_object* l_Lean_Parser_Term_namedPattern___closed__8;
 lean_object* l_Lean_Parser_Term_parser_x21___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_proj___elambda__1___closed__6;
+lean_object* l_Lean_Parser_optionalFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_namedArgument___closed__6;
 lean_object* l_Lean_Parser_Term_implicitBinder___closed__1;
 lean_object* l_Lean_Parser_Term_tparser_x21___closed__4;
+extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_doExpr___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_typeAscription___closed__2;
 lean_object* l_Lean_Parser_Term_seq___closed__3;
@@ -1623,10 +1601,10 @@ lean_object* l_Lean_Parser_Term_implicitBinder___closed__2;
 lean_object* l_Lean_Parser_Term_explicitBinder___closed__4;
 lean_object* l_Lean_Parser_Term_andM___closed__3;
 lean_object* l_Lean_Parser_Term_band___closed__2;
-lean_object* l_Lean_Parser_Term_mapConstRev___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_mapConstRev___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_instBinder___closed__4;
 lean_object* l_Lean_Parser_Term_leftArrow___closed__2;
-lean_object* l_Lean_Parser_Term_ne___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_ne___elambda__1(lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_heq___closed__1;
@@ -1638,35 +1616,34 @@ lean_object* l_Lean_Parser_Term_checkIsSort___closed__2;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
 lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_parser_x21___closed__4;
-lean_object* l_Lean_Parser_Term_orelse___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_orelse___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_div(lean_object*);
 lean_object* l_Lean_Parser_Term_subtype___closed__9;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_where___closed__1;
-lean_object* l_Lean_Parser_Term_namedPattern___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_le___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_namedPattern___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_le___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_fcomp___closed__3;
 lean_object* l_Lean_Parser_Term_doLet___closed__2;
 extern lean_object* l_Lean_mkHole___closed__2;
 lean_object* l_Lean_Parser_Term_type___closed__5;
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__1;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__10;
 lean_object* l_Lean_Parser_Term_unicodeInfixR___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__2;
 lean_object* l_Lean_Parser_Term_andthen___closed__1;
 lean_object* l_Lean_Parser_Term_and___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_inaccessible___elambda__1___closed__6;
+lean_object* l_Lean_Parser_nameLit___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_equiv___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Term_letPatDecl___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_letPatDecl___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_letIdDecl___closed__8;
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_binderType___closed__6;
-lean_object* l_Lean_Parser_Term_typeSpec___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_typeSpec___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_haveAssign___closed__3;
 lean_object* l_Lean_Parser_Term_typeSpec___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_forall___closed__5;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18(lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_pow;
 lean_object* l_Lean_Parser_Term_letIdDecl___closed__4;
 lean_object* l_Lean_Parser_Term_leftArrow___closed__1;
@@ -1677,9 +1654,9 @@ lean_object* l_Lean_Parser_Term_do___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_doLet___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_namedHole___closed__6;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_listLit(lean_object*);
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6(lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_type___elambda__1___closed__6;
-lean_object* l_Lean_Parser_mkAntiquot(uint8_t, lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_Parser_mkAntiquot(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Parser_Term_dollarProj___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_explicit;
 lean_object* l_Lean_Parser_Term_match__syntax___elambda__1___closed__7;
@@ -1689,34 +1666,34 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_sortApp(lean_object*);
 lean_object* l_Lean_Parser_Term_typeAscription___closed__6;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__3;
 lean_object* l_Lean_Parser_Term_lt;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_simpleBinder___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_matchAlts___closed__5;
 lean_object* l_Lean_Parser_Term_bor___elambda__1___closed__4;
-lean_object* l_Lean_Parser_Term_doId___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_mapConst___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_doId___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_mapConst___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_letIdDecl___closed__9;
 lean_object* l_Lean_Parser_Term_hole___closed__3;
 lean_object* l_Lean_Parser_Term_structInstSource___elambda__1___closed__3;
+lean_object* l_Lean_Parser_unicodeSymbolFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_namedHole___closed__2;
 lean_object* l_Lean_Parser_Term_structInstField___closed__3;
 lean_object* l_Lean_Parser_Term_parser_x21___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__12;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_seqRight___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_seqRight___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_match(lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_depArrow(lean_object*);
 lean_object* l_Lean_Parser_Term_simpleBinder___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_structInstSource___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_bne___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_optIdent___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_optIdent___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_gt___closed__1;
 lean_object* l_Lean_Parser_Term_ge;
 lean_object* l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__3;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2(uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2(uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_have___closed__5;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_where(lean_object*);
-lean_object* l_Lean_Parser_Term_depArrow___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_depArrow___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_gt___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_typeSpec___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__4;
@@ -1732,7 +1709,7 @@ lean_object* l_Lean_Parser_Term_infixR___boxed(lean_object*, lean_object*);
 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_paren___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_explicitUniv___closed__11;
 lean_object* l_Lean_Parser_Term_arrayLit___closed__1;
 lean_object* l_Lean_Parser_Term_nomatch___closed__5;
@@ -1743,13 +1720,12 @@ lean_object* l_Lean_Parser_Term_structInstSource___elambda__1___closed__2;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_hole(lean_object*);
 lean_object* l_Lean_Parser_Term_iff___closed__2;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__12;
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_fcomp___closed__2;
 lean_object* l_Lean_Parser_Term_where___closed__3;
 lean_object* l_Lean_Parser_Term_map___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_sort___elambda__1___closed__9;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_gt(lean_object*);
-lean_object* l_Lean_Parser_Term_app___elambda__1___boxed(lean_object*, lean_object*, lean_object*);
 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;
@@ -1766,33 +1742,30 @@ lean_object* l_Lean_Parser_Term_mapRev___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_uminus___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_bindOp___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_suffices;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_mapConstRev;
 lean_object* l_Lean_Parser_Term_iff;
 lean_object* l_Lean_Parser_Term_iff___elambda__1___closed__5;
-lean_object* l_Lean_Parser_many1Fn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_many1Fn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_letIdLhs;
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_namedHole___closed__4;
 lean_object* l_Lean_Parser_Term_show___elambda__1___closed__9;
 lean_object* l_Lean_Parser_Term_subtype___closed__8;
-lean_object* l_Lean_Parser_Term_num___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_num___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_subtype___elambda__1___closed__7;
-lean_object* l_Lean_Parser_Term_cons___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_cons___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_sort___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_eq___closed__3;
 lean_object* l_Lean_Parser_Term_add;
-lean_object* l_Lean_Parser_Term_inaccessible___elambda__1(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Parser_mkAntiquotAux___closed__21;
+lean_object* l_Lean_Parser_Term_inaccessible___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_namedPattern___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__5;
-lean_object* l_Lean_Parser_Term_proj___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_proj___elambda__1(lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_char(lean_object*);
 lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__3;
-lean_object* l_Lean_Parser_Term_let___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_let___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__8;
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__6;
 lean_object* l_Lean_Parser_ParserState_mkUnexpectedError(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_subtype___closed__4;
 lean_object* l_Lean_Parser_Term_nomatch___closed__3;
@@ -1803,8 +1776,8 @@ lean_object* l_Lean_Parser_Term_structInst;
 lean_object* l_Lean_Parser_Term_dollarProj___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_show___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_ne;
-lean_object* l_Lean_Parser_Term_match___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Term_binderIdent___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_match___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_binderIdent___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_char___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_borrowed___elambda__1___closed__6;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_borrowed(lean_object*);
@@ -1815,11 +1788,10 @@ lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_sub;
 lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_do___closed__5;
-lean_object* l_Lean_Parser_darrow___elambda__1___rarg___closed__9;
 lean_object* l_Lean_Parser_Term_bne___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_mapConstRev___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_have___elambda__1___closed__13;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_dollar___closed__1;
 lean_object* l_Lean_Parser_Term_doExpr___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_char___elambda__1___closed__4;
@@ -1828,13 +1800,12 @@ lean_object* l_Lean_Parser_Term_map___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_matchAlt___closed__6;
 lean_object* l_Lean_Parser_Term_parenSpecial___closed__4;
 lean_object* l_Lean_Parser_Term_modN___elambda__1___closed__1;
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8(lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__9;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_or(lean_object*);
 lean_object* l_Lean_Parser_Term_iff___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_antiquot___closed__1;
 lean_object* l_Lean_Parser_Term_doPat___closed__5;
-lean_object* l_Lean_Parser_categoryParser___elambda__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_binderDefault___closed__3;
 lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__6;
@@ -1845,7 +1816,7 @@ lean_object* l_Lean_Parser_Term_mapConstRev___closed__1;
 lean_object* l_Lean_Parser_Term_sorry___elambda__1___closed__5;
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_bindOp___elambda__1___closed__2;
-lean_object* l_Lean_Parser_Term_do___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_do___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_letDecl___closed__3;
 lean_object* l_Lean_Parser_Term_namedHole___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_subtype___elambda__1___closed__3;
@@ -1866,26 +1837,27 @@ lean_object* l_Lean_Parser_Term_doExpr;
 lean_object* l_Lean_Parser_Term_orelse___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_suffices___closed__6;
 lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+lean_object* l_Lean_Parser_Term_sortApp___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_depArrow___closed__7;
 lean_object* l_Lean_Parser_Term_seq___closed__1;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_paren(lean_object*);
 lean_object* l___regBuiltinParser_Lean_Parser_Term_if(lean_object*);
 lean_object* l_Lean_Parser_Term_arrow___closed__3;
 lean_object* l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__6;
-lean_object* l_Lean_Parser_Term_fromTerm___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_fromTerm___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_andM___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_doExpr___closed__3;
 lean_object* l_Lean_Parser_Term_binderTactic___closed__3;
 lean_object* l_Lean_Parser_Term_doId___closed__6;
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1(lean_object*);
-lean_object* l_Lean_Parser_Term_unicodeInfixR___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_unicodeInfixR___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_emptyC___elambda__1___closed__7;
-lean_object* l_Lean_Parser_Term_unicodeInfixL___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_dollar___elambda__1___closed__2;
+lean_object* l_Lean_Parser_Term_unicodeInfixL___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_subtype___closed__11;
 lean_object* l_Lean_Parser_unicodeSymbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
 lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__7;
 lean_object* l_Lean_Parser_Term_namedArgument___closed__4;
 lean_object* l_Lean_Parser_Term_dollar___closed__2;
@@ -1893,12 +1865,12 @@ extern lean_object* l_addParenHeuristic___closed__1;
 lean_object* l_Lean_Parser_Term_borrowed___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_instBinder___closed__6;
 lean_object* l_Lean_Parser_Term_bnot___elambda__1___closed__7;
-lean_object* l_Lean_Parser_strLit(uint8_t);
-lean_object* l_Lean_Parser_Term_sortApp___elambda__1___rarg(lean_object*, lean_object*);
+extern lean_object* l_Lean_Parser_strLit;
 lean_object* l_Lean_Parser_Term_equiv___elambda__1___closed__3;
+lean_object* l_Lean_Parser_Term_dollar___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_char___elambda__1___closed__1;
-lean_object* l_Lean_Parser_Term_bnot___elambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_bnot___elambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_let;
 lean_object* l_Lean_Parser_Term_depArrow___closed__3;
 lean_object* l_Lean_Parser_Term_namedHole___closed__1;
@@ -1911,7 +1883,6 @@ lean_object* l_Lean_Parser_Term_modN___closed__1;
 lean_object* l_Lean_Parser_Term_band___closed__1;
 lean_object* l_Lean_Parser_Term_parser_x21___closed__6;
 lean_object* l_Lean_Parser_Term_seq___closed__2;
-lean_object* l_Lean_Parser_Term_binderType___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_listLit___elambda__1___closed__6;
 lean_object* l_Lean_Parser_Term_char___elambda__1___closed__3;
 extern lean_object* l_Lean_Parser_Level_paren___closed__1;
@@ -1922,25 +1893,26 @@ lean_object* l_Lean_Parser_Term_typeSpec___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_hole___closed__1;
 lean_object* l_Lean_Parser_Term_match___elambda__1___closed__13;
 lean_object* l_Lean_Parser_Term_letEqnsDecl___closed__4;
-lean_object* l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__1;
-lean_object* l_Lean_Parser_Term_prop___elambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Term_prop___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_inaccessible___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Term_borrowed___closed__1;
-lean_object* l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2;
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_suffices___closed__3;
+lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_arrayLit___elambda__1___closed__1;
 lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__8;
 lean_object* l_Lean_Parser_Term_app___closed__3;
 lean_object* l_Lean_Parser_Term_tparser_x21;
+extern lean_object* l_Lean_Parser_Level_max___closed__2;
 lean_object* l_Lean_Parser_Term_binderTactic___closed__5;
 lean_object* l_Lean_Parser_Term_doId___elambda__1___closed__3;
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_proj___elambda__1___closed__3;
 lean_object* l_Lean_Parser_Term_letIdDecl___closed__6;
 lean_object* l_Lean_Parser_Term_app___closed__4;
-lean_object* _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__1() {
+lean_object* l_Lean_Parser_andthenFn(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* _init_l_Lean_Parser_darrow___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1948,16 +1920,16 @@ x_1 = lean_mk_string("⇒");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_darrow___elambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_darrow___elambda__1___rarg___closed__1;
+x_1 = l_Lean_Parser_darrow___elambda__1___closed__1;
 x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__3() {
+lean_object* _init_l_Lean_Parser_darrow___elambda__1___closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -1965,93 +1937,85 @@ x_1 = lean_mk_string("=>");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__4() {
+lean_object* _init_l_Lean_Parser_darrow___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_darrow___elambda__1___rarg___closed__3;
+x_1 = l_Lean_Parser_darrow___elambda__1___closed__3;
 x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__5() {
+lean_object* _init_l_Lean_Parser_darrow___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_darrow___elambda__1___rarg___closed__2;
+x_2 = l_Lean_Parser_darrow___elambda__1___closed__2;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__6() {
+lean_object* _init_l_Lean_Parser_darrow___elambda__1___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_darrow___elambda__1___rarg___closed__5;
-x_2 = l_Lean_Parser_unicodeSymbolFn___rarg___closed__1;
+x_1 = l_Lean_Parser_darrow___elambda__1___closed__5;
+x_2 = l_Lean_Parser_unicodeSymbolFn___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__7() {
+lean_object* _init_l_Lean_Parser_darrow___elambda__1___closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_darrow___elambda__1___rarg___closed__6;
-x_2 = l_Lean_Parser_darrow___elambda__1___rarg___closed__4;
+x_1 = l_Lean_Parser_darrow___elambda__1___closed__6;
+x_2 = l_Lean_Parser_darrow___elambda__1___closed__4;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__8() {
+lean_object* _init_l_Lean_Parser_darrow___elambda__1___closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_darrow___elambda__1___rarg___closed__7;
+x_1 = l_Lean_Parser_darrow___elambda__1___closed__7;
 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_darrow___elambda__1___rarg___closed__9() {
+lean_object* _init_l_Lean_Parser_darrow___elambda__1___closed__9() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_darrow___elambda__1___rarg___closed__8;
+x_2 = l_Lean_Parser_darrow___elambda__1___closed__8;
 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* l_Lean_Parser_darrow___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_darrow___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_3 = l_Lean_Parser_darrow___elambda__1___rarg___closed__2;
-x_4 = l_Lean_Parser_darrow___elambda__1___rarg___closed__4;
-x_5 = l_Lean_Parser_darrow___elambda__1___rarg___closed__9;
+x_3 = l_Lean_Parser_darrow___elambda__1___closed__2;
+x_4 = l_Lean_Parser_darrow___elambda__1___closed__4;
+x_5 = l_Lean_Parser_darrow___elambda__1___closed__9;
 x_6 = l_Lean_Parser_unicodeSymbolFnAux(x_3, x_4, x_5, x_1, x_2);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_darrow___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_darrow___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_darrow___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_darrow___elambda__1___rarg___closed__2;
-x_3 = l_Lean_Parser_darrow___elambda__1___rarg___closed__4;
+x_2 = l_Lean_Parser_darrow___elambda__1___closed__2;
+x_3 = l_Lean_Parser_darrow___elambda__1___closed__4;
 x_4 = l_Lean_Parser_unicodeSymbolInfo(x_2, x_3, x_1);
 return x_4;
 }
@@ -2060,7 +2024,7 @@ lean_object* _init_l_Lean_Parser_darrow___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_darrow___elambda__1___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_darrow___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -2084,44 +2048,33 @@ x_1 = l_Lean_Parser_darrow___closed__3;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_darrow___elambda__1___boxed(lean_object* x_1) {
+lean_object* l_Lean_Parser_Term_unicodeInfixR___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_2; 
-x_2 = l_Lean_Parser_darrow___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Term_unicodeInfixR___elambda__1(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; lean_object* x_7; 
-lean_inc(x_4);
+lean_object* x_5; lean_object* x_6; 
 lean_inc(x_3);
-x_6 = lean_apply_3(x_1, x_3, x_4, x_5);
-x_7 = lean_ctor_get(x_6, 3);
-lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
+x_5 = lean_apply_2(x_1, x_3, x_4);
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
 {
-lean_object* x_8; 
-x_8 = lean_apply_3(x_2, x_3, x_4, x_6);
-return x_8;
+lean_object* x_7; 
+x_7 = lean_apply_2(x_2, x_3, x_5);
+return x_7;
 }
 else
 {
-lean_dec(x_7);
-lean_dec(x_4);
+lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-return x_6;
+return x_5;
 }
 }
 }
 lean_object* l_Lean_Parser_Term_unicodeInfixR(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; uint8_t 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_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_inc(x_3);
 x_4 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_4, 0, x_3);
@@ -2130,30 +2083,29 @@ x_6 = l_String_trim(x_2);
 lean_inc(x_6);
 lean_inc(x_5);
 x_7 = l_Lean_Parser_unicodeSymbolInfo(x_5, x_6, x_4);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___rarg___boxed), 5, 2);
+x_8 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___boxed), 4, 2);
 lean_closure_set(x_8, 0, x_5);
 lean_closure_set(x_8, 1, x_6);
 x_9 = lean_unsigned_to_nat(1u);
 x_10 = lean_nat_sub(x_3, x_9);
 lean_dec(x_3);
-x_11 = 1;
-x_12 = l_Lean_Parser_termParser___closed__2;
+x_11 = l_Lean_Parser_termParser___closed__2;
 lean_inc(x_10);
-x_13 = l_Lean_Parser_categoryParser(x_11, x_12, x_10);
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = l_Lean_Parser_andthenInfo(x_7, x_14);
-x_16 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1___rarg___boxed), 5, 2);
-lean_closure_set(x_16, 0, x_12);
-lean_closure_set(x_16, 1, x_10);
-x_17 = lean_alloc_closure((void*)(l_Lean_Parser_Term_unicodeInfixR___elambda__1), 5, 2);
-lean_closure_set(x_17, 0, x_8);
-lean_closure_set(x_17, 1, x_16);
-x_18 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_18, 0, x_15);
-lean_ctor_set(x_18, 1, x_17);
-return x_18;
+x_12 = l_Lean_Parser_categoryParser(x_11, x_10);
+x_13 = lean_ctor_get(x_12, 0);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_andthenInfo(x_7, x_13);
+x_15 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 2);
+lean_closure_set(x_15, 0, x_11);
+lean_closure_set(x_15, 1, x_10);
+x_16 = lean_alloc_closure((void*)(l_Lean_Parser_Term_unicodeInfixR___elambda__1), 4, 2);
+lean_closure_set(x_16, 0, x_8);
+lean_closure_set(x_16, 1, x_15);
+x_17 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_17, 0, x_14);
+lean_ctor_set(x_17, 1, x_16);
+return x_17;
 }
 }
 lean_object* l_Lean_Parser_Term_unicodeInfixR___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
@@ -2166,64 +2118,61 @@ lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_infixR___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_Term_infixR___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; 
-lean_inc(x_4);
+lean_object* x_5; lean_object* x_6; 
 lean_inc(x_3);
-x_6 = lean_apply_3(x_1, x_3, x_4, x_5);
-x_7 = lean_ctor_get(x_6, 3);
-lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
+x_5 = lean_apply_2(x_1, x_3, x_4);
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
 {
-lean_object* x_8; 
-x_8 = lean_apply_3(x_2, x_3, x_4, x_6);
-return x_8;
+lean_object* x_7; 
+x_7 = lean_apply_2(x_2, x_3, x_5);
+return x_7;
 }
 else
 {
-lean_dec(x_7);
-lean_dec(x_4);
+lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-return x_6;
+return x_5;
 }
 }
 }
 lean_object* l_Lean_Parser_Term_infixR(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t 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_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_inc(x_2);
 x_3 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_3, 0, x_2);
 x_4 = l_String_trim(x_1);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_symbolInfo(x_4, x_3);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
 lean_closure_set(x_6, 0, x_4);
 x_7 = lean_unsigned_to_nat(1u);
 x_8 = lean_nat_sub(x_2, x_7);
 lean_dec(x_2);
-x_9 = 1;
-x_10 = l_Lean_Parser_termParser___closed__2;
+x_9 = l_Lean_Parser_termParser___closed__2;
 lean_inc(x_8);
-x_11 = l_Lean_Parser_categoryParser(x_9, x_10, x_8);
-x_12 = lean_ctor_get(x_11, 0);
-lean_inc(x_12);
-lean_dec(x_11);
-x_13 = l_Lean_Parser_andthenInfo(x_5, x_12);
-x_14 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1___rarg___boxed), 5, 2);
-lean_closure_set(x_14, 0, x_10);
-lean_closure_set(x_14, 1, x_8);
-x_15 = lean_alloc_closure((void*)(l_Lean_Parser_Term_infixR___elambda__1), 5, 2);
-lean_closure_set(x_15, 0, x_6);
-lean_closure_set(x_15, 1, x_14);
-x_16 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_16, 0, x_13);
-lean_ctor_set(x_16, 1, x_15);
-return x_16;
+x_10 = l_Lean_Parser_categoryParser(x_9, x_8);
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = l_Lean_Parser_andthenInfo(x_5, x_11);
+x_13 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 2);
+lean_closure_set(x_13, 0, x_9);
+lean_closure_set(x_13, 1, x_8);
+x_14 = lean_alloc_closure((void*)(l_Lean_Parser_Term_infixR___elambda__1), 4, 2);
+lean_closure_set(x_14, 0, x_6);
+lean_closure_set(x_14, 1, x_13);
+x_15 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_15, 0, x_12);
+lean_ctor_set(x_15, 1, x_14);
+return x_15;
 }
 }
 lean_object* l_Lean_Parser_Term_infixR___boxed(lean_object* x_1, lean_object* x_2) {
@@ -2235,35 +2184,33 @@ lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_unicodeInfixL___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_Term_unicodeInfixL___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; 
-lean_inc(x_4);
+lean_object* x_5; lean_object* x_6; 
 lean_inc(x_3);
-x_6 = lean_apply_3(x_1, x_3, x_4, x_5);
-x_7 = lean_ctor_get(x_6, 3);
-lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
+x_5 = lean_apply_2(x_1, x_3, x_4);
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
 {
-lean_object* x_8; 
-x_8 = lean_apply_3(x_2, x_3, x_4, x_6);
-return x_8;
+lean_object* x_7; 
+x_7 = lean_apply_2(x_2, x_3, x_5);
+return x_7;
 }
 else
 {
-lean_dec(x_7);
-lean_dec(x_4);
+lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-return x_6;
+return x_5;
 }
 }
 }
 lean_object* l_Lean_Parser_Term_unicodeInfixL(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; uint8_t 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_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_inc(x_3);
 x_4 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_4, 0, x_3);
@@ -2272,27 +2219,26 @@ x_6 = l_String_trim(x_2);
 lean_inc(x_6);
 lean_inc(x_5);
 x_7 = l_Lean_Parser_unicodeSymbolInfo(x_5, x_6, x_4);
-x_8 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___rarg___boxed), 5, 2);
+x_8 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___boxed), 4, 2);
 lean_closure_set(x_8, 0, x_5);
 lean_closure_set(x_8, 1, x_6);
-x_9 = 1;
-x_10 = l_Lean_Parser_termParser___closed__2;
+x_9 = l_Lean_Parser_termParser___closed__2;
 lean_inc(x_3);
-x_11 = l_Lean_Parser_categoryParser(x_9, x_10, x_3);
-x_12 = lean_ctor_get(x_11, 0);
-lean_inc(x_12);
-lean_dec(x_11);
-x_13 = l_Lean_Parser_andthenInfo(x_7, x_12);
-x_14 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1___rarg___boxed), 5, 2);
-lean_closure_set(x_14, 0, x_10);
-lean_closure_set(x_14, 1, x_3);
-x_15 = lean_alloc_closure((void*)(l_Lean_Parser_Term_unicodeInfixL___elambda__1), 5, 2);
-lean_closure_set(x_15, 0, x_8);
-lean_closure_set(x_15, 1, x_14);
-x_16 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_16, 0, x_13);
-lean_ctor_set(x_16, 1, x_15);
-return x_16;
+x_10 = l_Lean_Parser_categoryParser(x_9, x_3);
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = l_Lean_Parser_andthenInfo(x_7, x_11);
+x_13 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 2);
+lean_closure_set(x_13, 0, x_9);
+lean_closure_set(x_13, 1, x_3);
+x_14 = lean_alloc_closure((void*)(l_Lean_Parser_Term_unicodeInfixL___elambda__1), 4, 2);
+lean_closure_set(x_14, 0, x_8);
+lean_closure_set(x_14, 1, x_13);
+x_15 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_15, 0, x_12);
+lean_ctor_set(x_15, 1, x_14);
+return x_15;
 }
 }
 lean_object* l_Lean_Parser_Term_unicodeInfixL___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
@@ -2305,61 +2251,58 @@ lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_infixL___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_Term_infixL___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; 
-lean_inc(x_4);
+lean_object* x_5; lean_object* x_6; 
 lean_inc(x_3);
-x_6 = lean_apply_3(x_1, x_3, x_4, x_5);
-x_7 = lean_ctor_get(x_6, 3);
-lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
+x_5 = lean_apply_2(x_1, x_3, x_4);
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
 {
-lean_object* x_8; 
-x_8 = lean_apply_3(x_2, x_3, x_4, x_6);
-return x_8;
+lean_object* x_7; 
+x_7 = lean_apply_2(x_2, x_3, x_5);
+return x_7;
 }
 else
 {
-lean_dec(x_7);
-lean_dec(x_4);
+lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_2);
-return x_6;
+return x_5;
 }
 }
 }
 lean_object* l_Lean_Parser_Term_infixL(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t 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_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_inc(x_2);
 x_3 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_3, 0, x_2);
 x_4 = l_String_trim(x_1);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_symbolInfo(x_4, x_3);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
+x_6 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
 lean_closure_set(x_6, 0, x_4);
-x_7 = 1;
-x_8 = l_Lean_Parser_termParser___closed__2;
+x_7 = l_Lean_Parser_termParser___closed__2;
 lean_inc(x_2);
-x_9 = l_Lean_Parser_categoryParser(x_7, x_8, x_2);
-x_10 = lean_ctor_get(x_9, 0);
-lean_inc(x_10);
-lean_dec(x_9);
-x_11 = l_Lean_Parser_andthenInfo(x_5, x_10);
-x_12 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1___rarg___boxed), 5, 2);
-lean_closure_set(x_12, 0, x_8);
-lean_closure_set(x_12, 1, x_2);
-x_13 = lean_alloc_closure((void*)(l_Lean_Parser_Term_infixL___elambda__1), 5, 2);
-lean_closure_set(x_13, 0, x_6);
-lean_closure_set(x_13, 1, x_12);
-x_14 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_14, 0, x_11);
-lean_ctor_set(x_14, 1, x_13);
-return x_14;
+x_8 = l_Lean_Parser_categoryParser(x_7, x_2);
+x_9 = lean_ctor_get(x_8, 0);
+lean_inc(x_9);
+lean_dec(x_8);
+x_10 = l_Lean_Parser_andthenInfo(x_5, x_9);
+x_11 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 2);
+lean_closure_set(x_11, 0, x_7);
+lean_closure_set(x_11, 1, x_2);
+x_12 = lean_alloc_closure((void*)(l_Lean_Parser_Term_infixL___elambda__1), 4, 2);
+lean_closure_set(x_12, 0, x_6);
+lean_closure_set(x_12, 1, x_11);
+x_13 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_13, 0, x_10);
+lean_ctor_set(x_13, 1, x_12);
+return x_13;
 }
 }
 lean_object* l_Lean_Parser_Term_infixL___boxed(lean_object* x_1, lean_object* x_2) {
@@ -2412,215 +2355,215 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-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; 
-x_9 = lean_ctor_get(x_8, 0);
+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; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
+x_10 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
+x_11 = lean_unsigned_to_nat(0u);
+lean_inc(x_5);
+x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_5, x_6);
+x_13 = lean_ctor_get(x_12, 3);
+lean_inc(x_13);
+if (lean_obj_tag(x_13) == 0)
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_31; lean_object* x_32; 
 lean_dec(x_9);
-x_11 = lean_ctor_get(x_8, 1);
-lean_inc(x_11);
-x_12 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_13 = lean_unsigned_to_nat(0u);
-lean_inc(x_7);
-x_14 = l_Lean_Parser_categoryParserFn(x_12, x_13, x_7, x_8);
-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_33; lean_object* x_34; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_16 = lean_ctor_get(x_14, 0);
+lean_dec(x_8);
+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 = lean_ctor_get(x_12, 1);
 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_inc(x_18);
-lean_inc(x_7);
-x_33 = l_Lean_Parser_tokenFn(x_7, x_14);
-x_34 = lean_ctor_get(x_33, 3);
-lean_inc(x_34);
-if (lean_obj_tag(x_34) == 0)
+lean_inc(x_5);
+x_31 = l_Lean_Parser_tokenFn(x_5, x_12);
+x_32 = lean_ctor_get(x_31, 3);
+lean_inc(x_32);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_35; lean_object* x_36; 
-x_35 = lean_ctor_get(x_33, 0);
+lean_object* x_33; lean_object* x_34; 
+x_33 = lean_ctor_get(x_31, 0);
+lean_inc(x_33);
+x_34 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_33);
+lean_dec(x_33);
+if (lean_obj_tag(x_34) == 2)
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = lean_ctor_get(x_34, 1);
 lean_inc(x_35);
-x_36 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_35);
+lean_dec(x_34);
+x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_37 = lean_string_dec_eq(x_35, x_36);
 lean_dec(x_35);
-if (lean_obj_tag(x_36) == 2)
+if (x_37 == 0)
 {
-lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_37 = lean_ctor_get(x_36, 1);
-lean_inc(x_37);
-lean_dec(x_36);
-x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_39 = lean_string_dec_eq(x_37, x_38);
-lean_dec(x_37);
-if (x_39 == 0)
-{
-lean_object* x_40; lean_object* x_41; 
-x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_18);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_18);
-x_19 = x_41;
-goto block_32;
+lean_object* x_38; lean_object* x_39; 
+x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_16);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_16);
+x_17 = x_39;
+goto block_30;
 }
 else
 {
-x_19 = x_33;
-goto block_32;
+x_17 = x_31;
+goto block_30;
+}
+}
+else
+{
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_34);
+x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_16);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_16);
+x_17 = x_41;
+goto block_30;
 }
 }
 else
 {
 lean_object* x_42; lean_object* x_43; 
-lean_dec(x_36);
+lean_dec(x_32);
 x_42 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_16);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_16);
+x_17 = x_43;
+goto block_30;
+}
+block_30:
+{
+lean_object* x_18; 
+x_18 = lean_ctor_get(x_17, 3);
 lean_inc(x_18);
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_42, x_18);
-x_19 = x_43;
-goto block_32;
-}
-}
-else
+if (lean_obj_tag(x_18) == 0)
 {
-lean_object* x_44; lean_object* x_45; 
-lean_dec(x_34);
-x_44 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_18);
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_44, x_18);
-x_19 = x_45;
-goto block_32;
-}
-block_32:
+lean_dec(x_16);
+lean_dec(x_15);
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_dec(x_18);
-lean_dec(x_17);
-{
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_19;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_17;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
-lean_dec(x_20);
-lean_dec(x_7);
-x_22 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
-lean_dec(x_17);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+lean_dec(x_18);
+lean_dec(x_5);
+x_20 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
+lean_dec(x_15);
+x_21 = lean_ctor_get(x_20, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_nat_sub(x_22, x_2);
+lean_dec(x_22);
+x_24 = lean_unsigned_to_nat(1u);
+x_25 = lean_nat_dec_eq(x_23, x_24);
 lean_dec(x_23);
-x_25 = lean_nat_sub(x_24, x_3);
-lean_dec(x_24);
-x_26 = lean_unsigned_to_nat(1u);
-x_27 = lean_nat_dec_eq(x_25, x_26);
-lean_dec(x_25);
-if (x_27 == 0)
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; 
+x_26 = l_Lean_nullKind;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_2);
+return x_27;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_28; lean_object* x_29; 
 x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_3);
+x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_2);
 return x_29;
 }
 else
 {
+lean_dec(x_2);
+return x_20;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_13);
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Lean_nullKind;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_3);
-return x_31;
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_44 = lean_box(0);
+x_45 = l_Lean_Parser_ParserState_pushSyntax(x_12, x_44);
+x_46 = l_Lean_nullKind;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_2);
+return x_47;
 }
 else
 {
-lean_dec(x_3);
-return x_22;
-}
-}
-}
-}
-}
-else
-{
-lean_dec(x_15);
-lean_dec(x_7);
-if (x_5 == 0)
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_46 = lean_box(0);
-x_47 = l_Lean_Parser_ParserState_pushSyntax(x_14, x_46);
-x_48 = l_Lean_nullKind;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_3);
-return x_49;
-}
-else
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_50 = l_Lean_Parser_ParserState_restore(x_14, x_10, x_11);
-lean_dec(x_10);
-x_51 = lean_ctor_get(x_50, 0);
-lean_inc(x_51);
-x_52 = lean_array_get_size(x_51);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
+x_48 = l_Lean_Parser_ParserState_restore(x_12, x_8, x_9);
+lean_dec(x_8);
+x_49 = lean_ctor_get(x_48, 0);
+lean_inc(x_49);
+x_50 = lean_array_get_size(x_49);
+lean_dec(x_49);
+x_51 = lean_nat_sub(x_50, x_2);
+lean_dec(x_50);
+x_52 = lean_unsigned_to_nat(2u);
+x_53 = lean_nat_dec_eq(x_51, x_52);
 lean_dec(x_51);
-x_53 = lean_nat_sub(x_52, x_3);
-lean_dec(x_52);
-x_54 = lean_unsigned_to_nat(2u);
-x_55 = lean_nat_dec_eq(x_53, x_54);
-lean_dec(x_53);
-if (x_55 == 0)
+if (x_53 == 0)
+{
+lean_object* x_54; lean_object* x_55; 
+x_54 = l_Lean_nullKind;
+x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_2);
+return x_55;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_56; lean_object* x_57; 
 x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_50, x_56, x_3);
+x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_2);
 return x_57;
 }
 else
 {
-if (x_4 == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-x_58 = l_Lean_nullKind;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_50, x_58, x_3);
-return x_59;
-}
-else
-{
-lean_object* x_60; 
-lean_dec(x_3);
-x_60 = l_Lean_Parser_ParserState_popSyntax(x_50);
-return x_60;
+lean_object* x_58; 
+lean_dec(x_2);
+x_58 = l_Lean_Parser_ParserState_popSyntax(x_48);
+return x_58;
 }
 }
 }
 }
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = 0;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2(x_1, x_2, x_8, x_3, x_9, x_4, x_5, x_6);
-return x_10;
+lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = 0;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2(x_1, x_6, x_2, x_7, x_3, x_4);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_explicitUniv___elambda__1___closed__1() {
@@ -2654,13 +2597,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_explicitUniv___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_explicitUniv___elambda__1___closed__5() {
@@ -2761,234 +2703,228 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__8;
-x_7 = l_Lean_Parser_checkNoWsBeforeFn(x_6, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__8;
+x_6 = l_Lean_Parser_checkNoWsBeforeFn(x_5, x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_9 = lean_ctor_get(x_7, 0);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
-lean_dec(x_9);
-x_11 = lean_ctor_get(x_7, 1);
-lean_inc(x_11);
-lean_inc(x_2);
+x_9 = lean_array_get_size(x_8);
+lean_dec(x_8);
+x_10 = lean_ctor_get(x_6, 1);
+lean_inc(x_10);
 lean_inc(x_1);
-x_12 = lean_apply_3(x_5, x_1, x_2, x_7);
-x_13 = lean_ctor_get(x_12, 3);
+x_11 = lean_apply_2(x_4, x_1, x_6);
+x_12 = lean_ctor_get(x_11, 3);
+lean_inc(x_12);
+if (lean_obj_tag(x_12) == 0)
+{
+lean_dec(x_10);
+lean_dec(x_9);
+lean_dec(x_1);
+return x_11;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; uint8_t x_15; 
+x_13 = lean_ctor_get(x_12, 0);
 lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
-{
-lean_dec(x_11);
-lean_dec(x_10);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_12;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_14 = lean_ctor_get(x_13, 0);
+lean_dec(x_12);
+x_14 = lean_ctor_get(x_11, 1);
 lean_inc(x_14);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_12, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_15, x_11);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+x_15 = lean_nat_dec_eq(x_14, x_10);
 lean_dec(x_14);
-lean_dec(x_11);
+if (x_15 == 0)
+{
+lean_dec(x_13);
 lean_dec(x_10);
-lean_dec(x_2);
+lean_dec(x_9);
 lean_dec(x_1);
-return x_12;
+return x_11;
 }
 else
 {
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_59; lean_object* x_60; 
-lean_inc(x_11);
-x_17 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_11);
-lean_dec(x_10);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_array_get_size(x_18);
-lean_dec(x_18);
-lean_inc(x_2);
-x_59 = l_Lean_Parser_tokenFn(x_2, x_17);
-x_60 = lean_ctor_get(x_59, 3);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_57; lean_object* x_58; 
+lean_inc(x_10);
+x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
+lean_dec(x_9);
+x_17 = lean_ctor_get(x_16, 0);
+lean_inc(x_17);
+x_18 = lean_array_get_size(x_17);
+lean_dec(x_17);
+lean_inc(x_1);
+x_57 = l_Lean_Parser_tokenFn(x_1, x_16);
+x_58 = lean_ctor_get(x_57, 3);
+lean_inc(x_58);
+if (lean_obj_tag(x_58) == 0)
 {
-lean_object* x_61; lean_object* x_62; 
-x_61 = lean_ctor_get(x_59, 0);
+lean_object* x_59; lean_object* x_60; 
+x_59 = lean_ctor_get(x_57, 0);
+lean_inc(x_59);
+x_60 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_59);
+lean_dec(x_59);
+if (lean_obj_tag(x_60) == 2)
+{
+lean_object* x_61; lean_object* x_62; uint8_t x_63; 
+x_61 = lean_ctor_get(x_60, 1);
 lean_inc(x_61);
-x_62 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_61);
+lean_dec(x_60);
+x_62 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__6;
+x_63 = lean_string_dec_eq(x_61, x_62);
 lean_dec(x_61);
-if (lean_obj_tag(x_62) == 2)
+if (x_63 == 0)
 {
-lean_object* x_63; lean_object* x_64; uint8_t x_65; 
-x_63 = lean_ctor_get(x_62, 1);
-lean_inc(x_63);
-lean_dec(x_62);
-x_64 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__6;
-x_65 = lean_string_dec_eq(x_63, x_64);
-lean_dec(x_63);
-if (x_65 == 0)
+lean_object* x_64; lean_object* x_65; 
+x_64 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
+lean_inc(x_10);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_64, x_10);
+x_19 = x_65;
+goto block_56;
+}
+else
+{
+x_19 = x_57;
+goto block_56;
+}
+}
+else
 {
 lean_object* x_66; lean_object* x_67; 
+lean_dec(x_60);
 x_66 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
-lean_inc(x_11);
-x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_59, x_66, x_11);
-x_20 = x_67;
-goto block_58;
-}
-else
-{
-x_20 = x_59;
-goto block_58;
+lean_inc(x_10);
+x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_66, x_10);
+x_19 = x_67;
+goto block_56;
 }
 }
 else
 {
 lean_object* x_68; lean_object* x_69; 
-lean_dec(x_62);
+lean_dec(x_58);
 x_68 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
-lean_inc(x_11);
-x_69 = l_Lean_Parser_ParserState_mkErrorsAt(x_59, x_68, x_11);
-x_20 = x_69;
-goto block_58;
+lean_inc(x_10);
+x_69 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_68, x_10);
+x_19 = x_69;
+goto block_56;
 }
-}
-else
+block_56:
 {
-lean_object* x_70; lean_object* x_71; 
-lean_dec(x_60);
-x_70 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__14;
-lean_inc(x_11);
-x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_59, x_70, x_11);
-x_20 = x_71;
-goto block_58;
-}
-block_58:
+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; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
+uint8_t x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = 0;
+lean_inc(x_1);
+x_22 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1(x_21, x_21, x_1, x_19);
+x_23 = lean_ctor_get(x_22, 3);
+lean_inc(x_23);
+if (lean_obj_tag(x_23) == 0)
 {
-uint8_t x_22; uint8_t x_23; lean_object* x_24; lean_object* x_25; 
-x_22 = 0;
-x_23 = 0;
-lean_inc(x_2);
-x_24 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1(x_22, x_23, x_23, x_1, x_2, x_20);
-lean_dec(x_1);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_26 = lean_ctor_get(x_24, 1);
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+x_24 = lean_ctor_get(x_22, 1);
+lean_inc(x_24);
+x_25 = l_Lean_Parser_tokenFn(x_1, x_22);
+x_26 = lean_ctor_get(x_25, 3);
 lean_inc(x_26);
-x_27 = l_Lean_Parser_tokenFn(x_2, x_24);
-x_28 = lean_ctor_get(x_27, 3);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
+if (lean_obj_tag(x_26) == 0)
 {
-lean_object* x_29; lean_object* x_30; 
-x_29 = lean_ctor_get(x_27, 0);
+lean_object* x_27; lean_object* x_28; 
+x_27 = lean_ctor_get(x_25, 0);
+lean_inc(x_27);
+x_28 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_27);
+lean_dec(x_27);
+if (lean_obj_tag(x_28) == 2)
+{
+lean_object* x_29; lean_object* x_30; uint8_t x_31; 
+x_29 = lean_ctor_get(x_28, 1);
 lean_inc(x_29);
-x_30 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_29);
-lean_dec(x_29);
-if (lean_obj_tag(x_30) == 2)
-{
-lean_object* x_31; lean_object* x_32; uint8_t x_33; 
-x_31 = lean_ctor_get(x_30, 1);
-lean_inc(x_31);
-lean_dec(x_30);
-x_32 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
-x_33 = lean_string_dec_eq(x_31, x_32);
-lean_dec(x_31);
-if (x_33 == 0)
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_34 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_26);
-x_36 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_19);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_14, x_11);
-lean_dec(x_11);
-return x_38;
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_26);
-x_39 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_27, x_39, x_19);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_14, x_11);
-lean_dec(x_11);
-return x_41;
-}
-}
-else
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-lean_dec(x_30);
-x_42 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_42, x_26);
-x_44 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_19);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_14, x_11);
-lean_dec(x_11);
-return x_46;
-}
-}
-else
-{
-lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
 lean_dec(x_28);
-x_47 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_47, x_26);
-x_49 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_48, x_49, x_19);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_14, x_11);
-lean_dec(x_11);
-return x_51;
+x_30 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
+x_31 = lean_string_dec_eq(x_29, x_30);
+lean_dec(x_29);
+if (x_31 == 0)
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_32 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_32, x_24);
+x_34 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_18);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
+lean_dec(x_10);
+return x_36;
+}
+else
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+lean_dec(x_24);
+x_37 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
+x_38 = l_Lean_Parser_ParserState_mkNode(x_25, x_37, x_18);
+x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_13, x_10);
+lean_dec(x_10);
+return x_39;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_25);
-lean_dec(x_2);
-x_52 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_24, x_52, x_19);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_14, x_11);
-lean_dec(x_11);
-return x_54;
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+lean_dec(x_28);
+x_40 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_40, x_24);
+x_42 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
+x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_18);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_13, x_10);
+lean_dec(x_10);
+return x_44;
 }
 }
 else
 {
-lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-lean_dec(x_21);
-lean_dec(x_2);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_26);
+x_45 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_45, x_24);
+x_47 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_18);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_13, x_10);
+lean_dec(x_10);
+return x_49;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_23);
 lean_dec(x_1);
-x_55 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
-x_56 = l_Lean_Parser_ParserState_mkNode(x_20, x_55, x_19);
-x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_14, x_11);
-lean_dec(x_11);
-return x_57;
+x_50 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_22, x_50, x_18);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_13, x_10);
+lean_dec(x_10);
+return x_52;
+}
+}
+else
+{
+lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+lean_dec(x_20);
+lean_dec(x_1);
+x_53 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2;
+x_54 = l_Lean_Parser_ParserState_mkNode(x_19, x_53, x_18);
+x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_13, x_10);
+lean_dec(x_10);
+return x_55;
 }
 }
 }
@@ -2996,11 +2932,10 @@ return x_57;
 }
 else
 {
-lean_dec(x_8);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 }
 }
@@ -3102,7 +3037,7 @@ lean_object* _init_l_Lean_Parser_Term_explicitUniv___closed__10() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_explicitUniv___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_explicitUniv___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3126,38 +3061,32 @@ x_1 = l_Lean_Parser_Term_explicitUniv___closed__11;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
-lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-lean_dec(x_6);
-return x_13;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
 x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_8 = lean_unbox(x_2);
-lean_dec(x_2);
-x_9 = lean_unbox(x_3);
+x_8 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1(x_7, x_8, x_9, x_4, x_5, x_6);
+x_9 = lean_unbox(x_4);
 lean_dec(x_4);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
 return x_10;
 }
 }
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox(x_1);
+lean_dec(x_1);
+x_6 = lean_unbox(x_2);
+lean_dec(x_2);
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__1(x_5, x_6, x_3, x_4);
+return x_7;
+}
+}
 lean_object* _init_l_Lean_Parser_Term_namedPattern___elambda__1___closed__1() {
 _start:
 {
@@ -3189,13 +3118,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_namedPattern___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_namedPattern___elambda__1___closed__5() {
@@ -3255,160 +3183,159 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_namedPattern___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_namedPattern___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__7;
-x_7 = l_Lean_Parser_checkNoWsBeforeFn(x_6, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__7;
+x_6 = l_Lean_Parser_checkNoWsBeforeFn(x_5, x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_9 = lean_ctor_get(x_7, 0);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
-lean_dec(x_9);
-x_11 = lean_ctor_get(x_7, 1);
-lean_inc(x_11);
-lean_inc(x_2);
-x_12 = lean_apply_3(x_5, x_1, x_2, x_7);
-x_13 = lean_ctor_get(x_12, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
-{
-lean_dec(x_11);
-lean_dec(x_10);
-lean_dec(x_2);
-return x_12;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_12, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_15, x_11);
-lean_dec(x_15);
-if (x_16 == 0)
-{
-lean_dec(x_14);
-lean_dec(x_11);
-lean_dec(x_10);
-lean_dec(x_2);
-return x_12;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_32; lean_object* x_33; 
-lean_inc(x_11);
-x_17 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_11);
-lean_dec(x_10);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_array_get_size(x_18);
-lean_dec(x_18);
-lean_inc(x_2);
-x_32 = l_Lean_Parser_tokenFn(x_2, x_17);
-x_33 = lean_ctor_get(x_32, 3);
-lean_inc(x_33);
-if (lean_obj_tag(x_33) == 0)
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = lean_ctor_get(x_32, 0);
-lean_inc(x_34);
-x_35 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_34);
-lean_dec(x_34);
-if (lean_obj_tag(x_35) == 2)
-{
-lean_object* x_36; lean_object* x_37; uint8_t x_38; 
-x_36 = lean_ctor_get(x_35, 1);
-lean_inc(x_36);
-lean_dec(x_35);
-x_37 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__6;
-x_38 = lean_string_dec_eq(x_36, x_37);
-lean_dec(x_36);
-if (x_38 == 0)
-{
-lean_object* x_39; lean_object* x_40; 
-x_39 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
-lean_inc(x_11);
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_39, x_11);
-x_20 = x_40;
-goto block_31;
-}
-else
-{
-x_20 = x_32;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_41; lean_object* x_42; 
-lean_dec(x_35);
-x_41 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
-lean_inc(x_11);
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_41, x_11);
-x_20 = x_42;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; 
-lean_dec(x_33);
-x_43 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
-lean_inc(x_11);
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_43, x_11);
-x_20 = x_44;
-goto block_31;
-}
-block_31:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-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 = l_Lean_Parser_termParser___closed__2;
-x_23 = l_Lean_Parser_appPrec;
-x_24 = l_Lean_Parser_categoryParserFn(x_22, x_23, x_2, x_20);
-x_25 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_19);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_14, x_11);
-lean_dec(x_11);
-return x_27;
-}
-else
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_21);
-lean_dec(x_2);
-x_28 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_19);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_14, x_11);
-lean_dec(x_11);
-return x_30;
-}
-}
-}
-}
-}
-else
-{
+x_9 = lean_array_get_size(x_8);
 lean_dec(x_8);
-lean_dec(x_5);
-lean_dec(x_2);
+x_10 = lean_ctor_get(x_6, 1);
+lean_inc(x_10);
+lean_inc(x_1);
+x_11 = lean_apply_2(x_4, x_1, x_6);
+x_12 = lean_ctor_get(x_11, 3);
+lean_inc(x_12);
+if (lean_obj_tag(x_12) == 0)
+{
+lean_dec(x_10);
+lean_dec(x_9);
 lean_dec(x_1);
-return x_7;
+return x_11;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; uint8_t x_15; 
+x_13 = lean_ctor_get(x_12, 0);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = lean_ctor_get(x_11, 1);
+lean_inc(x_14);
+x_15 = lean_nat_dec_eq(x_14, x_10);
+lean_dec(x_14);
+if (x_15 == 0)
+{
+lean_dec(x_13);
+lean_dec(x_10);
+lean_dec(x_9);
+lean_dec(x_1);
+return x_11;
+}
+else
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_31; lean_object* x_32; 
+lean_inc(x_10);
+x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
+lean_dec(x_9);
+x_17 = lean_ctor_get(x_16, 0);
+lean_inc(x_17);
+x_18 = lean_array_get_size(x_17);
+lean_dec(x_17);
+lean_inc(x_1);
+x_31 = l_Lean_Parser_tokenFn(x_1, x_16);
+x_32 = lean_ctor_get(x_31, 3);
+lean_inc(x_32);
+if (lean_obj_tag(x_32) == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+x_33 = lean_ctor_get(x_31, 0);
+lean_inc(x_33);
+x_34 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_33);
+lean_dec(x_33);
+if (lean_obj_tag(x_34) == 2)
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = lean_ctor_get(x_34, 1);
+lean_inc(x_35);
+lean_dec(x_34);
+x_36 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__6;
+x_37 = lean_string_dec_eq(x_35, x_36);
+lean_dec(x_35);
+if (x_37 == 0)
+{
+lean_object* x_38; lean_object* x_39; 
+x_38 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
+lean_inc(x_10);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_10);
+x_19 = x_39;
+goto block_30;
+}
+else
+{
+x_19 = x_31;
+goto block_30;
+}
+}
+else
+{
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_34);
+x_40 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
+lean_inc(x_10);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_10);
+x_19 = x_41;
+goto block_30;
+}
+}
+else
+{
+lean_object* x_42; lean_object* x_43; 
+lean_dec(x_32);
+x_42 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
+lean_inc(x_10);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_10);
+x_19 = x_43;
+goto block_30;
+}
+block_30:
+{
+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_24; lean_object* x_25; lean_object* x_26; 
+x_21 = l_Lean_Parser_termParser___closed__2;
+x_22 = l_Lean_Parser_appPrec;
+x_23 = l_Lean_Parser_categoryParser___elambda__1(x_21, x_22, x_1, x_19);
+x_24 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_18);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_13, x_10);
+lean_dec(x_10);
+return x_26;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_20);
+lean_dec(x_1);
+x_27 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_19, x_27, x_18);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_13, x_10);
+lean_dec(x_10);
+return x_29;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_7);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
 }
 }
 }
@@ -3425,12 +3352,11 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Term_namedPattern___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_termParser___closed__2;
-x_3 = l_Lean_Parser_appPrec;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_termParser___closed__2;
+x_2 = l_Lean_Parser_appPrec;
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_namedPattern___closed__3() {
@@ -3481,7 +3407,7 @@ lean_object* _init_l_Lean_Parser_Term_namedPattern___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_namedPattern___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_namedPattern___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3518,201 +3444,187 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_id___elambda__1___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_mkTermIdFromIdent___closed__1;
-x_3 = l_Lean_Parser_Term_id___elambda__1___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_mkTermIdFromIdent___closed__1;
+x_2 = l_Lean_Parser_Term_id___elambda__1___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_id___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_id___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_id___elambda__1___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_id___elambda__1___closed__2;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
+lean_inc(x_1);
+x_16 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
 lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_16, 0);
+lean_inc(x_18);
+x_19 = lean_array_get_size(x_18);
+lean_dec(x_18);
+x_20 = lean_ctor_get(x_16, 1);
 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_24; lean_object* x_25; 
-x_21 = lean_ctor_get(x_19, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
-lean_dec(x_21);
-x_23 = lean_ctor_get(x_19, 1);
-lean_inc(x_23);
-lean_inc(x_2);
 lean_inc(x_1);
-x_24 = l_Lean_Parser_Term_explicitUniv___elambda__1(x_1, x_2, x_19);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
+x_21 = l_Lean_Parser_Term_explicitUniv___elambda__1(x_1, x_16);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_23);
-lean_dec(x_2);
-lean_dec(x_1);
-x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_22);
-x_28 = l_Lean_mkTermIdFromIdent___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_18);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_13, x_10);
-lean_dec(x_10);
-return x_30;
-}
-else
-{
-lean_object* x_31; lean_object* x_32; uint8_t x_33; 
-x_31 = lean_ctor_get(x_25, 0);
-lean_inc(x_31);
-lean_dec(x_25);
-x_32 = lean_ctor_get(x_24, 1);
-lean_inc(x_32);
-x_33 = lean_nat_dec_eq(x_32, x_23);
-lean_dec(x_32);
-if (x_33 == 0)
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_31);
-lean_dec(x_23);
-lean_dec(x_2);
-lean_dec(x_1);
-x_34 = l_Lean_nullKind;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_24, x_34, x_22);
-x_36 = l_Lean_mkTermIdFromIdent___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_18);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_13, x_10);
-lean_dec(x_10);
-return x_38;
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-lean_inc(x_23);
-x_39 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
-x_40 = l_Lean_Parser_Term_namedPattern___elambda__1(x_1, x_2, x_39);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_31, x_23);
-x_42 = lean_ctor_get(x_41, 3);
-lean_inc(x_42);
-if (lean_obj_tag(x_42) == 0)
-{
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_dec(x_23);
-x_43 = l_Lean_nullKind;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_41, x_43, x_22);
-x_45 = l_Lean_mkTermIdFromIdent___closed__2;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_18);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_13, x_10);
-lean_dec(x_10);
-return x_47;
-}
-else
-{
-lean_object* x_48; uint8_t x_49; 
-lean_dec(x_42);
-x_48 = lean_ctor_get(x_41, 1);
-lean_inc(x_48);
-x_49 = lean_nat_dec_eq(x_48, x_23);
-lean_dec(x_48);
-if (x_49 == 0)
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_23);
-x_50 = l_Lean_nullKind;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_41, x_50, x_22);
-x_52 = l_Lean_mkTermIdFromIdent___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_51, x_52, x_18);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_13, x_10);
-lean_dec(x_10);
-return x_54;
-}
-else
-{
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_55 = l_Lean_Parser_ParserState_restore(x_41, x_22, x_23);
-x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_22);
-x_58 = l_Lean_mkTermIdFromIdent___closed__2;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_18);
-x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_13, x_10);
-lean_dec(x_10);
-return x_60;
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
 lean_dec(x_20);
-lean_dec(x_2);
 lean_dec(x_1);
-x_61 = l_Lean_mkTermIdFromIdent___closed__2;
-x_62 = l_Lean_Parser_ParserState_mkNode(x_19, x_61, x_18);
-x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_13, x_10);
-lean_dec(x_10);
-return x_63;
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_19);
+x_25 = l_Lean_mkTermIdFromIdent___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; uint8_t x_30; 
+x_28 = lean_ctor_get(x_22, 0);
+lean_inc(x_28);
+lean_dec(x_22);
+x_29 = lean_ctor_get(x_21, 1);
+lean_inc(x_29);
+x_30 = lean_nat_dec_eq(x_29, x_20);
+lean_dec(x_29);
+if (x_30 == 0)
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_28);
+lean_dec(x_20);
+lean_dec(x_1);
+x_31 = l_Lean_nullKind;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_21, x_31, x_19);
+x_33 = l_Lean_mkTermIdFromIdent___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+lean_inc(x_20);
+x_36 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+x_37 = l_Lean_Parser_Term_namedPattern___elambda__1(x_1, x_36);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_28, x_20);
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+lean_dec(x_20);
+x_40 = l_Lean_nullKind;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_38, x_40, x_19);
+x_42 = l_Lean_mkTermIdFromIdent___closed__2;
+x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_15);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_10, x_7);
+lean_dec(x_7);
+return x_44;
+}
+else
+{
+lean_object* x_45; uint8_t x_46; 
+lean_dec(x_39);
+x_45 = lean_ctor_get(x_38, 1);
+lean_inc(x_45);
+x_46 = lean_nat_dec_eq(x_45, x_20);
+lean_dec(x_45);
+if (x_46 == 0)
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_20);
+x_47 = l_Lean_nullKind;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_38, x_47, x_19);
+x_49 = l_Lean_mkTermIdFromIdent___closed__2;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_48, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
+return x_51;
+}
+else
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_52 = l_Lean_Parser_ParserState_restore(x_38, x_19, x_20);
+x_53 = l_Lean_nullKind;
+x_54 = l_Lean_Parser_ParserState_mkNode(x_52, x_53, x_19);
+x_55 = l_Lean_mkTermIdFromIdent___closed__2;
+x_56 = l_Lean_Parser_ParserState_mkNode(x_54, x_55, x_15);
+x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_10, x_7);
+lean_dec(x_7);
+return x_57;
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_58 = l_Lean_mkTermIdFromIdent___closed__2;
+x_59 = l_Lean_Parser_ParserState_mkNode(x_16, x_58, x_15);
+x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_10, x_7);
+lean_dec(x_7);
+return x_60;
 }
 }
 }
@@ -3745,7 +3657,7 @@ lean_object* _init_l_Lean_Parser_Term_id___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_id___closed__2;
@@ -3779,7 +3691,7 @@ lean_object* _init_l_Lean_Parser_Term_id___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_id___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_id___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3806,10 +3718,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_id(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_mkTermIdFromIdent___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_mkTermIdFromIdent___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_id;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -3838,81 +3750,72 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_num___elambda__1___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Level_num___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_num___elambda__1___closed__2;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Level_num___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_num___elambda__1___closed__2;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_num___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_num___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_num___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_num___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_num___elambda__1___closed__3;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-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_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = l_Lean_Parser_Term_num___elambda__1___closed__1;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_18);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_13, x_10);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
 lean_dec(x_10);
-return x_22;
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_numLit___elambda__1(x_1, x_13);
+x_17 = l_Lean_Parser_Term_num___elambda__1___closed__1;
+x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_15);
+x_19 = l_Lean_Parser_mergeOrElseErrors(x_18, x_10, x_7);
+lean_dec(x_7);
+return x_19;
 }
 }
 }
@@ -3921,7 +3824,7 @@ lean_object* _init_l_Lean_Parser_Term_num___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_num___elambda__1___closed__5;
+x_1 = l_Lean_Parser_numLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_num___elambda__1___closed__1;
@@ -3945,7 +3848,7 @@ lean_object* _init_l_Lean_Parser_Term_num___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_num___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_num___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -3972,10 +3875,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_num(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_num___elambda__1___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_num___elambda__1___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_num;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -4012,90 +3915,72 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_str___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_str___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_str___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_str___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_str___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_str___elambda__1___closed__5() {
+lean_object* l_Lean_Parser_Term_str___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_strLit(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Term_str___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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_str___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_str___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_str___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-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_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = l_Lean_Parser_Term_str___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_18);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_13, x_10);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
 lean_dec(x_10);
-return x_22;
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_strLit___elambda__1(x_1, x_13);
+x_17 = l_Lean_Parser_Term_str___elambda__1___closed__2;
+x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_15);
+x_19 = l_Lean_Parser_mergeOrElseErrors(x_18, x_10, x_7);
+lean_dec(x_7);
+return x_19;
 }
 }
 }
@@ -4104,7 +3989,7 @@ lean_object* _init_l_Lean_Parser_Term_str___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_str___elambda__1___closed__5;
+x_1 = l_Lean_Parser_strLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_str___elambda__1___closed__2;
@@ -4128,7 +4013,7 @@ lean_object* _init_l_Lean_Parser_Term_str___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_str___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_str___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4155,10 +4040,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_str(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_str___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_str___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_str;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -4195,90 +4080,72 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_char___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_char___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_char___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_char___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_char___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_char___elambda__1___closed__5() {
+lean_object* l_Lean_Parser_Term_char___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_charLit(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Term_char___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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_char___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_char___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_char___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-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_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = l_Lean_Parser_Term_char___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_18);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_13, x_10);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
 lean_dec(x_10);
-return x_22;
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_charLit___elambda__1(x_1, x_13);
+x_17 = l_Lean_Parser_Term_char___elambda__1___closed__2;
+x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_15);
+x_19 = l_Lean_Parser_mergeOrElseErrors(x_18, x_10, x_7);
+lean_dec(x_7);
+return x_19;
 }
 }
 }
@@ -4287,7 +4154,7 @@ lean_object* _init_l_Lean_Parser_Term_char___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_char___elambda__1___closed__5;
+x_1 = l_Lean_Parser_charLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_char___elambda__1___closed__2;
@@ -4311,7 +4178,7 @@ lean_object* _init_l_Lean_Parser_Term_char___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_char___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_char___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4338,10 +4205,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_char(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_char___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_char___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_char;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -4378,13 +4245,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_type___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_type___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_type___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_type___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_type___elambda__1___closed__5() {
@@ -4436,125 +4302,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_type___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_type___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_type___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_type___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Term_type___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Term_type___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Term_type___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Term_type___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Term_type___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Term_type___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Term_type___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Term_type___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Term_type___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Term_type___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Term_type___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Term_type___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -4596,7 +4462,7 @@ lean_object* _init_l_Lean_Parser_Term_type___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_type___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_type___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4623,10 +4489,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_type(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_type___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_type;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -4663,13 +4529,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_sort___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_sort___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_sort___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_sort___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_sort___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_sort___elambda__1___closed__5() {
@@ -4721,125 +4586,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_sort___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_sort___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_sort___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_sort___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Term_sort___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Term_sort___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Term_sort___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Term_sort___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Term_sort___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Term_sort___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Term_sort___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Term_sort___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -4881,7 +4746,7 @@ lean_object* _init_l_Lean_Parser_Term_sort___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sort___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sort___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -4908,10 +4773,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_sort(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_sort___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_sort;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -4948,13 +4813,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_prop___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_prop___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_prop___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_prop___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_prop___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_prop___elambda__1___closed__5() {
@@ -5006,125 +4870,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_prop___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_prop___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_prop___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_prop___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Term_prop___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Term_prop___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Term_prop___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Term_prop___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Term_prop___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Term_prop___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Term_prop___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Term_prop___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -5166,7 +5030,7 @@ lean_object* _init_l_Lean_Parser_Term_prop___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_prop___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_prop___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5193,10 +5057,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_prop(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_prop___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_prop;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -5215,134 +5079,133 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_hole___elambda__1___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_mkHole___closed__1;
-x_3 = l_Lean_Parser_Term_hole___elambda__1___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_mkHole___closed__1;
+x_2 = l_Lean_Parser_Term_hole___elambda__1___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_hole___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_hole___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_hole___elambda__1___closed__2;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_hole___elambda__1___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Level_hole___elambda__1___closed__4;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_mkHole___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_mkHole___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_mkHole___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_mkHole___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Level_hole___elambda__1___closed__4;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_mkHole___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_mkHole___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_mkHole___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Level_hole___elambda__1___closed__7;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_mkHole___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -5384,7 +5247,7 @@ lean_object* _init_l_Lean_Parser_Term_hole___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_hole___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_hole___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5411,10 +5274,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_hole(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_mkHole___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_mkHole___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_hole;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -5451,13 +5314,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_namedHole___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_namedHole___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_namedHole___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_namedHole___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_namedHole___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_namedHole___elambda__1___closed__5() {
@@ -5501,149 +5363,139 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_namedHole___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_namedHole___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_namedHole___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_namedHole___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_26; lean_object* x_27; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
+lean_inc(x_28);
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
+lean_dec(x_28);
+if (lean_obj_tag(x_29) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_namedHole___elambda__1___closed__5;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
-lean_inc(x_10);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_10);
-x_19 = x_37;
-goto block_28;
-}
-else
-{
-x_19 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
-lean_inc(x_10);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_10);
-x_19 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+lean_dec(x_29);
+x_31 = l_Lean_Parser_Term_namedHole___elambda__1___closed__5;
+x_32 = lean_string_dec_eq(x_30, x_31);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
-lean_inc(x_10);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_10);
-x_19 = x_41;
-goto block_28;
-}
-block_28:
+if (x_32 == 0)
 {
-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_24; 
-x_21 = lean_apply_3(x_5, x_1, x_2, x_19);
-x_22 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_10);
-lean_dec(x_10);
-return x_24;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
+lean_inc(x_7);
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_7);
+x_16 = x_34;
+goto block_25;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+x_16 = x_26;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_29);
+x_35 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_7);
+x_16 = x_36;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_27);
+x_37 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_7);
+x_16 = x_38;
+goto block_25;
+}
+block_25:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_ident___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_25 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_19, x_25, x_18);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_13, x_10);
-lean_dec(x_10);
-return x_27;
+x_22 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -5664,7 +5516,7 @@ lean_object* _init_l_Lean_Parser_Term_namedHole___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_namedHole___closed__1;
@@ -5698,7 +5550,7 @@ lean_object* _init_l_Lean_Parser_Term_namedHole___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_namedHole___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_namedHole___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -5725,10 +5577,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_namedHole(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_namedHole;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -5765,13 +5617,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_sorry___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_sorry___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_sorry___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_sorry___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_sorry___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_sorry___elambda__1___closed__5() {
@@ -5815,125 +5666,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_sorry___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_sorry___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_sorry___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_sorry___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Term_sorry___elambda__1___closed__5;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Term_sorry___elambda__1___closed__8;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Term_sorry___elambda__1___closed__8;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Term_sorry___elambda__1___closed__8;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Term_sorry___elambda__1___closed__5;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Term_sorry___elambda__1___closed__8;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Term_sorry___elambda__1___closed__8;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Term_sorry___elambda__1___closed__8;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -5975,7 +5826,7 @@ lean_object* _init_l_Lean_Parser_Term_sorry___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sorry___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sorry___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6002,10 +5853,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_sorry(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_sorry___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_sorry;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -6042,13 +5893,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_cdot___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_cdot___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_cdot___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_cdot___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_cdot___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_cdot___elambda__1___closed__5() {
@@ -6100,125 +5950,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_cdot___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_cdot___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_cdot___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_cdot___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Term_cdot___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Term_cdot___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Term_cdot___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Term_cdot___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Term_cdot___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Term_cdot___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Term_cdot___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Term_cdot___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -6260,7 +6110,7 @@ lean_object* _init_l_Lean_Parser_Term_cdot___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_cdot___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_cdot___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6287,10 +6137,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_cdot(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_cdot___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_cdot;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -6327,13 +6177,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_emptyC___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_emptyC___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_emptyC___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_emptyC___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_emptyC___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_emptyC___elambda__1___closed__5() {
@@ -6385,125 +6234,125 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_emptyC___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_emptyC___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_emptyC___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_emptyC___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
-lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
-lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
-{
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l_Lean_Parser_Term_emptyC___elambda__1___closed__6;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9;
-lean_inc(x_8);
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_8);
-x_26 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_16);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_11, x_8);
-lean_dec(x_8);
-return x_28;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_17, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_20);
-x_32 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9;
-lean_inc(x_8);
-x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_32, x_8);
-x_34 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_16);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_11, x_8);
-lean_dec(x_8);
-return x_36;
-}
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
-x_37 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9;
-lean_inc(x_8);
-x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_8);
-x_39 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_8);
-lean_dec(x_8);
-return x_41;
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_20 = lean_ctor_get(x_19, 1);
+lean_inc(x_20);
+lean_dec(x_19);
+x_21 = l_Lean_Parser_Term_emptyC___elambda__1___closed__6;
+x_22 = lean_string_dec_eq(x_20, x_21);
+lean_dec(x_20);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9;
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_7);
+x_25 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_15);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_10, x_7);
+lean_dec(x_7);
+return x_27;
+}
+else
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_16, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_19);
+x_31 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9;
+lean_inc(x_7);
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_31, x_7);
+x_33 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_15);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_10, x_7);
+lean_dec(x_7);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_17);
+x_36 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_36, x_7);
+x_38 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 }
@@ -6545,7 +6394,7 @@ lean_object* _init_l_Lean_Parser_Term_emptyC___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_emptyC___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_emptyC___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -6572,10 +6421,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_emptyC(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_emptyC;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -6612,13 +6461,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_typeAscription___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_typeAscription___elambda__1___closed__5() {
@@ -6662,141 +6510,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_typeAscription___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_typeAscription___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_typeAscription___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -6816,19 +6664,8 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_termParser___closed__2;
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__3() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_typeAscription___closed__1;
@@ -6836,42 +6673,42 @@ x_4 = l_Lean_Parser_andthenInfo(x_3, x_2);
 return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__4() {
+lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__2;
-x_2 = l_Lean_Parser_Term_typeAscription___closed__3;
+x_2 = l_Lean_Parser_Term_typeAscription___closed__2;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__5() {
+lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__4;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_Term_typeAscription___closed__4;
+x_3 = l_Lean_Parser_Term_typeAscription___closed__3;
 x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
 return x_4;
 }
 }
+lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__5() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_typeAscription___elambda__1), 2, 0);
+return x_1;
+}
+}
 lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__6() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_typeAscription___elambda__1), 3, 0);
-return x_1;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__7() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__5;
-x_2 = l_Lean_Parser_Term_typeAscription___closed__6;
+x_1 = l_Lean_Parser_Term_typeAscription___closed__4;
+x_2 = l_Lean_Parser_Term_typeAscription___closed__5;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -6882,219 +6719,219 @@ lean_object* _init_l_Lean_Parser_Term_typeAscription() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__7;
+x_1 = l_Lean_Parser_Term_typeAscription___closed__6;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-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; 
-x_9 = lean_ctor_get(x_8, 0);
+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; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
+x_10 = l_Lean_Parser_termParser___closed__2;
+x_11 = lean_unsigned_to_nat(0u);
+lean_inc(x_5);
+x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_5, x_6);
+x_13 = lean_ctor_get(x_12, 3);
+lean_inc(x_13);
+if (lean_obj_tag(x_13) == 0)
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_31; lean_object* x_32; 
 lean_dec(x_9);
-x_11 = lean_ctor_get(x_8, 1);
-lean_inc(x_11);
-x_12 = l_Lean_Parser_termParser___closed__2;
-x_13 = lean_unsigned_to_nat(0u);
-lean_inc(x_7);
-x_14 = l_Lean_Parser_categoryParserFn(x_12, x_13, x_7, x_8);
-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_33; lean_object* x_34; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_16 = lean_ctor_get(x_14, 0);
+lean_dec(x_8);
+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 = lean_ctor_get(x_12, 1);
 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_inc(x_18);
-lean_inc(x_7);
-x_33 = l_Lean_Parser_tokenFn(x_7, x_14);
-x_34 = lean_ctor_get(x_33, 3);
-lean_inc(x_34);
-if (lean_obj_tag(x_34) == 0)
+lean_inc(x_5);
+x_31 = l_Lean_Parser_tokenFn(x_5, x_12);
+x_32 = lean_ctor_get(x_31, 3);
+lean_inc(x_32);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_35; lean_object* x_36; 
-x_35 = lean_ctor_get(x_33, 0);
+lean_object* x_33; lean_object* x_34; 
+x_33 = lean_ctor_get(x_31, 0);
+lean_inc(x_33);
+x_34 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_33);
+lean_dec(x_33);
+if (lean_obj_tag(x_34) == 2)
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = lean_ctor_get(x_34, 1);
 lean_inc(x_35);
-x_36 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_35);
+lean_dec(x_34);
+x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_37 = lean_string_dec_eq(x_35, x_36);
 lean_dec(x_35);
-if (lean_obj_tag(x_36) == 2)
+if (x_37 == 0)
 {
-lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_37 = lean_ctor_get(x_36, 1);
-lean_inc(x_37);
-lean_dec(x_36);
-x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_39 = lean_string_dec_eq(x_37, x_38);
-lean_dec(x_37);
-if (x_39 == 0)
-{
-lean_object* x_40; lean_object* x_41; 
-x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_18);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_18);
-x_19 = x_41;
-goto block_32;
+lean_object* x_38; lean_object* x_39; 
+x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_16);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_16);
+x_17 = x_39;
+goto block_30;
 }
 else
 {
-x_19 = x_33;
-goto block_32;
+x_17 = x_31;
+goto block_30;
+}
+}
+else
+{
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_34);
+x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_16);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_16);
+x_17 = x_41;
+goto block_30;
 }
 }
 else
 {
 lean_object* x_42; lean_object* x_43; 
-lean_dec(x_36);
+lean_dec(x_32);
 x_42 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_16);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_16);
+x_17 = x_43;
+goto block_30;
+}
+block_30:
+{
+lean_object* x_18; 
+x_18 = lean_ctor_get(x_17, 3);
 lean_inc(x_18);
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_42, x_18);
-x_19 = x_43;
-goto block_32;
-}
-}
-else
+if (lean_obj_tag(x_18) == 0)
 {
-lean_object* x_44; lean_object* x_45; 
-lean_dec(x_34);
-x_44 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_18);
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_44, x_18);
-x_19 = x_45;
-goto block_32;
-}
-block_32:
+lean_dec(x_16);
+lean_dec(x_15);
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_dec(x_18);
-lean_dec(x_17);
-{
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_19;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_17;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
-lean_dec(x_20);
-lean_dec(x_7);
-x_22 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
-lean_dec(x_17);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+lean_dec(x_18);
+lean_dec(x_5);
+x_20 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
+lean_dec(x_15);
+x_21 = lean_ctor_get(x_20, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_nat_sub(x_22, x_2);
+lean_dec(x_22);
+x_24 = lean_unsigned_to_nat(1u);
+x_25 = lean_nat_dec_eq(x_23, x_24);
 lean_dec(x_23);
-x_25 = lean_nat_sub(x_24, x_3);
-lean_dec(x_24);
-x_26 = lean_unsigned_to_nat(1u);
-x_27 = lean_nat_dec_eq(x_25, x_26);
-lean_dec(x_25);
-if (x_27 == 0)
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; 
+x_26 = l_Lean_nullKind;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_2);
+return x_27;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_28; lean_object* x_29; 
 x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_3);
+x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_2);
 return x_29;
 }
 else
 {
+lean_dec(x_2);
+return x_20;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_13);
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Lean_nullKind;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_3);
-return x_31;
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_44 = lean_box(0);
+x_45 = l_Lean_Parser_ParserState_pushSyntax(x_12, x_44);
+x_46 = l_Lean_nullKind;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_2);
+return x_47;
 }
 else
 {
-lean_dec(x_3);
-return x_22;
-}
-}
-}
-}
-}
-else
-{
-lean_dec(x_15);
-lean_dec(x_7);
-if (x_5 == 0)
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_46 = lean_box(0);
-x_47 = l_Lean_Parser_ParserState_pushSyntax(x_14, x_46);
-x_48 = l_Lean_nullKind;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_3);
-return x_49;
-}
-else
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_50 = l_Lean_Parser_ParserState_restore(x_14, x_10, x_11);
-lean_dec(x_10);
-x_51 = lean_ctor_get(x_50, 0);
-lean_inc(x_51);
-x_52 = lean_array_get_size(x_51);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
+x_48 = l_Lean_Parser_ParserState_restore(x_12, x_8, x_9);
+lean_dec(x_8);
+x_49 = lean_ctor_get(x_48, 0);
+lean_inc(x_49);
+x_50 = lean_array_get_size(x_49);
+lean_dec(x_49);
+x_51 = lean_nat_sub(x_50, x_2);
+lean_dec(x_50);
+x_52 = lean_unsigned_to_nat(2u);
+x_53 = lean_nat_dec_eq(x_51, x_52);
 lean_dec(x_51);
-x_53 = lean_nat_sub(x_52, x_3);
-lean_dec(x_52);
-x_54 = lean_unsigned_to_nat(2u);
-x_55 = lean_nat_dec_eq(x_53, x_54);
-lean_dec(x_53);
-if (x_55 == 0)
+if (x_53 == 0)
+{
+lean_object* x_54; lean_object* x_55; 
+x_54 = l_Lean_nullKind;
+x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_2);
+return x_55;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_56; lean_object* x_57; 
 x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_50, x_56, x_3);
+x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_2);
 return x_57;
 }
 else
 {
-if (x_4 == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-x_58 = l_Lean_nullKind;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_50, x_58, x_3);
-return x_59;
-}
-else
-{
-lean_object* x_60; 
-lean_dec(x_3);
-x_60 = l_Lean_Parser_ParserState_popSyntax(x_50);
-return x_60;
+lean_object* x_58; 
+lean_dec(x_2);
+x_58 = l_Lean_Parser_ParserState_popSyntax(x_48);
+return x_58;
 }
 }
 }
 }
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = 0;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(x_1, x_2, x_8, x_3, x_9, x_4, x_5, x_6);
-return x_10;
+lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = 0;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(x_1, x_6, x_2, x_7, x_3, x_4);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_tupleTail___elambda__1___closed__1() {
@@ -7128,155 +6965,148 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_tupleTail___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_tupleTail___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_tupleTail___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_tupleTail___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
-lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_27; lean_object* x_28; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_27 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_28 = lean_ctor_get(x_27, 3);
+lean_inc(x_28);
+if (lean_obj_tag(x_28) == 0)
 {
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
+lean_object* x_29; lean_object* x_30; 
+x_29 = lean_ctor_get(x_27, 0);
+lean_inc(x_29);
+x_30 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_29);
+lean_dec(x_29);
+if (lean_obj_tag(x_30) == 2)
+{
+lean_object* x_31; lean_object* x_32; uint8_t x_33; 
+x_31 = lean_ctor_get(x_30, 1);
 lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
+lean_dec(x_30);
+x_32 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_33 = lean_string_dec_eq(x_31, x_32);
 lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
+if (x_33 == 0)
 {
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
+lean_object* x_34; lean_object* x_35; 
+x_34 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_7);
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_7);
+x_16 = x_35;
+goto block_26;
+}
+else
+{
+x_16 = x_27;
+goto block_26;
+}
+}
+else
 {
 lean_object* x_36; lean_object* x_37; 
+lean_dec(x_30);
 x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
+lean_inc(x_7);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_36, x_7);
+x_16 = x_37;
+goto block_26;
 }
 }
 else
 {
 lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
+lean_dec(x_28);
 x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
+lean_inc(x_7);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_38, x_7);
+x_16 = x_39;
+goto block_26;
 }
+block_26:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = 0;
+x_19 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_18, x_18, x_1, x_16);
+x_20 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__2;
+x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_15);
+x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_10, x_7);
+lean_dec(x_7);
+return x_22;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; 
-lean_dec(x_30);
-x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
-{
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-uint8_t x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = 0;
-x_20 = 0;
-x_21 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_19, x_20, x_20, x_1, x_2, x_17);
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_22 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
-}
-else
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-lean_dec(x_1);
-x_25 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_23 = l_Lean_Parser_Term_tupleTail___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_16, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
 }
 }
 }
@@ -7287,7 +7117,7 @@ lean_object* _init_l_Lean_Parser_Term_tupleTail___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_explicitUniv___closed__2;
@@ -7331,7 +7161,7 @@ lean_object* _init_l_Lean_Parser_Term_tupleTail___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tupleTail___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tupleTail___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7355,124 +7185,115 @@ x_1 = l_Lean_Parser_Term_tupleTail___closed__6;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
-lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-lean_dec(x_6);
-return x_13;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
 x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_8 = lean_unbox(x_2);
-lean_dec(x_2);
-x_9 = lean_unbox(x_3);
+x_8 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_7, x_8, x_9, x_4, x_5, x_6);
+x_9 = lean_unbox(x_4);
 lean_dec(x_4);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
 return x_10;
 }
 }
-lean_object* l_Lean_Parser_Term_parenSpecial___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
-lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-lean_inc(x_2);
+uint8_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox(x_1);
+lean_dec(x_1);
+x_6 = lean_unbox(x_2);
+lean_dec(x_2);
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_5, x_6, x_3, x_4);
+return x_7;
+}
+}
+lean_object* l_Lean_Parser_Term_parenSpecial___elambda__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
 lean_inc(x_1);
-x_7 = l_Lean_Parser_Term_tupleTail___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
-lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
+x_6 = l_Lean_Parser_Term_tupleTail___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_9; lean_object* x_10; 
-lean_dec(x_6);
-lean_dec(x_2);
+lean_object* x_8; lean_object* x_9; 
+lean_dec(x_5);
 lean_dec(x_1);
-x_9 = l_Lean_nullKind;
-x_10 = l_Lean_Parser_ParserState_mkNode(x_7, x_9, x_5);
-return x_10;
+x_8 = l_Lean_nullKind;
+x_9 = l_Lean_Parser_ParserState_mkNode(x_6, x_8, x_4);
+return x_9;
 }
 else
 {
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_8, 0);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_7, 0);
+lean_inc(x_10);
+lean_dec(x_7);
+x_11 = lean_ctor_get(x_6, 1);
 lean_inc(x_11);
-lean_dec(x_8);
-x_12 = lean_ctor_get(x_7, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_6);
-lean_dec(x_12);
-if (x_13 == 0)
-{
-lean_object* x_14; lean_object* x_15; 
+x_12 = lean_nat_dec_eq(x_11, x_5);
 lean_dec(x_11);
-lean_dec(x_6);
-lean_dec(x_2);
+if (x_12 == 0)
+{
+lean_object* x_13; lean_object* x_14; 
+lean_dec(x_10);
+lean_dec(x_5);
 lean_dec(x_1);
-x_14 = l_Lean_nullKind;
-x_15 = l_Lean_Parser_ParserState_mkNode(x_7, x_14, x_5);
-return x_15;
+x_13 = l_Lean_nullKind;
+x_14 = l_Lean_Parser_ParserState_mkNode(x_6, x_13, x_4);
+return x_14;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-lean_inc(x_6);
-x_16 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
-x_17 = l_Lean_Parser_Term_typeAscription___elambda__1(x_1, x_2, x_16);
-x_18 = l_Lean_Parser_mergeOrElseErrors(x_17, x_11, x_6);
-x_19 = lean_ctor_get(x_18, 3);
-lean_inc(x_19);
-if (lean_obj_tag(x_19) == 0)
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+lean_inc(x_5);
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+x_16 = l_Lean_Parser_Term_typeAscription___elambda__1(x_1, x_15);
+x_17 = l_Lean_Parser_mergeOrElseErrors(x_16, x_10, x_5);
+x_18 = lean_ctor_get(x_17, 3);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
 {
-lean_object* x_20; lean_object* x_21; 
-lean_dec(x_6);
-x_20 = l_Lean_nullKind;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_18, x_20, x_5);
-return x_21;
+lean_object* x_19; lean_object* x_20; 
+lean_dec(x_5);
+x_19 = l_Lean_nullKind;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_17, x_19, x_4);
+return x_20;
 }
 else
 {
-lean_object* x_22; uint8_t x_23; 
-lean_dec(x_19);
-x_22 = lean_ctor_get(x_18, 1);
-lean_inc(x_22);
-x_23 = lean_nat_dec_eq(x_22, x_6);
-lean_dec(x_22);
-if (x_23 == 0)
+lean_object* x_21; uint8_t x_22; 
+lean_dec(x_18);
+x_21 = lean_ctor_get(x_17, 1);
+lean_inc(x_21);
+x_22 = lean_nat_dec_eq(x_21, x_5);
+lean_dec(x_21);
+if (x_22 == 0)
 {
-lean_object* x_24; lean_object* x_25; 
-lean_dec(x_6);
-x_24 = l_Lean_nullKind;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_5);
-return x_25;
+lean_object* x_23; lean_object* x_24; 
+lean_dec(x_5);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_17, x_23, x_4);
+return x_24;
 }
 else
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_26 = l_Lean_Parser_ParserState_restore(x_18, x_5, x_6);
-x_27 = l_Lean_nullKind;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_5);
-return x_28;
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_25 = l_Lean_Parser_ParserState_restore(x_17, x_4, x_5);
+x_26 = l_Lean_nullKind;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_4);
+return x_27;
 }
 }
 }
@@ -7506,7 +7327,7 @@ lean_object* _init_l_Lean_Parser_Term_parenSpecial___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_parenSpecial___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_parenSpecial___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7543,319 +7364,313 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_paren___elambda__1___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_paren___elambda__1___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_paren___elambda__1___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_paren___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_paren___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_paren___elambda__1___closed__2;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_paren___elambda__1___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_49; lean_object* x_80; lean_object* x_81; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_80 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_81 = lean_ctor_get(x_80, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_48; lean_object* x_79; lean_object* x_80; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_79 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_80 = lean_ctor_get(x_79, 3);
+lean_inc(x_80);
+if (lean_obj_tag(x_80) == 0)
+{
+lean_object* x_81; lean_object* x_82; 
+x_81 = lean_ctor_get(x_79, 0);
 lean_inc(x_81);
-if (lean_obj_tag(x_81) == 0)
-{
-lean_object* x_82; lean_object* x_83; 
-x_82 = lean_ctor_get(x_80, 0);
-lean_inc(x_82);
-x_83 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_82);
-lean_dec(x_82);
-if (lean_obj_tag(x_83) == 2)
-{
-lean_object* x_84; lean_object* x_85; uint8_t x_86; 
-x_84 = lean_ctor_get(x_83, 1);
-lean_inc(x_84);
-lean_dec(x_83);
-x_85 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_86 = lean_string_dec_eq(x_84, x_85);
-lean_dec(x_84);
-if (x_86 == 0)
-{
-lean_object* x_87; lean_object* x_88; 
-x_87 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_87, x_8);
-x_49 = x_88;
-goto block_79;
-}
-else
-{
-x_49 = x_80;
-goto block_79;
-}
-}
-else
-{
-lean_object* x_89; lean_object* x_90; 
-lean_dec(x_83);
-x_89 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_90 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_89, x_8);
-x_49 = x_90;
-goto block_79;
-}
-}
-else
-{
-lean_object* x_91; lean_object* x_92; 
+x_82 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_81);
 lean_dec(x_81);
-x_91 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_8);
-x_92 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_91, x_8);
-x_49 = x_92;
-goto block_79;
-}
-block_48:
+if (lean_obj_tag(x_82) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_83; lean_object* x_84; uint8_t x_85; 
+x_83 = lean_ctor_get(x_82, 1);
+lean_inc(x_83);
+lean_dec(x_82);
+x_84 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_85 = lean_string_dec_eq(x_83, x_84);
+lean_dec(x_83);
+if (x_85 == 0)
+{
+lean_object* x_86; lean_object* x_87; 
+x_86 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_7);
+x_48 = x_87;
+goto block_78;
+}
+else
+{
+x_48 = x_79;
+goto block_78;
+}
+}
+else
+{
+lean_object* x_88; lean_object* x_89; 
+lean_dec(x_82);
+x_88 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_88, x_7);
+x_48 = x_89;
+goto block_78;
+}
+}
+else
+{
+lean_object* x_90; lean_object* x_91; 
+lean_dec(x_80);
+x_90 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_7);
+x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_90, x_7);
+x_48 = x_91;
+goto block_78;
+}
+block_47:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_16, 1);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_19 = l_Lean_Parser_tokenFn(x_1, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = lean_ctor_get(x_17, 1);
-lean_inc(x_19);
-x_20 = l_Lean_Parser_tokenFn(x_2, x_17);
-x_21 = lean_ctor_get(x_20, 3);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_object* x_22; lean_object* x_23; 
-x_22 = lean_ctor_get(x_20, 0);
-lean_inc(x_22);
-x_23 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_22);
-lean_dec(x_22);
-if (lean_obj_tag(x_23) == 2)
-{
-lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_24 = lean_ctor_get(x_23, 1);
-lean_inc(x_24);
-lean_dec(x_23);
-x_25 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_26 = lean_string_dec_eq(x_24, x_25);
-lean_dec(x_24);
-if (x_26 == 0)
-{
-lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_27 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_27, x_19);
-x_29 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-lean_dec(x_19);
-x_32 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_20, x_32, x_16);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_8);
-lean_dec(x_8);
-return x_34;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_23);
-x_35 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_35, x_19);
-x_37 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_16);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_8);
-lean_dec(x_8);
-return x_39;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
 lean_dec(x_21);
-x_40 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_40, x_19);
-x_42 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_16);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_11, x_8);
-lean_dec(x_8);
-return x_44;
-}
+if (lean_obj_tag(x_22) == 2)
+{
+lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 1);
+lean_inc(x_23);
+lean_dec(x_22);
+x_24 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_25 = lean_string_dec_eq(x_23, x_24);
+lean_dec(x_23);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_26 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18);
+x_28 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
 lean_dec(x_18);
-lean_dec(x_2);
-x_45 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_17, x_45, x_16);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_11, x_8);
-lean_dec(x_8);
-return x_47;
+x_31 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_19, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
 }
 }
-block_79:
+else
 {
-lean_object* x_50; 
-x_50 = lean_ctor_get(x_49, 3);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_22);
+x_34 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_34, x_18);
+x_36 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_20);
+x_39 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_39, x_18);
+x_41 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_44 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_16, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+block_78:
+{
+lean_object* x_49; 
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+x_50 = lean_ctor_get(x_48, 0);
 lean_inc(x_50);
-if (lean_obj_tag(x_50) == 0)
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-x_51 = lean_ctor_get(x_49, 0);
-lean_inc(x_51);
-x_52 = lean_array_get_size(x_51);
-lean_dec(x_51);
-x_53 = lean_ctor_get(x_49, 1);
-lean_inc(x_53);
-x_54 = l_Lean_Parser_termParser___closed__2;
-x_55 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_categoryParserFn(x_54, x_55, x_2, x_49);
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-lean_inc(x_2);
-x_58 = l_Lean_Parser_Term_parenSpecial___elambda__1(x_1, x_2, x_56);
-x_59 = lean_ctor_get(x_58, 3);
-lean_inc(x_59);
-if (lean_obj_tag(x_59) == 0)
-{
-lean_object* x_60; lean_object* x_61; 
-lean_dec(x_53);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_58, x_60, x_52);
-x_17 = x_61;
-goto block_48;
-}
-else
-{
-lean_object* x_62; uint8_t x_63; 
-lean_dec(x_59);
-x_62 = lean_ctor_get(x_58, 1);
-lean_inc(x_62);
-x_63 = lean_nat_dec_eq(x_62, x_53);
-lean_dec(x_62);
-if (x_63 == 0)
-{
-lean_object* x_64; lean_object* x_65; 
-lean_dec(x_53);
-x_64 = l_Lean_nullKind;
-x_65 = l_Lean_Parser_ParserState_mkNode(x_58, x_64, x_52);
-x_17 = x_65;
-goto block_48;
-}
-else
-{
-lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-x_66 = l_Lean_Parser_ParserState_restore(x_58, x_52, x_53);
-x_67 = l_Lean_nullKind;
-x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_52);
-x_17 = x_68;
-goto block_48;
-}
-}
-}
-else
-{
-lean_object* x_69; uint8_t x_70; 
-lean_dec(x_57);
-lean_dec(x_1);
-x_69 = lean_ctor_get(x_56, 1);
-lean_inc(x_69);
-x_70 = lean_nat_dec_eq(x_69, x_53);
-lean_dec(x_69);
-if (x_70 == 0)
-{
-lean_object* x_71; lean_object* x_72; 
-lean_dec(x_53);
-x_71 = l_Lean_nullKind;
-x_72 = l_Lean_Parser_ParserState_mkNode(x_56, x_71, x_52);
-x_17 = x_72;
-goto block_48;
-}
-else
-{
-lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_73 = l_Lean_Parser_ParserState_restore(x_56, x_52, x_53);
-x_74 = l_Lean_nullKind;
-x_75 = l_Lean_Parser_ParserState_mkNode(x_73, x_74, x_52);
-x_17 = x_75;
-goto block_48;
-}
-}
-}
-else
-{
-lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+x_51 = lean_array_get_size(x_50);
 lean_dec(x_50);
-lean_dec(x_2);
+x_52 = lean_ctor_get(x_48, 1);
+lean_inc(x_52);
+x_53 = l_Lean_Parser_termParser___closed__2;
+x_54 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_48);
+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; 
+lean_inc(x_1);
+x_57 = l_Lean_Parser_Term_parenSpecial___elambda__1(x_1, x_55);
+x_58 = lean_ctor_get(x_57, 3);
+lean_inc(x_58);
+if (lean_obj_tag(x_58) == 0)
+{
+lean_object* x_59; lean_object* x_60; 
+lean_dec(x_52);
+x_59 = l_Lean_nullKind;
+x_60 = l_Lean_Parser_ParserState_mkNode(x_57, x_59, x_51);
+x_16 = x_60;
+goto block_47;
+}
+else
+{
+lean_object* x_61; uint8_t x_62; 
+lean_dec(x_58);
+x_61 = lean_ctor_get(x_57, 1);
+lean_inc(x_61);
+x_62 = lean_nat_dec_eq(x_61, x_52);
+lean_dec(x_61);
+if (x_62 == 0)
+{
+lean_object* x_63; lean_object* x_64; 
+lean_dec(x_52);
+x_63 = l_Lean_nullKind;
+x_64 = l_Lean_Parser_ParserState_mkNode(x_57, x_63, x_51);
+x_16 = x_64;
+goto block_47;
+}
+else
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_65 = l_Lean_Parser_ParserState_restore(x_57, x_51, x_52);
+x_66 = l_Lean_nullKind;
+x_67 = l_Lean_Parser_ParserState_mkNode(x_65, x_66, x_51);
+x_16 = x_67;
+goto block_47;
+}
+}
+}
+else
+{
+lean_object* x_68; uint8_t x_69; 
+lean_dec(x_56);
+x_68 = lean_ctor_get(x_55, 1);
+lean_inc(x_68);
+x_69 = lean_nat_dec_eq(x_68, x_52);
+lean_dec(x_68);
+if (x_69 == 0)
+{
+lean_object* x_70; lean_object* x_71; 
+lean_dec(x_52);
+x_70 = l_Lean_nullKind;
+x_71 = l_Lean_Parser_ParserState_mkNode(x_55, x_70, x_51);
+x_16 = x_71;
+goto block_47;
+}
+else
+{
+lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+x_72 = l_Lean_Parser_ParserState_restore(x_55, x_51, x_52);
+x_73 = l_Lean_nullKind;
+x_74 = l_Lean_Parser_ParserState_mkNode(x_72, x_73, x_51);
+x_16 = x_74;
+goto block_47;
+}
+}
+}
+else
+{
+lean_object* x_75; lean_object* x_76; lean_object* x_77; 
+lean_dec(x_49);
 lean_dec(x_1);
-x_76 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
-x_77 = l_Lean_Parser_ParserState_mkNode(x_49, x_76, x_16);
-x_78 = l_Lean_Parser_mergeOrElseErrors(x_77, x_11, x_8);
-lean_dec(x_8);
-return x_78;
+x_75 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_76 = l_Lean_Parser_ParserState_mkNode(x_48, x_75, x_15);
+x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_10, x_7);
+lean_dec(x_7);
+return x_77;
 }
 }
 }
@@ -7866,7 +7681,7 @@ lean_object* _init_l_Lean_Parser_Term_paren___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_parenSpecial;
@@ -7890,7 +7705,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_paren___closed__2;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
@@ -7931,7 +7746,7 @@ lean_object* _init_l_Lean_Parser_Term_paren___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_paren___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_paren___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -7958,27 +7773,27 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_paren(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_paren;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = 0;
-x_9 = 1;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(x_1, x_2, x_7, x_8, x_9, x_3, x_4, x_5);
-return x_10;
+lean_object* x_4; lean_object* x_5; uint8_t x_6; uint8_t x_7; lean_object* x_8; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_6 = 0;
+x_7 = 1;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_tupleTail___elambda__1___spec__2(x_1, x_5, x_6, x_7, x_2, x_3);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__1() {
@@ -8012,13 +7827,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__5() {
@@ -8103,227 +7917,221 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_anonymousCtor___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_56; lean_object* x_57; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_54; lean_object* x_55; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_54 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_55 = lean_ctor_get(x_54, 3);
+lean_inc(x_55);
+if (lean_obj_tag(x_55) == 0)
 {
-lean_object* x_58; lean_object* x_59; 
-x_58 = lean_ctor_get(x_56, 0);
+lean_object* x_56; lean_object* x_57; 
+x_56 = lean_ctor_get(x_54, 0);
+lean_inc(x_56);
+x_57 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_56);
+lean_dec(x_56);
+if (lean_obj_tag(x_57) == 2)
+{
+lean_object* x_58; lean_object* x_59; uint8_t x_60; 
+x_58 = lean_ctor_get(x_57, 1);
 lean_inc(x_58);
-x_59 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_58);
+lean_dec(x_57);
+x_59 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__5;
+x_60 = lean_string_dec_eq(x_58, x_59);
 lean_dec(x_58);
-if (lean_obj_tag(x_59) == 2)
+if (x_60 == 0)
 {
-lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_60 = lean_ctor_get(x_59, 1);
-lean_inc(x_60);
-lean_dec(x_59);
-x_61 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__5;
-x_62 = lean_string_dec_eq(x_60, x_61);
-lean_dec(x_60);
-if (x_62 == 0)
+lean_object* x_61; lean_object* x_62; 
+x_61 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12;
+lean_inc(x_7);
+x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_7);
+x_16 = x_62;
+goto block_53;
+}
+else
+{
+x_16 = x_54;
+goto block_53;
+}
+}
+else
 {
 lean_object* x_63; lean_object* x_64; 
+lean_dec(x_57);
 x_63 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_8);
-x_17 = x_64;
-goto block_55;
-}
-else
-{
-x_17 = x_56;
-goto block_55;
+lean_inc(x_7);
+x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_63, x_7);
+x_16 = x_64;
+goto block_53;
 }
 }
 else
 {
 lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
+lean_dec(x_55);
 x_65 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_8);
-x_17 = x_66;
-goto block_55;
+lean_inc(x_7);
+x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_65, x_7);
+x_16 = x_66;
+goto block_53;
 }
-}
-else
+block_53:
 {
-lean_object* x_67; lean_object* x_68; 
-lean_dec(x_57);
-x_67 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12;
-lean_inc(x_8);
-x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_8);
-x_17 = x_68;
-goto block_55;
-}
-block_55:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+uint8_t x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = 0;
+lean_inc(x_1);
+x_19 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(x_18, x_1, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-uint8_t x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = 0;
-x_20 = 0;
-lean_inc(x_2);
-x_21 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(x_19, x_20, x_1, x_2, x_17);
-lean_dec(x_1);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_19, 1);
+lean_inc(x_21);
+x_22 = l_Lean_Parser_tokenFn(x_1, x_19);
+x_23 = lean_ctor_get(x_22, 3);
 lean_inc(x_23);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
+if (lean_obj_tag(x_23) == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
+lean_object* x_24; lean_object* x_25; 
+x_24 = lean_ctor_get(x_22, 0);
+lean_inc(x_24);
+x_25 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_24);
+lean_dec(x_24);
+if (lean_obj_tag(x_25) == 2)
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_25, 1);
 lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
-{
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__6;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_31 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
-x_33 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_16);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_8);
-lean_dec(x_8);
-return x_38;
-}
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_39 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
-x_41 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
 lean_dec(x_25);
-x_44 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
-x_46 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
+x_27 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__6;
+x_28 = lean_string_dec_eq(x_26, x_27);
+lean_dec(x_26);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_29 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9;
+x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+x_31 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_21);
+x_34 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
 }
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_22);
-lean_dec(x_2);
-x_49 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_16);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_11, x_8);
-lean_dec(x_8);
-return x_51;
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_25);
+x_37 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
+x_39 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_23);
+x_42 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9;
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
+x_44 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_20);
 lean_dec(x_1);
-x_52 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_17, x_52, x_16);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_8);
-lean_dec(x_8);
-return x_54;
+x_47 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_50 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_16, x_50, x_15);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_10, x_7);
+lean_dec(x_7);
+return x_52;
 }
 }
 }
@@ -8344,7 +8152,7 @@ lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_explicitUniv___closed__2;
@@ -8408,7 +8216,7 @@ lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_anonymousCtor___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_anonymousCtor___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -8432,232 +8240,226 @@ x_1 = l_Lean_Parser_Term_anonymousCtor___closed__9;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-uint8_t x_6; uint8_t x_7; lean_object* x_8; 
-x_6 = lean_unbox(x_1);
+uint8_t x_4; lean_object* x_5; 
+x_4 = lean_unbox(x_1);
 lean_dec(x_1);
-x_7 = lean_unbox(x_2);
-lean_dec(x_2);
-x_8 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(x_6, x_7, x_3, x_4, x_5);
-lean_dec(x_3);
-return x_8;
+x_5 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(x_4, x_2, x_3);
+return x_5;
 }
 }
 lean_object* l___regBuiltinParser_Lean_Parser_Term_anonymousCtor(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_anonymousCtor;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_Term_optIdent___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_optIdent___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; lean_object* x_32; lean_object* x_33; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_ctor_get(x_3, 1);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_6);
-lean_dec(x_6);
-lean_inc(x_2);
-x_32 = lean_apply_3(x_5, x_1, x_2, x_3);
+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_29; lean_object* x_30; 
+x_3 = lean_ctor_get(x_2, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_2, 1);
+lean_inc(x_4);
+x_5 = lean_array_get_size(x_3);
+lean_dec(x_3);
+lean_inc(x_1);
+x_29 = l_Lean_Parser_ident___elambda__1(x_1, x_2);
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_31 = lean_ctor_get(x_29, 1);
+lean_inc(x_31);
+x_32 = l_Lean_Parser_tokenFn(x_1, x_29);
 x_33 = lean_ctor_get(x_32, 3);
 lean_inc(x_33);
 if (lean_obj_tag(x_33) == 0)
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-x_34 = lean_ctor_get(x_32, 1);
+lean_object* x_34; lean_object* x_35; 
+x_34 = lean_ctor_get(x_32, 0);
 lean_inc(x_34);
-x_35 = l_Lean_Parser_tokenFn(x_2, x_32);
-x_36 = lean_ctor_get(x_35, 3);
-lean_inc(x_36);
-if (lean_obj_tag(x_36) == 0)
-{
-lean_object* x_37; lean_object* x_38; 
-x_37 = lean_ctor_get(x_35, 0);
-lean_inc(x_37);
-x_38 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_37);
-lean_dec(x_37);
-if (lean_obj_tag(x_38) == 2)
-{
-lean_object* x_39; lean_object* x_40; uint8_t x_41; 
-x_39 = lean_ctor_get(x_38, 1);
-lean_inc(x_39);
-lean_dec(x_38);
-x_40 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
-x_41 = lean_string_dec_eq(x_39, x_40);
-lean_dec(x_39);
-if (x_41 == 0)
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_42 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_35, x_42, x_34);
-x_44 = lean_ctor_get(x_43, 0);
-lean_inc(x_44);
-x_45 = lean_ctor_get(x_43, 2);
-lean_inc(x_45);
-x_46 = lean_ctor_get(x_43, 3);
-lean_inc(x_46);
-x_9 = x_43;
-x_10 = x_44;
-x_11 = x_45;
-x_12 = x_46;
-goto block_31;
-}
-else
-{
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_35 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_34);
 lean_dec(x_34);
-x_47 = lean_ctor_get(x_35, 0);
-lean_inc(x_47);
-x_48 = lean_ctor_get(x_35, 2);
-lean_inc(x_48);
-x_49 = lean_ctor_get(x_35, 3);
-lean_inc(x_49);
-x_9 = x_35;
-x_10 = x_47;
-x_11 = x_48;
-x_12 = x_49;
-goto block_31;
-}
-}
-else
+if (lean_obj_tag(x_35) == 2)
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_38);
-x_50 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_35, x_50, x_34);
-x_52 = lean_ctor_get(x_51, 0);
-lean_inc(x_52);
-x_53 = lean_ctor_get(x_51, 2);
-lean_inc(x_53);
-x_54 = lean_ctor_get(x_51, 3);
-lean_inc(x_54);
-x_9 = x_51;
-x_10 = x_52;
-x_11 = x_53;
-x_12 = x_54;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+lean_object* x_36; lean_object* x_37; uint8_t x_38; 
+x_36 = lean_ctor_get(x_35, 1);
+lean_inc(x_36);
+lean_dec(x_35);
+x_37 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
+x_38 = lean_string_dec_eq(x_36, x_37);
 lean_dec(x_36);
-x_55 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_35, x_55, x_34);
-x_57 = lean_ctor_get(x_56, 0);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_56, 2);
-lean_inc(x_58);
-x_59 = lean_ctor_get(x_56, 3);
-lean_inc(x_59);
-x_9 = x_56;
-x_10 = x_57;
-x_11 = x_58;
-x_12 = x_59;
-goto block_31;
+if (x_38 == 0)
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_39 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_39, x_31);
+x_41 = lean_ctor_get(x_40, 0);
+lean_inc(x_41);
+x_42 = lean_ctor_get(x_40, 2);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_40, 3);
+lean_inc(x_43);
+x_6 = x_40;
+x_7 = x_41;
+x_8 = x_42;
+x_9 = x_43;
+goto block_28;
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_31);
+x_44 = lean_ctor_get(x_32, 0);
+lean_inc(x_44);
+x_45 = lean_ctor_get(x_32, 2);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_32, 3);
+lean_inc(x_46);
+x_6 = x_32;
+x_7 = x_44;
+x_8 = x_45;
+x_9 = x_46;
+goto block_28;
 }
 }
 else
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_35);
+x_47 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_47, x_31);
+x_49 = lean_ctor_get(x_48, 0);
+lean_inc(x_49);
+x_50 = lean_ctor_get(x_48, 2);
+lean_inc(x_50);
+x_51 = lean_ctor_get(x_48, 3);
+lean_inc(x_51);
+x_6 = x_48;
+x_7 = x_49;
+x_8 = x_50;
+x_9 = x_51;
+goto block_28;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
 lean_dec(x_33);
-lean_dec(x_2);
-x_60 = lean_ctor_get(x_32, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_32, 2);
-lean_inc(x_61);
-x_62 = lean_ctor_get(x_32, 3);
-lean_inc(x_62);
-x_9 = x_32;
-x_10 = x_60;
-x_11 = x_61;
-x_12 = x_62;
-goto block_31;
+x_52 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_52, x_31);
+x_54 = lean_ctor_get(x_53, 0);
+lean_inc(x_54);
+x_55 = lean_ctor_get(x_53, 2);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_53, 3);
+lean_inc(x_56);
+x_6 = x_53;
+x_7 = x_54;
+x_8 = x_55;
+x_9 = x_56;
+goto block_28;
 }
-block_31:
-{
-if (lean_obj_tag(x_12) == 0)
-{
-lean_object* x_13; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_13 = lean_ctor_get(x_9, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
-{
-lean_object* x_14; lean_object* x_15; 
-lean_dec(x_7);
-x_14 = l_Lean_nullKind;
-x_15 = l_Lean_Parser_ParserState_mkNode(x_9, x_14, x_8);
-return x_15;
 }
 else
 {
-lean_object* x_16; uint8_t x_17; 
-lean_dec(x_13);
-x_16 = lean_ctor_get(x_9, 1);
-lean_inc(x_16);
-x_17 = lean_nat_dec_eq(x_16, x_7);
-lean_dec(x_16);
-if (x_17 == 0)
+lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+lean_dec(x_30);
+lean_dec(x_1);
+x_57 = lean_ctor_get(x_29, 0);
+lean_inc(x_57);
+x_58 = lean_ctor_get(x_29, 2);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_29, 3);
+lean_inc(x_59);
+x_6 = x_29;
+x_7 = x_57;
+x_8 = x_58;
+x_9 = x_59;
+goto block_28;
+}
+block_28:
 {
-lean_object* x_18; lean_object* x_19; 
+if (lean_obj_tag(x_9) == 0)
+{
+lean_object* x_10; 
+lean_dec(x_8);
 lean_dec(x_7);
+x_10 = lean_ctor_get(x_6, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_4);
+x_11 = l_Lean_nullKind;
+x_12 = l_Lean_Parser_ParserState_mkNode(x_6, x_11, x_5);
+return x_12;
+}
+else
+{
+lean_object* x_13; uint8_t x_14; 
+lean_dec(x_10);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_13, x_4);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_object* x_15; lean_object* x_16; 
+lean_dec(x_4);
+x_15 = l_Lean_nullKind;
+x_16 = l_Lean_Parser_ParserState_mkNode(x_6, x_15, x_5);
+return x_16;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+x_17 = l_Lean_Parser_ParserState_restore(x_6, x_5, x_4);
 x_18 = l_Lean_nullKind;
-x_19 = l_Lean_Parser_ParserState_mkNode(x_9, x_18, x_8);
+x_19 = l_Lean_Parser_ParserState_mkNode(x_17, x_18, x_5);
 return x_19;
 }
-else
-{
-lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_20 = l_Lean_Parser_ParserState_restore(x_9, x_8, x_7);
-x_21 = l_Lean_nullKind;
-x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_8);
-return x_22;
-}
 }
 }
 else
 {
-lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-lean_dec(x_9);
-x_23 = l_Array_shrink___main___rarg(x_10, x_8);
-lean_inc(x_7);
-x_24 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_24, 0, x_23);
-lean_ctor_set(x_24, 1, x_7);
-lean_ctor_set(x_24, 2, x_11);
-lean_ctor_set(x_24, 3, x_12);
-x_25 = lean_nat_dec_eq(x_7, x_7);
-if (x_25 == 0)
+lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+lean_dec(x_6);
+x_20 = l_Array_shrink___main___rarg(x_7, x_5);
+lean_inc(x_4);
+x_21 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_21, 0, x_20);
+lean_ctor_set(x_21, 1, x_4);
+lean_ctor_set(x_21, 2, x_8);
+lean_ctor_set(x_21, 3, x_9);
+x_22 = lean_nat_dec_eq(x_4, x_4);
+if (x_22 == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-lean_dec(x_7);
+lean_object* x_23; lean_object* x_24; 
+lean_dec(x_4);
+x_23 = l_Lean_nullKind;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_5);
+return x_24;
+}
+else
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_25 = l_Lean_Parser_ParserState_restore(x_21, x_5, x_4);
 x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_8);
+x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_5);
 return x_27;
 }
-else
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-x_28 = l_Lean_Parser_ParserState_restore(x_24, x_8, x_7);
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_8);
-return x_30;
-}
 }
 }
 }
@@ -8666,7 +8468,7 @@ lean_object* _init_l_Lean_Parser_Term_optIdent___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_typeAscription___closed__1;
@@ -8687,7 +8489,7 @@ lean_object* _init_l_Lean_Parser_Term_optIdent___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_optIdent___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_optIdent___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -8742,13 +8544,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_if___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_if___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_if___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_if___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__5() {
@@ -8910,352 +8711,348 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_if___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_if___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_if___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_if___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_57; lean_object* x_92; lean_object* x_93; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_92 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_93 = lean_ctor_get(x_92, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_56; lean_object* x_91; lean_object* x_92; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_91 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_92 = lean_ctor_get(x_91, 3);
+lean_inc(x_92);
+if (lean_obj_tag(x_92) == 0)
+{
+lean_object* x_93; lean_object* x_94; 
+x_93 = lean_ctor_get(x_91, 0);
 lean_inc(x_93);
-if (lean_obj_tag(x_93) == 0)
-{
-lean_object* x_94; lean_object* x_95; 
-x_94 = lean_ctor_get(x_92, 0);
-lean_inc(x_94);
-x_95 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_94);
-lean_dec(x_94);
-if (lean_obj_tag(x_95) == 2)
-{
-lean_object* x_96; lean_object* x_97; uint8_t x_98; 
-x_96 = lean_ctor_get(x_95, 1);
-lean_inc(x_96);
-lean_dec(x_95);
-x_97 = l_Lean_Parser_Term_if___elambda__1___closed__6;
-x_98 = lean_string_dec_eq(x_96, x_97);
-lean_dec(x_96);
-if (x_98 == 0)
-{
-lean_object* x_99; lean_object* x_100; 
-x_99 = l_Lean_Parser_Term_if___elambda__1___closed__20;
-lean_inc(x_8);
-x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_99, x_8);
-x_57 = x_100;
-goto block_91;
-}
-else
-{
-x_57 = x_92;
-goto block_91;
-}
-}
-else
-{
-lean_object* x_101; lean_object* x_102; 
-lean_dec(x_95);
-x_101 = l_Lean_Parser_Term_if___elambda__1___closed__20;
-lean_inc(x_8);
-x_102 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_101, x_8);
-x_57 = x_102;
-goto block_91;
-}
-}
-else
-{
-lean_object* x_103; lean_object* x_104; 
+x_94 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_93);
 lean_dec(x_93);
-x_103 = l_Lean_Parser_Term_if___elambda__1___closed__20;
-lean_inc(x_8);
-x_104 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_103, x_8);
-x_57 = x_104;
-goto block_91;
+if (lean_obj_tag(x_94) == 2)
+{
+lean_object* x_95; lean_object* x_96; uint8_t x_97; 
+x_95 = lean_ctor_get(x_94, 1);
+lean_inc(x_95);
+lean_dec(x_94);
+x_96 = l_Lean_Parser_Term_if___elambda__1___closed__6;
+x_97 = lean_string_dec_eq(x_95, x_96);
+lean_dec(x_95);
+if (x_97 == 0)
+{
+lean_object* x_98; lean_object* x_99; 
+x_98 = l_Lean_Parser_Term_if___elambda__1___closed__20;
+lean_inc(x_7);
+x_99 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_98, x_7);
+x_56 = x_99;
+goto block_90;
 }
-block_56:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_56 = x_91;
+goto block_90;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = lean_ctor_get(x_21, 3);
+lean_object* x_100; lean_object* x_101; 
+lean_dec(x_94);
+x_100 = l_Lean_Parser_Term_if___elambda__1___closed__20;
+lean_inc(x_7);
+x_101 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_100, x_7);
+x_56 = x_101;
+goto block_90;
+}
+}
+else
+{
+lean_object* x_102; lean_object* x_103; 
+lean_dec(x_92);
+x_102 = l_Lean_Parser_Term_if___elambda__1___closed__20;
+lean_inc(x_7);
+x_103 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_102, x_7);
+x_56 = x_103;
+goto block_90;
+}
+block_55:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_22 = lean_ctor_get(x_20, 1);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
+lean_inc(x_1);
+x_23 = l_Lean_Parser_tokenFn(x_1, x_20);
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
-lean_inc(x_23);
-lean_inc(x_2);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
+lean_object* x_25; lean_object* x_26; 
+x_25 = lean_ctor_get(x_23, 0);
 lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
-lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
-{
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l_Lean_Parser_Term_if___elambda__1___closed__10;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-lean_dec(x_2);
-x_31 = l_Lean_Parser_Term_if___elambda__1___closed__13;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
-x_33 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_24);
-x_37 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_16);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_8);
-lean_dec(x_8);
-return x_39;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-lean_dec(x_27);
-lean_dec(x_2);
-x_40 = l_Lean_Parser_Term_if___elambda__1___closed__13;
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_40, x_23);
-x_42 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_16);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_11, x_8);
-lean_dec(x_8);
-return x_44;
-}
-}
-else
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_26 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_25);
 lean_dec(x_25);
-lean_dec(x_2);
-x_45 = l_Lean_Parser_Term_if___elambda__1___closed__13;
-x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_45, x_23);
-x_47 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_16);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_11, x_8);
-lean_dec(x_8);
-return x_49;
-}
-}
-else
+if (lean_obj_tag(x_26) == 2)
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_22);
-lean_dec(x_2);
-x_50 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_21, x_50, x_16);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_11, x_8);
-lean_dec(x_8);
-return x_52;
-}
-}
-else
+lean_object* x_27; lean_object* x_28; uint8_t x_29; 
+x_27 = lean_ctor_get(x_26, 1);
+lean_inc(x_27);
+lean_dec(x_26);
+x_28 = l_Lean_Parser_Term_if___elambda__1___closed__10;
+x_29 = lean_string_dec_eq(x_27, x_28);
+lean_dec(x_27);
+if (x_29 == 0)
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_53 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_54 = l_Lean_Parser_ParserState_mkNode(x_17, x_53, x_16);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_11, x_8);
-lean_dec(x_8);
-return x_55;
-}
-}
-block_91:
-{
-lean_object* x_58; 
-x_58 = lean_ctor_get(x_57, 3);
-lean_inc(x_58);
-if (lean_obj_tag(x_58) == 0)
-{
-lean_object* x_59; lean_object* x_60; 
-lean_inc(x_2);
-x_59 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_2, x_57);
-x_60 = lean_ctor_get(x_59, 3);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_61 = l_Lean_Parser_termParser___closed__2;
-x_62 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_63 = l_Lean_Parser_categoryParserFn(x_61, x_62, x_2, x_59);
-x_64 = lean_ctor_get(x_63, 3);
-lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
-{
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-x_65 = lean_ctor_get(x_63, 1);
-lean_inc(x_65);
-lean_inc(x_2);
-x_66 = l_Lean_Parser_tokenFn(x_2, x_63);
-x_67 = lean_ctor_get(x_66, 3);
-lean_inc(x_67);
-if (lean_obj_tag(x_67) == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = lean_ctor_get(x_66, 0);
-lean_inc(x_68);
-x_69 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_68);
-lean_dec(x_68);
-if (lean_obj_tag(x_69) == 2)
-{
-lean_object* x_70; lean_object* x_71; uint8_t x_72; 
-x_70 = lean_ctor_get(x_69, 1);
-lean_inc(x_70);
-lean_dec(x_69);
-x_71 = l_Lean_Parser_Term_if___elambda__1___closed__8;
-x_72 = lean_string_dec_eq(x_70, x_71);
-lean_dec(x_70);
-if (x_72 == 0)
-{
-lean_object* x_73; lean_object* x_74; 
-x_73 = l_Lean_Parser_Term_if___elambda__1___closed__16;
-x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_73, x_65);
-x_17 = x_74;
-goto block_56;
-}
-else
-{
-lean_dec(x_65);
-x_17 = x_66;
-goto block_56;
-}
-}
-else
-{
-lean_object* x_75; lean_object* x_76; 
-lean_dec(x_69);
-x_75 = l_Lean_Parser_Term_if___elambda__1___closed__16;
-x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_75, x_65);
-x_17 = x_76;
-goto block_56;
-}
-}
-else
-{
-lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-lean_dec(x_67);
-lean_dec(x_2);
-x_77 = l_Lean_Parser_Term_if___elambda__1___closed__16;
-x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_77, x_65);
-x_79 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_80 = l_Lean_Parser_ParserState_mkNode(x_78, x_79, x_16);
-x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_11, x_8);
-lean_dec(x_8);
-return x_81;
-}
-}
-else
-{
-lean_object* x_82; lean_object* x_83; lean_object* x_84; 
-lean_dec(x_64);
-lean_dec(x_2);
-x_82 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_83 = l_Lean_Parser_ParserState_mkNode(x_63, x_82, x_16);
-x_84 = l_Lean_Parser_mergeOrElseErrors(x_83, x_11, x_8);
-lean_dec(x_8);
-return x_84;
-}
-}
-else
-{
-lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-lean_dec(x_60);
-lean_dec(x_2);
-x_85 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_86 = l_Lean_Parser_ParserState_mkNode(x_59, x_85, x_16);
-x_87 = l_Lean_Parser_mergeOrElseErrors(x_86, x_11, x_8);
-lean_dec(x_8);
-return x_87;
-}
-}
-else
-{
-lean_object* x_88; lean_object* x_89; lean_object* x_90; 
-lean_dec(x_58);
-lean_dec(x_2);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
 lean_dec(x_1);
-x_88 = l_Lean_Parser_Term_if___elambda__1___closed__2;
-x_89 = l_Lean_Parser_ParserState_mkNode(x_57, x_88, x_16);
-x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_11, x_8);
-lean_dec(x_8);
-return x_90;
+x_30 = l_Lean_Parser_Term_if___elambda__1___closed__13;
+x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22);
+x_32 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
+}
+else
+{
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_22);
+x_35 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_23);
+x_36 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_26);
+lean_dec(x_1);
+x_39 = l_Lean_Parser_Term_if___elambda__1___closed__13;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_39, x_22);
+x_41 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_24);
+lean_dec(x_1);
+x_44 = l_Lean_Parser_Term_if___elambda__1___closed__13;
+x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_44, x_22);
+x_46 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_15);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_7);
+lean_dec(x_7);
+return x_48;
+}
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_21);
+lean_dec(x_1);
+x_49 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_20, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
+return x_51;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_52 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_16, x_52, x_15);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_10, x_7);
+lean_dec(x_7);
+return x_54;
+}
+}
+block_90:
+{
+lean_object* x_57; 
+x_57 = lean_ctor_get(x_56, 3);
+lean_inc(x_57);
+if (lean_obj_tag(x_57) == 0)
+{
+lean_object* x_58; lean_object* x_59; 
+lean_inc(x_1);
+x_58 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_56);
+x_59 = lean_ctor_get(x_58, 3);
+lean_inc(x_59);
+if (lean_obj_tag(x_59) == 0)
+{
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_60 = l_Lean_Parser_termParser___closed__2;
+x_61 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_62 = l_Lean_Parser_categoryParser___elambda__1(x_60, x_61, x_1, x_58);
+x_63 = lean_ctor_get(x_62, 3);
+lean_inc(x_63);
+if (lean_obj_tag(x_63) == 0)
+{
+lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+x_64 = lean_ctor_get(x_62, 1);
+lean_inc(x_64);
+lean_inc(x_1);
+x_65 = l_Lean_Parser_tokenFn(x_1, x_62);
+x_66 = lean_ctor_get(x_65, 3);
+lean_inc(x_66);
+if (lean_obj_tag(x_66) == 0)
+{
+lean_object* x_67; lean_object* x_68; 
+x_67 = lean_ctor_get(x_65, 0);
+lean_inc(x_67);
+x_68 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_67);
+lean_dec(x_67);
+if (lean_obj_tag(x_68) == 2)
+{
+lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_69 = lean_ctor_get(x_68, 1);
+lean_inc(x_69);
+lean_dec(x_68);
+x_70 = l_Lean_Parser_Term_if___elambda__1___closed__8;
+x_71 = lean_string_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_Parser_Term_if___elambda__1___closed__16;
+x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_72, x_64);
+x_16 = x_73;
+goto block_55;
+}
+else
+{
+lean_dec(x_64);
+x_16 = x_65;
+goto block_55;
+}
+}
+else
+{
+lean_object* x_74; lean_object* x_75; 
+lean_dec(x_68);
+x_74 = l_Lean_Parser_Term_if___elambda__1___closed__16;
+x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_74, x_64);
+x_16 = x_75;
+goto block_55;
+}
+}
+else
+{
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; 
+lean_dec(x_66);
+lean_dec(x_1);
+x_76 = l_Lean_Parser_Term_if___elambda__1___closed__16;
+x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_76, x_64);
+x_78 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_79 = l_Lean_Parser_ParserState_mkNode(x_77, x_78, x_15);
+x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_10, x_7);
+lean_dec(x_7);
+return x_80;
+}
+}
+else
+{
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+lean_dec(x_63);
+lean_dec(x_1);
+x_81 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_82 = l_Lean_Parser_ParserState_mkNode(x_62, x_81, x_15);
+x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_10, x_7);
+lean_dec(x_7);
+return x_83;
+}
+}
+else
+{
+lean_object* x_84; lean_object* x_85; lean_object* x_86; 
+lean_dec(x_59);
+lean_dec(x_1);
+x_84 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_85 = l_Lean_Parser_ParserState_mkNode(x_58, x_84, x_15);
+x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_10, x_7);
+lean_dec(x_7);
+return x_86;
+}
+}
+else
+{
+lean_object* x_87; lean_object* x_88; lean_object* x_89; 
+lean_dec(x_57);
+lean_dec(x_1);
+x_87 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_88 = l_Lean_Parser_ParserState_mkNode(x_56, x_87, x_15);
+x_89 = l_Lean_Parser_mergeOrElseErrors(x_88, x_10, x_7);
+lean_dec(x_7);
+return x_89;
 }
 }
 }
@@ -9296,7 +9093,7 @@ lean_object* _init_l_Lean_Parser_Term_if___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_if___closed__3;
@@ -9308,7 +9105,7 @@ lean_object* _init_l_Lean_Parser_Term_if___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_if___closed__4;
@@ -9330,7 +9127,7 @@ lean_object* _init_l_Lean_Parser_Term_if___closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_if___closed__6;
@@ -9386,7 +9183,7 @@ lean_object* _init_l_Lean_Parser_Term_if___closed__12() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_if___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_if___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -9413,10 +9210,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_if(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_if___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_if;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -9453,13 +9250,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_fromTerm___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_fromTerm___elambda__1___closed__5() {
@@ -9511,141 +9307,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_fromTerm___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_fromTerm___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_fromTerm___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__9;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__9;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_fromTerm___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -9666,7 +9462,7 @@ lean_object* _init_l_Lean_Parser_Term_fromTerm___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_fromTerm___closed__1;
@@ -9700,7 +9496,7 @@ lean_object* _init_l_Lean_Parser_Term_fromTerm___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_fromTerm___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_fromTerm___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -9755,13 +9551,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_haveAssign___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_haveAssign___elambda__1___closed__5() {
@@ -9805,141 +9600,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_haveAssign___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_haveAssign___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_haveAssign___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -9960,7 +9755,7 @@ lean_object* _init_l_Lean_Parser_Term_haveAssign___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_haveAssign___closed__1;
@@ -9994,7 +9789,7 @@ lean_object* _init_l_Lean_Parser_Term_haveAssign___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_haveAssign___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_haveAssign___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -10049,13 +9844,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_have___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_have___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_have___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_have___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_have___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_have___elambda__1___closed__5() {
@@ -10148,400 +9942,390 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_have___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_have___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_have___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_have___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_52; lean_object* x_108; lean_object* x_109; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_108 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_109 = lean_ctor_get(x_108, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_51; lean_object* x_107; lean_object* x_108; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_107 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_108 = lean_ctor_get(x_107, 3);
+lean_inc(x_108);
+if (lean_obj_tag(x_108) == 0)
+{
+lean_object* x_109; lean_object* x_110; 
+x_109 = lean_ctor_get(x_107, 0);
 lean_inc(x_109);
-if (lean_obj_tag(x_109) == 0)
-{
-lean_object* x_110; lean_object* x_111; 
-x_110 = lean_ctor_get(x_108, 0);
-lean_inc(x_110);
-x_111 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_110);
-lean_dec(x_110);
-if (lean_obj_tag(x_111) == 2)
-{
-lean_object* x_112; lean_object* x_113; uint8_t x_114; 
-x_112 = lean_ctor_get(x_111, 1);
-lean_inc(x_112);
-lean_dec(x_111);
-x_113 = l_Lean_Parser_Term_have___elambda__1___closed__6;
-x_114 = lean_string_dec_eq(x_112, x_113);
-lean_dec(x_112);
-if (x_114 == 0)
-{
-lean_object* x_115; lean_object* x_116; 
-x_115 = l_Lean_Parser_Term_have___elambda__1___closed__13;
-lean_inc(x_8);
-x_116 = l_Lean_Parser_ParserState_mkErrorsAt(x_108, x_115, x_8);
-x_52 = x_116;
-goto block_107;
-}
-else
-{
-x_52 = x_108;
-goto block_107;
-}
-}
-else
-{
-lean_object* x_117; lean_object* x_118; 
-lean_dec(x_111);
-x_117 = l_Lean_Parser_Term_have___elambda__1___closed__13;
-lean_inc(x_8);
-x_118 = l_Lean_Parser_ParserState_mkErrorsAt(x_108, x_117, x_8);
-x_52 = x_118;
-goto block_107;
-}
-}
-else
-{
-lean_object* x_119; lean_object* x_120; 
+x_110 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_109);
 lean_dec(x_109);
-x_119 = l_Lean_Parser_Term_have___elambda__1___closed__13;
-lean_inc(x_8);
-x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_108, x_119, x_8);
-x_52 = x_120;
-goto block_107;
-}
-block_51:
+if (lean_obj_tag(x_110) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_111; lean_object* x_112; uint8_t x_113; 
+x_111 = lean_ctor_get(x_110, 1);
+lean_inc(x_111);
+lean_dec(x_110);
+x_112 = l_Lean_Parser_Term_have___elambda__1___closed__6;
+x_113 = lean_string_dec_eq(x_111, x_112);
+lean_dec(x_111);
+if (x_113 == 0)
+{
+lean_object* x_114; lean_object* x_115; 
+x_114 = l_Lean_Parser_Term_have___elambda__1___closed__13;
+lean_inc(x_7);
+x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_107, x_114, x_7);
+x_51 = x_115;
+goto block_106;
+}
+else
+{
+x_51 = x_107;
+goto block_106;
+}
+}
+else
+{
+lean_object* x_116; lean_object* x_117; 
+lean_dec(x_110);
+x_116 = l_Lean_Parser_Term_have___elambda__1___closed__13;
+lean_inc(x_7);
+x_117 = l_Lean_Parser_ParserState_mkErrorsAt(x_107, x_116, x_7);
+x_51 = x_117;
+goto block_106;
+}
+}
+else
+{
+lean_object* x_118; lean_object* x_119; 
+lean_dec(x_108);
+x_118 = l_Lean_Parser_Term_have___elambda__1___closed__13;
+lean_inc(x_7);
+x_119 = l_Lean_Parser_ParserState_mkErrorsAt(x_107, x_118, x_7);
+x_51 = x_119;
+goto block_106;
+}
+block_50:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_16, 1);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_inc(x_1);
+x_19 = l_Lean_Parser_tokenFn(x_1, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = lean_ctor_get(x_17, 1);
-lean_inc(x_19);
-lean_inc(x_2);
-x_20 = l_Lean_Parser_tokenFn(x_2, x_17);
-x_21 = lean_ctor_get(x_20, 3);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_object* x_22; lean_object* x_23; 
-x_22 = lean_ctor_get(x_20, 0);
-lean_inc(x_22);
-x_23 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_22);
-lean_dec(x_22);
-if (lean_obj_tag(x_23) == 2)
-{
-lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_24 = lean_ctor_get(x_23, 1);
-lean_inc(x_24);
-lean_dec(x_23);
-x_25 = l_Lean_Parser_Term_have___elambda__1___closed__7;
-x_26 = lean_string_dec_eq(x_24, x_25);
-lean_dec(x_24);
-if (x_26 == 0)
-{
-lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-lean_dec(x_2);
-x_27 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_27, x_19);
-x_29 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_16);
-x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_11, x_8);
-lean_dec(x_8);
-return x_31;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_19);
-x_32 = l_Lean_Parser_termParser___closed__2;
-x_33 = lean_unsigned_to_nat(0u);
-x_34 = l_Lean_Parser_categoryParserFn(x_32, x_33, x_2, x_20);
-x_35 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_16);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_11, x_8);
-lean_dec(x_8);
-return x_37;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-lean_dec(x_23);
-lean_dec(x_2);
-x_38 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_38, x_19);
-x_40 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_16);
-x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_11, x_8);
-lean_dec(x_8);
-return x_42;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
 lean_dec(x_21);
-lean_dec(x_2);
-x_43 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_43, x_19);
-x_45 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_16);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_11, x_8);
-lean_dec(x_8);
-return x_47;
-}
+if (lean_obj_tag(x_22) == 2)
+{
+lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 1);
+lean_inc(x_23);
+lean_dec(x_22);
+x_24 = l_Lean_Parser_Term_have___elambda__1___closed__7;
+x_25 = lean_string_dec_eq(x_23, x_24);
+lean_dec(x_23);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_1);
+x_26 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18);
+x_28 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
 }
 else
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
 lean_dec(x_18);
-lean_dec(x_2);
-x_48 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_17, x_48, x_16);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_11, x_8);
-lean_dec(x_8);
-return x_50;
+x_31 = l_Lean_Parser_termParser___closed__2;
+x_32 = lean_unsigned_to_nat(0u);
+x_33 = l_Lean_Parser_categoryParser___elambda__1(x_31, x_32, x_1, x_19);
+x_34 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
 }
 }
-block_107:
+else
 {
-lean_object* x_53; 
-x_53 = lean_ctor_get(x_52, 3);
-lean_inc(x_53);
-if (lean_obj_tag(x_53) == 0)
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_22);
+lean_dec(x_1);
+x_37 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_37, x_18);
+x_39 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
+}
+}
+else
 {
-lean_object* x_54; lean_object* x_55; 
-lean_inc(x_2);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_20);
+lean_dec(x_1);
+x_42 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_42, x_18);
+x_44 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_47 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_16, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
+}
+}
+block_106:
+{
+lean_object* x_52; 
+x_52 = lean_ctor_get(x_51, 3);
+lean_inc(x_52);
+if (lean_obj_tag(x_52) == 0)
+{
+lean_object* x_53; lean_object* x_54; 
 lean_inc(x_1);
-x_54 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_2, x_52);
-x_55 = lean_ctor_get(x_54, 3);
-lean_inc(x_55);
-if (lean_obj_tag(x_55) == 0)
+x_53 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_51);
+x_54 = lean_ctor_get(x_53, 3);
+lean_inc(x_54);
+if (lean_obj_tag(x_54) == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_56 = l_Lean_Parser_termParser___closed__2;
-x_57 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_58 = l_Lean_Parser_categoryParserFn(x_56, x_57, x_2, x_54);
-x_59 = lean_ctor_get(x_58, 3);
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_55 = l_Lean_Parser_termParser___closed__2;
+x_56 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_57 = l_Lean_Parser_categoryParser___elambda__1(x_55, x_56, x_1, x_53);
+x_58 = lean_ctor_get(x_57, 3);
+lean_inc(x_58);
+if (lean_obj_tag(x_58) == 0)
+{
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_59 = lean_ctor_get(x_57, 0);
 lean_inc(x_59);
-if (lean_obj_tag(x_59) == 0)
-{
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_60 = lean_ctor_get(x_58, 0);
-lean_inc(x_60);
-x_61 = lean_array_get_size(x_60);
-lean_dec(x_60);
-x_62 = lean_ctor_get(x_58, 1);
-lean_inc(x_62);
-lean_inc(x_2);
-lean_inc(x_1);
-x_63 = l_Lean_Parser_Term_haveAssign___elambda__1(x_1, x_2, x_58);
-x_64 = lean_ctor_get(x_63, 3);
-lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
-{
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-lean_dec(x_62);
-lean_dec(x_61);
-lean_dec(x_1);
-x_65 = lean_ctor_get(x_63, 1);
-lean_inc(x_65);
-lean_inc(x_2);
-x_66 = l_Lean_Parser_tokenFn(x_2, x_63);
-x_67 = lean_ctor_get(x_66, 3);
-lean_inc(x_67);
-if (lean_obj_tag(x_67) == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = lean_ctor_get(x_66, 0);
-lean_inc(x_68);
-x_69 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_68);
-lean_dec(x_68);
-if (lean_obj_tag(x_69) == 2)
-{
-lean_object* x_70; lean_object* x_71; uint8_t x_72; 
-x_70 = lean_ctor_get(x_69, 1);
-lean_inc(x_70);
-lean_dec(x_69);
-x_71 = l_Lean_Parser_Term_have___elambda__1___closed__7;
-x_72 = lean_string_dec_eq(x_70, x_71);
-lean_dec(x_70);
-if (x_72 == 0)
-{
-lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; 
-lean_dec(x_2);
-x_73 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_73, x_65);
-x_75 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_76 = l_Lean_Parser_ParserState_mkNode(x_74, x_75, x_16);
-x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_11, x_8);
-lean_dec(x_8);
-return x_77;
-}
-else
-{
-lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-lean_dec(x_65);
-x_78 = l_Lean_Parser_categoryParserFn(x_56, x_57, x_2, x_66);
-x_79 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_80 = l_Lean_Parser_ParserState_mkNode(x_78, x_79, x_16);
-x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_11, x_8);
-lean_dec(x_8);
-return x_81;
-}
-}
-else
-{
-lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-lean_dec(x_69);
-lean_dec(x_2);
-x_82 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_83 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_82, x_65);
-x_84 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_85 = l_Lean_Parser_ParserState_mkNode(x_83, x_84, x_16);
-x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_11, x_8);
-lean_dec(x_8);
-return x_86;
-}
-}
-else
-{
-lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
-lean_dec(x_67);
-lean_dec(x_2);
-x_87 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_87, x_65);
-x_89 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_90 = l_Lean_Parser_ParserState_mkNode(x_88, x_89, x_16);
-x_91 = l_Lean_Parser_mergeOrElseErrors(x_90, x_11, x_8);
-lean_dec(x_8);
-return x_91;
-}
-}
-else
-{
-lean_object* x_92; lean_object* x_93; uint8_t x_94; 
-x_92 = lean_ctor_get(x_64, 0);
-lean_inc(x_92);
-lean_dec(x_64);
-x_93 = lean_ctor_get(x_63, 1);
-lean_inc(x_93);
-x_94 = lean_nat_dec_eq(x_93, x_62);
-lean_dec(x_93);
-if (x_94 == 0)
-{
-lean_dec(x_92);
-lean_dec(x_62);
-lean_dec(x_61);
-lean_dec(x_1);
-x_17 = x_63;
-goto block_51;
-}
-else
-{
-lean_object* x_95; lean_object* x_96; lean_object* x_97; 
-lean_inc(x_62);
-x_95 = l_Lean_Parser_ParserState_restore(x_63, x_61, x_62);
-lean_dec(x_61);
-lean_inc(x_2);
-x_96 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_2, x_95);
-x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_92, x_62);
-lean_dec(x_62);
-x_17 = x_97;
-goto block_51;
-}
-}
-}
-else
-{
-lean_object* x_98; lean_object* x_99; lean_object* x_100; 
+x_60 = lean_array_get_size(x_59);
 lean_dec(x_59);
-lean_dec(x_2);
+x_61 = lean_ctor_get(x_57, 1);
+lean_inc(x_61);
+lean_inc(x_1);
+x_62 = l_Lean_Parser_Term_haveAssign___elambda__1(x_1, x_57);
+x_63 = lean_ctor_get(x_62, 3);
+lean_inc(x_63);
+if (lean_obj_tag(x_63) == 0)
+{
+lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+lean_dec(x_61);
+lean_dec(x_60);
+x_64 = lean_ctor_get(x_62, 1);
+lean_inc(x_64);
+lean_inc(x_1);
+x_65 = l_Lean_Parser_tokenFn(x_1, x_62);
+x_66 = lean_ctor_get(x_65, 3);
+lean_inc(x_66);
+if (lean_obj_tag(x_66) == 0)
+{
+lean_object* x_67; lean_object* x_68; 
+x_67 = lean_ctor_get(x_65, 0);
+lean_inc(x_67);
+x_68 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_67);
+lean_dec(x_67);
+if (lean_obj_tag(x_68) == 2)
+{
+lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_69 = lean_ctor_get(x_68, 1);
+lean_inc(x_69);
+lean_dec(x_68);
+x_70 = l_Lean_Parser_Term_have___elambda__1___closed__7;
+x_71 = lean_string_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; 
 lean_dec(x_1);
-x_98 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_99 = l_Lean_Parser_ParserState_mkNode(x_58, x_98, x_16);
-x_100 = l_Lean_Parser_mergeOrElseErrors(x_99, x_11, x_8);
-lean_dec(x_8);
-return x_100;
+x_72 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_72, x_64);
+x_74 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_73, x_74, x_15);
+x_76 = l_Lean_Parser_mergeOrElseErrors(x_75, x_10, x_7);
+lean_dec(x_7);
+return x_76;
+}
+else
+{
+lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; 
+lean_dec(x_64);
+x_77 = l_Lean_Parser_categoryParser___elambda__1(x_55, x_56, x_1, x_65);
+x_78 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_79 = l_Lean_Parser_ParserState_mkNode(x_77, x_78, x_15);
+x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_10, x_7);
+lean_dec(x_7);
+return x_80;
 }
 }
 else
 {
-lean_object* x_101; lean_object* x_102; lean_object* x_103; 
-lean_dec(x_55);
-lean_dec(x_2);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+lean_dec(x_68);
 lean_dec(x_1);
-x_101 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_102 = l_Lean_Parser_ParserState_mkNode(x_54, x_101, x_16);
-x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_11, x_8);
-lean_dec(x_8);
-return x_103;
+x_81 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_82 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_81, x_64);
+x_83 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_84 = l_Lean_Parser_ParserState_mkNode(x_82, x_83, x_15);
+x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_10, x_7);
+lean_dec(x_7);
+return x_85;
 }
 }
 else
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; 
-lean_dec(x_53);
-lean_dec(x_2);
+lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
+lean_dec(x_66);
 lean_dec(x_1);
-x_104 = l_Lean_Parser_Term_have___elambda__1___closed__2;
-x_105 = l_Lean_Parser_ParserState_mkNode(x_52, x_104, x_16);
-x_106 = l_Lean_Parser_mergeOrElseErrors(x_105, x_11, x_8);
-lean_dec(x_8);
-return x_106;
+x_86 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_86, x_64);
+x_88 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_15);
+x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_10, x_7);
+lean_dec(x_7);
+return x_90;
+}
+}
+else
+{
+lean_object* x_91; lean_object* x_92; uint8_t x_93; 
+x_91 = lean_ctor_get(x_63, 0);
+lean_inc(x_91);
+lean_dec(x_63);
+x_92 = lean_ctor_get(x_62, 1);
+lean_inc(x_92);
+x_93 = lean_nat_dec_eq(x_92, x_61);
+lean_dec(x_92);
+if (x_93 == 0)
+{
+lean_dec(x_91);
+lean_dec(x_61);
+lean_dec(x_60);
+x_16 = x_62;
+goto block_50;
+}
+else
+{
+lean_object* x_94; lean_object* x_95; lean_object* x_96; 
+lean_inc(x_61);
+x_94 = l_Lean_Parser_ParserState_restore(x_62, x_60, x_61);
+lean_dec(x_60);
+lean_inc(x_1);
+x_95 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_94);
+x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_91, x_61);
+lean_dec(x_61);
+x_16 = x_96;
+goto block_50;
+}
+}
+}
+else
+{
+lean_object* x_97; lean_object* x_98; lean_object* x_99; 
+lean_dec(x_58);
+lean_dec(x_1);
+x_97 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_98 = l_Lean_Parser_ParserState_mkNode(x_57, x_97, x_15);
+x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_10, x_7);
+lean_dec(x_7);
+return x_99;
+}
+}
+else
+{
+lean_object* x_100; lean_object* x_101; lean_object* x_102; 
+lean_dec(x_54);
+lean_dec(x_1);
+x_100 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_101 = l_Lean_Parser_ParserState_mkNode(x_53, x_100, x_15);
+x_102 = l_Lean_Parser_mergeOrElseErrors(x_101, x_10, x_7);
+lean_dec(x_7);
+return x_102;
+}
+}
+else
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; 
+lean_dec(x_52);
+lean_dec(x_1);
+x_103 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_104 = l_Lean_Parser_ParserState_mkNode(x_51, x_103, x_15);
+x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_10, x_7);
+lean_dec(x_7);
+return x_105;
 }
 }
 }
@@ -10586,7 +10370,7 @@ lean_object* _init_l_Lean_Parser_Term_have___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_have___closed__3;
@@ -10608,7 +10392,7 @@ lean_object* _init_l_Lean_Parser_Term_have___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_have___closed__5;
@@ -10664,7 +10448,7 @@ lean_object* _init_l_Lean_Parser_Term_have___closed__11() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_have___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_have___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -10691,10 +10475,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_have(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_have___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_have;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -10731,13 +10515,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_suffices___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_suffices___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_suffices___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_suffices___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_suffices___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_suffices___elambda__1___closed__5() {
@@ -10789,272 +10572,265 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_suffices___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_suffices___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_suffices___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_suffices___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_67; lean_object* x_68; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_67 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_68 = lean_ctor_get(x_67, 3);
-lean_inc(x_68);
-if (lean_obj_tag(x_68) == 0)
-{
-lean_object* x_69; lean_object* x_70; 
-x_69 = lean_ctor_get(x_67, 0);
-lean_inc(x_69);
-x_70 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_69);
-lean_dec(x_69);
-if (lean_obj_tag(x_70) == 2)
-{
-lean_object* x_71; lean_object* x_72; uint8_t x_73; 
-x_71 = lean_ctor_get(x_70, 1);
-lean_inc(x_71);
-lean_dec(x_70);
-x_72 = l_Lean_Parser_Term_suffices___elambda__1___closed__6;
-x_73 = lean_string_dec_eq(x_71, x_72);
-lean_dec(x_71);
-if (x_73 == 0)
-{
-lean_object* x_74; lean_object* x_75; 
-x_74 = l_Lean_Parser_Term_suffices___elambda__1___closed__9;
-lean_inc(x_8);
-x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_74, x_8);
-x_17 = x_75;
-goto block_66;
-}
-else
-{
-x_17 = x_67;
-goto block_66;
-}
-}
-else
-{
-lean_object* x_76; lean_object* x_77; 
-lean_dec(x_70);
-x_76 = l_Lean_Parser_Term_suffices___elambda__1___closed__9;
-lean_inc(x_8);
-x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_76, x_8);
-x_17 = x_77;
-goto block_66;
-}
-}
-else
-{
-lean_object* x_78; lean_object* x_79; 
-lean_dec(x_68);
-x_78 = l_Lean_Parser_Term_suffices___elambda__1___closed__9;
-lean_inc(x_8);
-x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_78, x_8);
-x_17 = x_79;
-goto block_66;
-}
-block_66:
-{
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_66; lean_object* x_67; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
 lean_inc(x_1);
-x_19 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_66 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_67 = lean_ctor_get(x_66, 3);
+lean_inc(x_67);
+if (lean_obj_tag(x_67) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_termParser___closed__2;
-x_22 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = lean_ctor_get(x_23, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
+lean_object* x_68; lean_object* x_69; 
+x_68 = lean_ctor_get(x_66, 0);
+lean_inc(x_68);
+x_69 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_68);
+lean_dec(x_68);
+if (lean_obj_tag(x_69) == 2)
 {
-lean_object* x_25; lean_object* x_26; 
-lean_inc(x_2);
-x_25 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_2, x_23);
-x_26 = lean_ctor_get(x_25, 3);
+lean_object* x_70; lean_object* x_71; uint8_t x_72; 
+x_70 = lean_ctor_get(x_69, 1);
+lean_inc(x_70);
+lean_dec(x_69);
+x_71 = l_Lean_Parser_Term_suffices___elambda__1___closed__6;
+x_72 = lean_string_dec_eq(x_70, x_71);
+lean_dec(x_70);
+if (x_72 == 0)
+{
+lean_object* x_73; lean_object* x_74; 
+x_73 = l_Lean_Parser_Term_suffices___elambda__1___closed__9;
+lean_inc(x_7);
+x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_73, x_7);
+x_16 = x_74;
+goto block_65;
+}
+else
+{
+x_16 = x_66;
+goto block_65;
+}
+}
+else
+{
+lean_object* x_75; lean_object* x_76; 
+lean_dec(x_69);
+x_75 = l_Lean_Parser_Term_suffices___elambda__1___closed__9;
+lean_inc(x_7);
+x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_75, x_7);
+x_16 = x_76;
+goto block_65;
+}
+}
+else
+{
+lean_object* x_77; lean_object* x_78; 
+lean_dec(x_67);
+x_77 = l_Lean_Parser_Term_suffices___elambda__1___closed__9;
+lean_inc(x_7);
+x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_77, x_7);
+x_16 = x_78;
+goto block_65;
+}
+block_65:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = l_Lean_Parser_termParser___closed__2;
+x_21 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+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_inc(x_1);
+x_24 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_22);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+x_26 = lean_ctor_get(x_24, 1);
 lean_inc(x_26);
-if (lean_obj_tag(x_26) == 0)
+lean_inc(x_1);
+x_27 = l_Lean_Parser_tokenFn(x_1, x_24);
+x_28 = lean_ctor_get(x_27, 3);
+lean_inc(x_28);
+if (lean_obj_tag(x_28) == 0)
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_27 = lean_ctor_get(x_25, 1);
-lean_inc(x_27);
-lean_inc(x_2);
-x_28 = l_Lean_Parser_tokenFn(x_2, x_25);
-x_29 = lean_ctor_get(x_28, 3);
+lean_object* x_29; lean_object* x_30; 
+x_29 = lean_ctor_get(x_27, 0);
 lean_inc(x_29);
-if (lean_obj_tag(x_29) == 0)
-{
-lean_object* x_30; lean_object* x_31; 
-x_30 = lean_ctor_get(x_28, 0);
-lean_inc(x_30);
-x_31 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_30);
-lean_dec(x_30);
-if (lean_obj_tag(x_31) == 2)
-{
-lean_object* x_32; lean_object* x_33; uint8_t x_34; 
-x_32 = lean_ctor_get(x_31, 1);
-lean_inc(x_32);
-lean_dec(x_31);
-x_33 = l_Lean_Parser_Term_have___elambda__1___closed__7;
-x_34 = lean_string_dec_eq(x_32, x_33);
-lean_dec(x_32);
-if (x_34 == 0)
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_2);
-x_35 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_27);
-x_37 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_16);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_8);
-lean_dec(x_8);
-return x_39;
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_40 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_28);
-x_41 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_31);
-lean_dec(x_2);
-x_44 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_44, x_27);
-x_46 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
-}
-}
-else
-{
-lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_30 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_29);
 lean_dec(x_29);
-lean_dec(x_2);
-x_49 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_49, x_27);
-x_51 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
-x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_16);
-x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_11, x_8);
-lean_dec(x_8);
-return x_53;
-}
+if (lean_obj_tag(x_30) == 2)
+{
+lean_object* x_31; lean_object* x_32; uint8_t x_33; 
+x_31 = lean_ctor_get(x_30, 1);
+lean_inc(x_31);
+lean_dec(x_30);
+x_32 = l_Lean_Parser_Term_have___elambda__1___closed__7;
+x_33 = lean_string_dec_eq(x_31, x_32);
+lean_dec(x_31);
+if (x_33 == 0)
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_1);
+x_34 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_26);
+x_36 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
 lean_dec(x_26);
-lean_dec(x_2);
-x_54 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_25, x_54, x_16);
-x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_11, x_8);
-lean_dec(x_8);
-return x_56;
+x_39 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_27);
+x_40 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_15);
+x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_10, x_7);
+lean_dec(x_7);
+return x_42;
 }
 }
 else
 {
-lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-lean_dec(x_24);
-lean_dec(x_2);
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_30);
 lean_dec(x_1);
-x_57 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
-x_58 = l_Lean_Parser_ParserState_mkNode(x_23, x_57, x_16);
-x_59 = l_Lean_Parser_mergeOrElseErrors(x_58, x_11, x_8);
-lean_dec(x_8);
-return x_59;
+x_43 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_43, x_26);
+x_45 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_10, x_7);
+lean_dec(x_7);
+return x_47;
 }
 }
 else
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_28);
 lean_dec(x_1);
-x_60 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_19, x_60, x_16);
-x_62 = l_Lean_Parser_mergeOrElseErrors(x_61, x_11, x_8);
-lean_dec(x_8);
-return x_62;
+x_48 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_48, x_26);
+x_50 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_15);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_10, x_7);
+lean_dec(x_7);
+return x_52;
 }
 }
 else
 {
-lean_object* x_63; lean_object* x_64; lean_object* x_65; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+lean_dec(x_25);
 lean_dec(x_1);
-x_63 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
-x_64 = l_Lean_Parser_ParserState_mkNode(x_17, x_63, x_16);
-x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_11, x_8);
-lean_dec(x_8);
-return x_65;
+x_53 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+x_54 = l_Lean_Parser_ParserState_mkNode(x_24, x_53, x_15);
+x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_10, x_7);
+lean_dec(x_7);
+return x_55;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+lean_dec(x_23);
+lean_dec(x_1);
+x_56 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+x_57 = l_Lean_Parser_ParserState_mkNode(x_22, x_56, x_15);
+x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_10, x_7);
+lean_dec(x_7);
+return x_58;
+}
+}
+else
+{
+lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_59 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+x_60 = l_Lean_Parser_ParserState_mkNode(x_18, x_59, x_15);
+x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_10, x_7);
+lean_dec(x_7);
+return x_61;
+}
+}
+else
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_62 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+x_63 = l_Lean_Parser_ParserState_mkNode(x_16, x_62, x_15);
+x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_10, x_7);
+lean_dec(x_7);
+return x_64;
 }
 }
 }
@@ -11087,7 +10863,7 @@ lean_object* _init_l_Lean_Parser_Term_suffices___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_suffices___closed__2;
@@ -11143,7 +10919,7 @@ lean_object* _init_l_Lean_Parser_Term_suffices___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_suffices___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_suffices___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -11170,10 +10946,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_suffices(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_suffices___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_suffices;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -11210,13 +10986,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_show___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_show___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_show___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_show___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_show___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_show___elambda__1___closed__5() {
@@ -11268,165 +11043,160 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_show___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_show___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_show___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_show___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_34; lean_object* x_35; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_34 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_35 = lean_ctor_get(x_34, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_33; lean_object* x_34; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_33 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_34 = lean_ctor_get(x_33, 3);
+lean_inc(x_34);
+if (lean_obj_tag(x_34) == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = lean_ctor_get(x_33, 0);
 lean_inc(x_35);
-if (lean_obj_tag(x_35) == 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_Lean_Parser_checkLeadingFn___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_inc(x_38);
-lean_dec(x_37);
-x_39 = l_Lean_Parser_Term_show___elambda__1___closed__6;
-x_40 = lean_string_dec_eq(x_38, x_39);
-lean_dec(x_38);
-if (x_40 == 0)
-{
-lean_object* x_41; lean_object* x_42; 
-x_41 = l_Lean_Parser_Term_show___elambda__1___closed__9;
-lean_inc(x_8);
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_41, x_8);
-x_17 = x_42;
-goto block_33;
-}
-else
-{
-x_17 = x_34;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; 
-lean_dec(x_37);
-x_43 = l_Lean_Parser_Term_show___elambda__1___closed__9;
-lean_inc(x_8);
-x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_43, x_8);
-x_17 = x_44;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_45; lean_object* x_46; 
+x_36 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_35);
 lean_dec(x_35);
-x_45 = l_Lean_Parser_Term_show___elambda__1___closed__9;
-lean_inc(x_8);
-x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_34, x_45, x_8);
-x_17 = x_46;
-goto block_33;
-}
-block_33:
+if (lean_obj_tag(x_36) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_37 = lean_ctor_get(x_36, 1);
+lean_inc(x_37);
+lean_dec(x_36);
+x_38 = l_Lean_Parser_Term_show___elambda__1___closed__6;
+x_39 = lean_string_dec_eq(x_37, x_38);
+lean_dec(x_37);
+if (x_39 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_23 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_2, x_21);
-x_24 = l_Lean_Parser_Term_show___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
+lean_object* x_40; lean_object* x_41; 
+x_40 = l_Lean_Parser_Term_show___elambda__1___closed__9;
+lean_inc(x_7);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_7);
+x_16 = x_41;
+goto block_32;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_dec(x_22);
-lean_dec(x_2);
-lean_dec(x_1);
-x_27 = l_Lean_Parser_Term_show___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkNode(x_21, x_27, x_16);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_11, x_8);
-lean_dec(x_8);
-return x_29;
+x_16 = x_33;
+goto block_32;
 }
 }
 else
 {
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_42; lean_object* x_43; 
+lean_dec(x_36);
+x_42 = l_Lean_Parser_Term_show___elambda__1___closed__9;
+lean_inc(x_7);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_42, x_7);
+x_16 = x_43;
+goto block_32;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; 
+lean_dec(x_34);
+x_44 = l_Lean_Parser_Term_show___elambda__1___closed__9;
+lean_inc(x_7);
+x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_44, x_7);
+x_16 = x_45;
+goto block_32;
+}
+block_32:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_22 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_20);
+x_23 = l_Lean_Parser_Term_show___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
+}
+else
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_21);
 lean_dec(x_1);
-x_30 = l_Lean_Parser_Term_show___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_17, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
+x_26 = l_Lean_Parser_Term_show___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
+}
+}
+else
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_29 = l_Lean_Parser_Term_show___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_16, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
 }
 }
 }
@@ -11447,7 +11217,7 @@ lean_object* _init_l_Lean_Parser_Term_show___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_fromTerm;
@@ -11493,7 +11263,7 @@ lean_object* _init_l_Lean_Parser_Term_show___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_show___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_show___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -11520,75 +11290,75 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_show(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_show___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_show___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_show;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-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; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-x_8 = l_Lean_Parser_termParser___closed__2;
-x_9 = l_Lean_Parser_appPrec;
+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; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-x_10 = l_Lean_Parser_categoryParserFn(x_8, x_9, x_3, x_4);
-x_11 = lean_ctor_get(x_10, 3);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+x_6 = l_Lean_Parser_termParser___closed__2;
+x_7 = l_Lean_Parser_appPrec;
+lean_inc(x_1);
+x_8 = l_Lean_Parser_categoryParser___elambda__1(x_6, x_7, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_object* x_12; uint8_t x_13; 
-lean_dec(x_6);
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_7, x_12);
-lean_dec(x_12);
-lean_dec(x_7);
-if (x_13 == 0)
+lean_object* x_10; uint8_t x_11; 
+lean_dec(x_4);
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+x_11 = lean_nat_dec_eq(x_5, x_10);
+lean_dec(x_10);
+lean_dec(x_5);
+if (x_11 == 0)
 {
-x_4 = x_10;
+x_2 = x_8;
 goto _start;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; 
-lean_dec(x_3);
-x_15 = l_Lean_Parser_manyAux___main___closed__1;
-x_16 = l_Lean_Parser_ParserState_mkUnexpectedError(x_10, x_15);
-return x_16;
+lean_object* x_13; lean_object* x_14; 
+lean_dec(x_1);
+x_13 = l_Lean_Parser_manyAux___main___closed__1;
+x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
+return x_14;
 }
 }
 else
 {
-lean_object* x_17; uint8_t x_18; 
-lean_dec(x_11);
-lean_dec(x_3);
-x_17 = lean_ctor_get(x_10, 1);
-lean_inc(x_17);
-x_18 = lean_nat_dec_eq(x_7, x_17);
-lean_dec(x_17);
-if (x_18 == 0)
+lean_object* x_15; uint8_t x_16; 
+lean_dec(x_9);
+lean_dec(x_1);
+x_15 = lean_ctor_get(x_8, 1);
+lean_inc(x_15);
+x_16 = lean_nat_dec_eq(x_5, x_15);
+lean_dec(x_15);
+if (x_16 == 0)
 {
-lean_dec(x_7);
-lean_dec(x_6);
-return x_10;
+lean_dec(x_5);
+lean_dec(x_4);
+return x_8;
 }
 else
 {
-lean_object* x_19; 
-x_19 = l_Lean_Parser_ParserState_restore(x_10, x_6, x_7);
-lean_dec(x_6);
-return x_19;
+lean_object* x_17; 
+x_17 = l_Lean_Parser_ParserState_restore(x_8, x_4, x_5);
+lean_dec(x_4);
+return x_17;
 }
 }
 }
@@ -11624,13 +11394,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_fun___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_fun___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_fun___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_fun___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_fun___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_fun___elambda__1___closed__5() {
@@ -11674,7 +11443,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_fun___elambda__1___closed__8;
-x_2 = l_Lean_Parser_unicodeSymbolFn___rarg___closed__1;
+x_2 = l_Lean_Parser_unicodeSymbolFn___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
@@ -11711,197 +11480,190 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_fun___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_fun___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_fun___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_fun___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_Term_fun___elambda__1___closed__6;
-x_18 = l_Lean_Parser_Term_fun___elambda__1___closed__7;
-x_19 = l_Lean_Parser_Term_fun___elambda__1___closed__12;
-lean_inc(x_2);
-x_20 = l_Lean_Parser_unicodeSymbolFnAux(x_17, x_18, x_19, x_2, x_14);
-x_21 = lean_ctor_get(x_20, 3);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_Term_fun___elambda__1___closed__6;
+x_17 = l_Lean_Parser_Term_fun___elambda__1___closed__7;
+x_18 = l_Lean_Parser_Term_fun___elambda__1___closed__12;
+lean_inc(x_1);
+x_19 = l_Lean_Parser_unicodeSymbolFnAux(x_16, x_17, x_18, x_1, x_13);
+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_24; lean_object* x_25; lean_object* x_26; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = l_Lean_Parser_termParser___closed__2;
+x_24 = l_Lean_Parser_appPrec;
+lean_inc(x_1);
+x_25 = l_Lean_Parser_categoryParser___elambda__1(x_23, x_24, x_1, x_19);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
 {
-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_20, 0);
-lean_inc(x_22);
-x_23 = lean_array_get_size(x_22);
-lean_dec(x_22);
-x_24 = l_Lean_Parser_termParser___closed__2;
-x_25 = l_Lean_Parser_appPrec;
-lean_inc(x_2);
-x_26 = l_Lean_Parser_categoryParserFn(x_24, x_25, x_2, x_20);
-x_27 = lean_ctor_get(x_26, 3);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_inc(x_1);
+x_27 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(x_1, x_25);
+x_28 = l_Lean_nullKind;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_22);
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
 {
-uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_28 = 0;
-lean_inc(x_2);
-x_29 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(x_28, x_1, x_2, x_26);
-lean_dec(x_1);
-x_30 = l_Lean_nullKind;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_23);
+lean_object* x_31; lean_object* x_32; 
+lean_inc(x_1);
+x_31 = l_Lean_Parser_darrow___elambda__1(x_1, x_29);
 x_32 = lean_ctor_get(x_31, 3);
 lean_inc(x_32);
 if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_33; lean_object* x_34; 
-lean_inc(x_2);
-x_33 = l_Lean_Parser_darrow___elambda__1___rarg(x_2, x_31);
-x_34 = lean_ctor_get(x_33, 3);
-lean_inc(x_34);
-if (lean_obj_tag(x_34) == 0)
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_35 = lean_unsigned_to_nat(0u);
-x_36 = l_Lean_Parser_categoryParserFn(x_24, x_35, x_2, x_33);
-x_37 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_16);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_8);
-lean_dec(x_8);
-return x_39;
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_33 = lean_unsigned_to_nat(0u);
+x_34 = l_Lean_Parser_categoryParser___elambda__1(x_23, x_33, x_1, x_31);
+x_35 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_15);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_10, x_7);
+lean_dec(x_7);
+return x_37;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-lean_dec(x_34);
-lean_dec(x_2);
-x_40 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
-x_41 = l_Lean_Parser_ParserState_mkNode(x_33, x_40, x_16);
-x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_11, x_8);
-lean_dec(x_8);
-return x_42;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
 lean_dec(x_32);
-lean_dec(x_2);
-x_43 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_31, x_43, x_16);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_11, x_8);
-lean_dec(x_8);
-return x_45;
+lean_dec(x_1);
+x_38 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_31, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_7);
+lean_dec(x_7);
+return x_40;
 }
 }
 else
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_27);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_30);
 lean_dec(x_1);
-x_46 = l_Lean_nullKind;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_26, x_46, x_23);
+x_41 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_29, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_26);
+x_44 = l_Lean_nullKind;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_25, x_44, x_22);
+x_46 = lean_ctor_get(x_45, 3);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; lean_object* x_48; 
+lean_inc(x_1);
+x_47 = l_Lean_Parser_darrow___elambda__1(x_1, x_45);
 x_48 = lean_ctor_get(x_47, 3);
 lean_inc(x_48);
 if (lean_obj_tag(x_48) == 0)
 {
-lean_object* x_49; lean_object* x_50; 
-lean_inc(x_2);
-x_49 = l_Lean_Parser_darrow___elambda__1___rarg(x_2, x_47);
-x_50 = lean_ctor_get(x_49, 3);
-lean_inc(x_50);
-if (lean_obj_tag(x_50) == 0)
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_51 = lean_unsigned_to_nat(0u);
-x_52 = l_Lean_Parser_categoryParserFn(x_24, x_51, x_2, x_49);
-x_53 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
-x_54 = l_Lean_Parser_ParserState_mkNode(x_52, x_53, x_16);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_11, x_8);
-lean_dec(x_8);
-return x_55;
+lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_49 = lean_unsigned_to_nat(0u);
+x_50 = l_Lean_Parser_categoryParser___elambda__1(x_23, x_49, x_1, x_47);
+x_51 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
+x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_15);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_10, x_7);
+lean_dec(x_7);
+return x_53;
 }
 else
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-lean_dec(x_50);
-lean_dec(x_2);
-x_56 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_49, x_56, x_16);
-x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_11, x_8);
-lean_dec(x_8);
-return x_58;
-}
-}
-else
-{
-lean_object* x_59; lean_object* x_60; lean_object* x_61; 
+lean_object* x_54; lean_object* x_55; lean_object* x_56; 
 lean_dec(x_48);
-lean_dec(x_2);
-x_59 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
-x_60 = l_Lean_Parser_ParserState_mkNode(x_47, x_59, x_16);
-x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_11, x_8);
-lean_dec(x_8);
-return x_61;
+lean_dec(x_1);
+x_54 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
+x_55 = l_Lean_Parser_ParserState_mkNode(x_47, x_54, x_15);
+x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_10, x_7);
+lean_dec(x_7);
+return x_56;
+}
+}
+else
+{
+lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+lean_dec(x_46);
+lean_dec(x_1);
+x_57 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
+x_58 = l_Lean_Parser_ParserState_mkNode(x_45, x_57, x_15);
+x_59 = l_Lean_Parser_mergeOrElseErrors(x_58, x_10, x_7);
+lean_dec(x_7);
+return x_59;
 }
 }
 }
 else
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-lean_dec(x_21);
-lean_dec(x_2);
+lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+lean_dec(x_20);
 lean_dec(x_1);
-x_62 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
-x_63 = l_Lean_Parser_ParserState_mkNode(x_20, x_62, x_16);
-x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_11, x_8);
-lean_dec(x_8);
-return x_64;
+x_60 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
+x_61 = l_Lean_Parser_ParserState_mkNode(x_19, x_60, x_15);
+x_62 = l_Lean_Parser_mergeOrElseErrors(x_61, x_10, x_7);
+lean_dec(x_7);
+return x_62;
 }
 }
 }
@@ -11925,7 +11687,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = l_Lean_Parser_darrow;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_4 = lean_ctor_get(x_3, 0);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_andthenInfo(x_2, x_4);
@@ -11980,7 +11742,7 @@ lean_object* _init_l_Lean_Parser_Term_fun___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_fun___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_fun___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -12004,24 +11766,13 @@ x_1 = l_Lean_Parser_Term_fun___closed__8;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_6;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Term_fun(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_fun___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_fun;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -12058,168 +11809,159 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_structInstField___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_structInstField___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_structInstField___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_structInstField___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_structInstField___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_structInstField___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_structInstField___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_structInstField___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_structInstField___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_16 = l_Lean_Parser_ident___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
 lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_16, 1);
+lean_inc(x_18);
+lean_inc(x_1);
+x_19 = l_Lean_Parser_tokenFn(x_1, x_16);
 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; 
-x_21 = lean_ctor_get(x_19, 1);
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-lean_inc(x_2);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-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; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
-{
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-lean_dec(x_2);
-x_29 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
-x_31 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_18);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_13, x_10);
-lean_dec(x_10);
-return x_33;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21);
 lean_dec(x_21);
-x_34 = l_Lean_Parser_termParser___closed__2;
-x_35 = lean_unsigned_to_nat(0u);
-x_36 = l_Lean_Parser_categoryParserFn(x_34, x_35, x_2, x_22);
-x_37 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_18);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_13, x_10);
-lean_dec(x_10);
-return x_39;
-}
-}
-else
+if (lean_obj_tag(x_22) == 2)
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-lean_dec(x_25);
-lean_dec(x_2);
-x_40 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_40, x_21);
-x_42 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_18);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_13, x_10);
-lean_dec(x_10);
-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_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_23 = lean_ctor_get(x_22, 1);
+lean_inc(x_23);
+lean_dec(x_22);
+x_24 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
+x_25 = lean_string_dec_eq(x_23, x_24);
 lean_dec(x_23);
-lean_dec(x_2);
-x_45 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_45, x_21);
-x_47 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_18);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_13, x_10);
-lean_dec(x_10);
-return x_49;
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_1);
+x_26 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18);
+x_28 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
+x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_15);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_10, x_7);
+lean_dec(x_7);
+return x_30;
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_18);
+x_31 = l_Lean_Parser_termParser___closed__2;
+x_32 = lean_unsigned_to_nat(0u);
+x_33 = l_Lean_Parser_categoryParser___elambda__1(x_31, x_32, x_1, x_19);
+x_34 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
 }
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_22);
+lean_dec(x_1);
+x_37 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_37, x_18);
+x_39 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
+}
+}
+else
+{
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
 lean_dec(x_20);
-lean_dec(x_2);
-x_50 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_19, x_50, x_18);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_13, x_10);
-lean_dec(x_10);
-return x_52;
+lean_dec(x_1);
+x_42 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_42, x_18);
+x_44 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_47 = l_Lean_Parser_Term_structInstField___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_16, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
 }
 }
 }
@@ -12229,7 +11971,7 @@ lean_object* _init_l_Lean_Parser_Term_structInstField___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_haveAssign___closed__2;
@@ -12263,7 +12005,7 @@ lean_object* _init_l_Lean_Parser_Term_structInstField___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_structInstField___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_structInstField___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -12318,13 +12060,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_structInstSource___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_structInstSource___elambda__1___closed__5() {
@@ -12368,189 +12109,189 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_structInstSource___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_structInstSource___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_structInstSource___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_48; lean_object* x_49; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_48 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_49 = lean_ctor_get(x_48, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_47; lean_object* x_48; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_47 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_48 = lean_ctor_get(x_47, 3);
+lean_inc(x_48);
+if (lean_obj_tag(x_48) == 0)
+{
+lean_object* x_49; lean_object* x_50; 
+x_49 = lean_ctor_get(x_47, 0);
 lean_inc(x_49);
-if (lean_obj_tag(x_49) == 0)
-{
-lean_object* x_50; lean_object* x_51; 
-x_50 = lean_ctor_get(x_48, 0);
-lean_inc(x_50);
-x_51 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_50);
-lean_dec(x_50);
-if (lean_obj_tag(x_51) == 2)
-{
-lean_object* x_52; lean_object* x_53; uint8_t x_54; 
-x_52 = lean_ctor_get(x_51, 1);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__5;
-x_54 = lean_string_dec_eq(x_52, x_53);
-lean_dec(x_52);
-if (x_54 == 0)
-{
-lean_object* x_55; lean_object* x_56; 
-x_55 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__8;
-lean_inc(x_8);
-x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_55, x_8);
-x_17 = x_56;
-goto block_47;
-}
-else
-{
-x_17 = x_48;
-goto block_47;
-}
-}
-else
-{
-lean_object* x_57; lean_object* x_58; 
-lean_dec(x_51);
-x_57 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__8;
-lean_inc(x_8);
-x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_57, x_8);
-x_17 = x_58;
-goto block_47;
-}
-}
-else
-{
-lean_object* x_59; lean_object* x_60; 
+x_50 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_49);
 lean_dec(x_49);
-x_59 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__8;
-lean_inc(x_8);
-x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_59, x_8);
-x_17 = x_60;
-goto block_47;
-}
-block_47:
+if (lean_obj_tag(x_50) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_51; lean_object* x_52; uint8_t x_53; 
+x_51 = lean_ctor_get(x_50, 1);
+lean_inc(x_51);
+lean_dec(x_50);
+x_52 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__5;
+x_53 = lean_string_dec_eq(x_51, x_52);
+lean_dec(x_51);
+if (x_53 == 0)
+{
+lean_object* x_54; lean_object* x_55; 
+x_54 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__8;
+lean_inc(x_7);
+x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_54, x_7);
+x_16 = x_55;
+goto block_46;
+}
+else
+{
+x_16 = x_47;
+goto block_46;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; 
+lean_dec(x_50);
+x_56 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__8;
+lean_inc(x_7);
+x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_56, x_7);
+x_16 = x_57;
+goto block_46;
+}
+}
+else
+{
+lean_object* x_58; lean_object* x_59; 
+lean_dec(x_48);
+x_58 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__8;
+lean_inc(x_7);
+x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_58, x_7);
+x_16 = x_59;
+goto block_46;
+}
+block_46:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+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; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-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; 
-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_22 = l_Lean_Parser_termParser___closed__2;
-x_23 = lean_unsigned_to_nat(0u);
-x_24 = l_Lean_Parser_categoryParserFn(x_22, x_23, x_2, x_17);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_21);
-x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_24, x_26, x_20);
-x_28 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_16);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_11, x_8);
-lean_dec(x_8);
-return x_30;
-}
-else
-{
-lean_object* x_31; uint8_t x_32; 
-lean_dec(x_25);
-x_31 = lean_ctor_get(x_24, 1);
-lean_inc(x_31);
-x_32 = lean_nat_dec_eq(x_31, x_21);
-lean_dec(x_31);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_21);
-x_33 = l_Lean_nullKind;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_24, x_33, x_20);
-x_35 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_16);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_11, x_8);
-lean_dec(x_8);
-return x_37;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_38 = l_Lean_Parser_ParserState_restore(x_24, x_20, x_21);
-x_39 = l_Lean_nullKind;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_20);
-x_41 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_19 = lean_array_get_size(x_18);
 lean_dec(x_18);
-lean_dec(x_2);
-x_44 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_17, x_44, x_16);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_11, x_8);
-lean_dec(x_8);
-return x_46;
+x_20 = lean_ctor_get(x_16, 1);
+lean_inc(x_20);
+x_21 = l_Lean_Parser_termParser___closed__2;
+x_22 = lean_unsigned_to_nat(0u);
+x_23 = l_Lean_Parser_categoryParser___elambda__1(x_21, x_22, x_1, x_16);
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_20);
+x_25 = l_Lean_nullKind;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_23, x_25, x_19);
+x_27 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__2;
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_15);
+x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_10, x_7);
+lean_dec(x_7);
+return x_29;
+}
+else
+{
+lean_object* x_30; uint8_t x_31; 
+lean_dec(x_24);
+x_30 = lean_ctor_get(x_23, 1);
+lean_inc(x_30);
+x_31 = lean_nat_dec_eq(x_30, x_20);
+lean_dec(x_30);
+if (x_31 == 0)
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_20);
+x_32 = l_Lean_nullKind;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_23, x_32, x_19);
+x_34 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
+}
+else
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_37 = l_Lean_Parser_ParserState_restore(x_23, x_19, x_20);
+x_38 = l_Lean_nullKind;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_19);
+x_40 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__2;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_15);
+x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_10, x_7);
+lean_dec(x_7);
+return x_42;
+}
+}
+}
+else
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_43 = l_Lean_Parser_Term_structInstSource___elambda__1___closed__2;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_16, x_43, x_15);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_10, x_7);
+lean_dec(x_7);
+return x_45;
 }
 }
 }
@@ -12571,7 +12312,7 @@ lean_object* _init_l_Lean_Parser_Term_structInstSource___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_optionaInfo(x_2);
@@ -12614,7 +12355,7 @@ lean_object* _init_l_Lean_Parser_Term_structInstSource___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_structInstSource___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_structInstSource___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -12638,238 +12379,234 @@ x_1 = l_Lean_Parser_Term_structInstSource___closed__7;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_60; lean_object* x_61; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_58; lean_object* x_59; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
-lean_dec(x_9);
-x_11 = lean_ctor_get(x_8, 1);
-lean_inc(x_11);
-lean_inc(x_7);
-lean_inc(x_6);
-x_60 = l_Lean_Parser_Term_structInstField___elambda__1(x_6, x_7, x_8);
-x_61 = lean_ctor_get(x_60, 3);
+lean_inc(x_5);
+x_58 = l_Lean_Parser_Term_structInstField___elambda__1(x_5, x_6);
+x_59 = lean_ctor_get(x_58, 3);
+lean_inc(x_59);
+if (lean_obj_tag(x_59) == 0)
+{
+x_10 = x_58;
+goto block_57;
+}
+else
+{
+lean_object* x_60; lean_object* x_61; uint8_t x_62; 
+x_60 = lean_ctor_get(x_59, 0);
+lean_inc(x_60);
+lean_dec(x_59);
+x_61 = lean_ctor_get(x_58, 1);
 lean_inc(x_61);
-if (lean_obj_tag(x_61) == 0)
-{
-x_12 = x_60;
-goto block_59;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; uint8_t x_64; 
-x_62 = lean_ctor_get(x_61, 0);
-lean_inc(x_62);
+x_62 = lean_nat_dec_eq(x_61, x_9);
 lean_dec(x_61);
-x_63 = lean_ctor_get(x_60, 1);
-lean_inc(x_63);
-x_64 = lean_nat_dec_eq(x_63, x_11);
-lean_dec(x_63);
-if (x_64 == 0)
+if (x_62 == 0)
 {
-lean_dec(x_62);
-x_12 = x_60;
-goto block_59;
+lean_dec(x_60);
+x_10 = x_58;
+goto block_57;
 }
 else
 {
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_inc(x_9);
+x_63 = l_Lean_Parser_ParserState_restore(x_58, x_8, x_9);
+lean_inc(x_5);
+x_64 = l_Lean_Parser_Term_structInstSource___elambda__1(x_5, x_63);
+x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_60, x_9);
+x_10 = x_65;
+goto block_57;
+}
+}
+block_57:
+{
+lean_object* x_11; 
+x_11 = lean_ctor_get(x_10, 3);
 lean_inc(x_11);
-x_65 = l_Lean_Parser_ParserState_restore(x_60, x_10, x_11);
-lean_inc(x_7);
-lean_inc(x_6);
-x_66 = l_Lean_Parser_Term_structInstSource___elambda__1(x_6, x_7, x_65);
-x_67 = l_Lean_Parser_mergeOrElseErrors(x_66, x_62, x_11);
-x_12 = x_67;
-goto block_59;
-}
-}
-block_59:
+if (lean_obj_tag(x_11) == 0)
 {
-lean_object* x_13; 
-x_13 = lean_ctor_get(x_12, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_14 = lean_ctor_get(x_12, 0);
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_12 = lean_ctor_get(x_10, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+x_14 = lean_ctor_get(x_10, 1);
 lean_inc(x_14);
-x_15 = lean_array_get_size(x_14);
-lean_dec(x_14);
-x_16 = lean_ctor_get(x_12, 1);
-lean_inc(x_16);
-lean_inc(x_7);
-x_31 = l_Lean_Parser_tokenFn(x_7, x_12);
-x_32 = lean_ctor_get(x_31, 3);
-lean_inc(x_32);
-if (lean_obj_tag(x_32) == 0)
+lean_inc(x_5);
+x_29 = l_Lean_Parser_tokenFn(x_5, x_10);
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_31, 0);
+lean_object* x_31; lean_object* x_32; 
+x_31 = lean_ctor_get(x_29, 0);
+lean_inc(x_31);
+x_32 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_31);
+lean_dec(x_31);
+if (lean_obj_tag(x_32) == 2)
+{
+lean_object* x_33; lean_object* x_34; uint8_t x_35; 
+x_33 = lean_ctor_get(x_32, 1);
 lean_inc(x_33);
-x_34 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_33);
+lean_dec(x_32);
+x_34 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_35 = lean_string_dec_eq(x_33, x_34);
 lean_dec(x_33);
-if (lean_obj_tag(x_34) == 2)
+if (x_35 == 0)
 {
-lean_object* x_35; lean_object* x_36; uint8_t x_37; 
-x_35 = lean_ctor_get(x_34, 1);
-lean_inc(x_35);
-lean_dec(x_34);
-x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_37 = lean_string_dec_eq(x_35, x_36);
-lean_dec(x_35);
-if (x_37 == 0)
+lean_object* x_36; lean_object* x_37; 
+x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_14);
+x_15 = x_37;
+goto block_28;
+}
+else
+{
+x_15 = x_29;
+goto block_28;
+}
+}
+else
 {
 lean_object* x_38; lean_object* x_39; 
+lean_dec(x_32);
 x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_16);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_16);
-x_17 = x_39;
-goto block_30;
-}
-else
-{
-x_17 = x_31;
-goto block_30;
+lean_inc(x_14);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_14);
+x_15 = x_39;
+goto block_28;
 }
 }
 else
 {
 lean_object* x_40; lean_object* x_41; 
-lean_dec(x_34);
+lean_dec(x_30);
 x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+lean_inc(x_14);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_14);
+x_15 = x_41;
+goto block_28;
+}
+block_28:
+{
+lean_object* x_16; 
+x_16 = lean_ctor_get(x_15, 3);
 lean_inc(x_16);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_16);
-x_17 = x_41;
-goto block_30;
-}
-}
-else
+if (lean_obj_tag(x_16) == 0)
 {
-lean_object* x_42; lean_object* x_43; 
-lean_dec(x_32);
-x_42 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-lean_inc(x_16);
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_16);
-x_17 = x_43;
-goto block_30;
-}
-block_30:
+lean_dec(x_14);
+lean_dec(x_13);
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_dec(x_16);
-lean_dec(x_15);
-{
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_17;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_15;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-lean_dec(x_18);
-lean_dec(x_7);
-lean_dec(x_6);
-x_20 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
-lean_dec(x_15);
-x_21 = lean_ctor_get(x_20, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+lean_dec(x_16);
+lean_dec(x_5);
+x_18 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
+lean_dec(x_13);
+x_19 = lean_ctor_get(x_18, 0);
+lean_inc(x_19);
+x_20 = lean_array_get_size(x_19);
+lean_dec(x_19);
+x_21 = lean_nat_sub(x_20, x_2);
+lean_dec(x_20);
+x_22 = lean_unsigned_to_nat(1u);
+x_23 = lean_nat_dec_eq(x_21, x_22);
 lean_dec(x_21);
-x_23 = lean_nat_sub(x_22, x_3);
-lean_dec(x_22);
-x_24 = lean_unsigned_to_nat(1u);
-x_25 = lean_nat_dec_eq(x_23, x_24);
-lean_dec(x_23);
-if (x_25 == 0)
+if (x_23 == 0)
+{
+lean_object* x_24; lean_object* x_25; 
+x_24 = l_Lean_nullKind;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_2);
+return x_25;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_26; lean_object* x_27; 
 x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_3);
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_2);
 return x_27;
 }
 else
 {
+lean_dec(x_2);
+return x_18;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_11);
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_3);
-return x_29;
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_42 = lean_box(0);
+x_43 = l_Lean_Parser_ParserState_pushSyntax(x_10, x_42);
+x_44 = l_Lean_nullKind;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_2);
+return x_45;
 }
 else
 {
-lean_dec(x_3);
-return x_20;
-}
-}
-}
-}
-}
-else
-{
-lean_dec(x_13);
-lean_dec(x_7);
-lean_dec(x_6);
-if (x_5 == 0)
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_44 = lean_box(0);
-x_45 = l_Lean_Parser_ParserState_pushSyntax(x_12, x_44);
-x_46 = l_Lean_nullKind;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_3);
-return x_47;
-}
-else
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
-x_48 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_11);
-lean_dec(x_10);
-x_49 = lean_ctor_get(x_48, 0);
-lean_inc(x_49);
-x_50 = lean_array_get_size(x_49);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; 
+x_46 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_47 = lean_ctor_get(x_46, 0);
+lean_inc(x_47);
+x_48 = lean_array_get_size(x_47);
+lean_dec(x_47);
+x_49 = lean_nat_sub(x_48, x_2);
+lean_dec(x_48);
+x_50 = lean_unsigned_to_nat(2u);
+x_51 = lean_nat_dec_eq(x_49, x_50);
 lean_dec(x_49);
-x_51 = lean_nat_sub(x_50, x_3);
-lean_dec(x_50);
-x_52 = lean_unsigned_to_nat(2u);
-x_53 = lean_nat_dec_eq(x_51, x_52);
-lean_dec(x_51);
-if (x_53 == 0)
+if (x_51 == 0)
+{
+lean_object* x_52; lean_object* x_53; 
+x_52 = l_Lean_nullKind;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_46, x_52, x_2);
+return x_53;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_54; lean_object* x_55; 
 x_54 = l_Lean_nullKind;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_3);
+x_55 = l_Lean_Parser_ParserState_mkNode(x_46, x_54, x_2);
 return x_55;
 }
 else
 {
-if (x_4 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_3);
-return x_57;
-}
-else
-{
-lean_object* x_58; 
-lean_dec(x_3);
-x_58 = l_Lean_Parser_ParserState_popSyntax(x_48);
-return x_58;
+lean_object* x_56; 
+lean_dec(x_2);
+x_56 = l_Lean_Parser_ParserState_popSyntax(x_46);
+return x_56;
 }
 }
 }
@@ -12877,18 +12614,18 @@ return x_58;
 }
 }
 }
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = 0;
-x_9 = 1;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2(x_1, x_2, x_7, x_8, x_9, x_3, x_4, x_5);
-return x_10;
+lean_object* x_4; lean_object* x_5; uint8_t x_6; uint8_t x_7; lean_object* x_8; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_6 = 0;
+x_7 = 1;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2(x_1, x_5, x_6, x_7, x_2, x_3);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_structInst___elambda__1___closed__1() {
@@ -12922,13 +12659,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_structInst___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_structInst___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_structInst___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_structInst___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_structInst___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_structInst___elambda__1___closed__5() {
@@ -13021,456 +12757,443 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_structInst___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_structInst___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_structInst___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_structInst___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_58; lean_object* x_121; lean_object* x_122; 
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_121 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_122 = lean_ctor_get(x_121, 3);
-lean_inc(x_122);
-if (lean_obj_tag(x_122) == 0)
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
 {
-lean_object* x_123; lean_object* x_124; 
-x_123 = lean_ctor_get(x_121, 0);
-lean_inc(x_123);
-x_124 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_123);
-lean_dec(x_123);
-if (lean_obj_tag(x_124) == 2)
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
 {
-lean_object* x_125; lean_object* x_126; uint8_t x_127; 
-x_125 = lean_ctor_get(x_124, 1);
-lean_inc(x_125);
-lean_dec(x_124);
-x_126 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
-x_127 = lean_string_dec_eq(x_125, x_126);
-lean_dec(x_125);
-if (x_127 == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_54; lean_object* x_117; lean_object* x_118; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_117 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_118 = lean_ctor_get(x_117, 3);
+lean_inc(x_118);
+if (lean_obj_tag(x_118) == 0)
+{
+lean_object* x_119; lean_object* x_120; 
+x_119 = lean_ctor_get(x_117, 0);
+lean_inc(x_119);
+x_120 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_119);
+lean_dec(x_119);
+if (lean_obj_tag(x_120) == 2)
+{
+lean_object* x_121; lean_object* x_122; uint8_t x_123; 
+x_121 = lean_ctor_get(x_120, 1);
+lean_inc(x_121);
+lean_dec(x_120);
+x_122 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
+x_123 = lean_string_dec_eq(x_121, x_122);
+lean_dec(x_121);
+if (x_123 == 0)
+{
+lean_object* x_124; lean_object* x_125; 
+x_124 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_125 = l_Lean_Parser_ParserState_mkErrorsAt(x_117, x_124, x_7);
+x_54 = x_125;
+goto block_116;
+}
+else
+{
+x_54 = x_117;
+goto block_116;
+}
+}
+else
+{
+lean_object* x_126; lean_object* x_127; 
+lean_dec(x_120);
+x_126 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_127 = l_Lean_Parser_ParserState_mkErrorsAt(x_117, x_126, x_7);
+x_54 = x_127;
+goto block_116;
+}
+}
+else
 {
 lean_object* x_128; lean_object* x_129; 
+lean_dec(x_118);
 x_128 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_10);
-x_129 = l_Lean_Parser_ParserState_mkErrorsAt(x_121, x_128, x_10);
-x_58 = x_129;
-goto block_120;
+lean_inc(x_7);
+x_129 = l_Lean_Parser_ParserState_mkErrorsAt(x_117, x_128, x_7);
+x_54 = x_129;
+goto block_116;
 }
-else
+block_53:
 {
-x_58 = x_121;
-goto block_120;
-}
-}
-else
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_130; lean_object* x_131; 
-lean_dec(x_124);
-x_130 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_10);
-x_131 = l_Lean_Parser_ParserState_mkErrorsAt(x_121, x_130, x_10);
-x_58 = x_131;
-goto block_120;
-}
-}
-else
-{
-lean_object* x_132; lean_object* x_133; 
-lean_dec(x_122);
-x_132 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_10);
-x_133 = l_Lean_Parser_ParserState_mkErrorsAt(x_121, x_132, x_10);
-x_58 = x_133;
-goto block_120;
-}
-block_57:
-{
-lean_object* x_20; 
+uint8_t x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = 1;
+lean_inc(x_1);
+x_19 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(x_18, x_1, x_16);
 x_20 = lean_ctor_get(x_19, 3);
 lean_inc(x_20);
 if (lean_obj_tag(x_20) == 0)
 {
-uint8_t x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = 0;
-x_22 = 1;
-lean_inc(x_2);
-x_23 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(x_21, x_22, x_1, x_2, x_19);
-x_24 = lean_ctor_get(x_23, 3);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_19, 1);
+lean_inc(x_21);
+x_22 = l_Lean_Parser_tokenFn(x_1, x_19);
+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; 
+x_24 = lean_ctor_get(x_22, 0);
 lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_25 = lean_ctor_get(x_23, 1);
-lean_inc(x_25);
-x_26 = l_Lean_Parser_tokenFn(x_2, x_23);
-x_27 = lean_ctor_get(x_26, 3);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; lean_object* x_29; 
-x_28 = lean_ctor_get(x_26, 0);
-lean_inc(x_28);
-x_29 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_28);
-lean_dec(x_28);
-if (lean_obj_tag(x_29) == 2)
-{
-lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_30 = lean_ctor_get(x_29, 1);
-lean_inc(x_30);
-lean_dec(x_29);
-x_31 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
-x_32 = lean_string_dec_eq(x_30, x_31);
-lean_dec(x_30);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_33 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_25);
-x_35 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_18);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_13, x_10);
-lean_dec(x_10);
-return x_37;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-lean_dec(x_25);
-x_38 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_26, x_38, x_18);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_13, x_10);
-lean_dec(x_10);
-return x_40;
-}
-}
-else
-{
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-lean_dec(x_29);
-x_41 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_41, x_25);
-x_43 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_18);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_13, x_10);
-lean_dec(x_10);
-return x_45;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-lean_dec(x_27);
-x_46 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_46, x_25);
-x_48 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_18);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_13, x_10);
-lean_dec(x_10);
-return x_50;
-}
-}
-else
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_25 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_24);
 lean_dec(x_24);
-lean_dec(x_2);
-x_51 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
-x_52 = l_Lean_Parser_ParserState_mkNode(x_23, x_51, x_18);
-x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_13, x_10);
-lean_dec(x_10);
-return x_53;
+if (lean_obj_tag(x_25) == 2)
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_25, 1);
+lean_inc(x_26);
+lean_dec(x_25);
+x_27 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
+x_28 = lean_string_dec_eq(x_26, x_27);
+lean_dec(x_26);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_29 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+x_31 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_21);
+x_34 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
 }
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_25);
+x_37 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
+x_39 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
+}
+}
+else
+{
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_23);
+x_42 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
+x_44 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
 lean_dec(x_20);
-lean_dec(x_2);
 lean_dec(x_1);
-x_54 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_19, x_54, x_18);
-x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_13, x_10);
-lean_dec(x_10);
-return x_56;
+x_47 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
 }
 }
-block_120:
+else
 {
-lean_object* x_59; 
-x_59 = lean_ctor_get(x_58, 3);
-lean_inc(x_59);
-if (lean_obj_tag(x_59) == 0)
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_50 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_16, x_50, x_15);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_10, x_7);
+lean_dec(x_7);
+return x_52;
+}
+}
+block_116:
 {
-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_86; lean_object* x_87; 
-x_60 = lean_ctor_get(x_58, 0);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_58, 1);
-lean_inc(x_61);
-x_62 = lean_array_get_size(x_60);
-lean_dec(x_60);
-lean_inc(x_2);
+lean_object* x_55; 
+x_55 = lean_ctor_get(x_54, 3);
+lean_inc(x_55);
+if (lean_obj_tag(x_55) == 0)
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_82; lean_object* x_83; 
+x_56 = lean_ctor_get(x_54, 0);
+lean_inc(x_56);
+x_57 = lean_ctor_get(x_54, 1);
+lean_inc(x_57);
+x_58 = lean_array_get_size(x_56);
+lean_dec(x_56);
 lean_inc(x_1);
-x_86 = lean_apply_3(x_5, x_1, x_2, x_58);
-x_87 = lean_ctor_get(x_86, 3);
+x_82 = l_Lean_Parser_ident___elambda__1(x_1, x_54);
+x_83 = lean_ctor_get(x_82, 3);
+lean_inc(x_83);
+if (lean_obj_tag(x_83) == 0)
+{
+lean_object* x_84; lean_object* x_85; lean_object* x_86; 
+x_84 = lean_ctor_get(x_82, 1);
+lean_inc(x_84);
+lean_inc(x_1);
+x_85 = l_Lean_Parser_tokenFn(x_1, x_82);
+x_86 = lean_ctor_get(x_85, 3);
+lean_inc(x_86);
+if (lean_obj_tag(x_86) == 0)
+{
+lean_object* x_87; lean_object* x_88; 
+x_87 = lean_ctor_get(x_85, 0);
 lean_inc(x_87);
-if (lean_obj_tag(x_87) == 0)
-{
-lean_object* x_88; lean_object* x_89; lean_object* x_90; 
-x_88 = lean_ctor_get(x_86, 1);
-lean_inc(x_88);
-lean_inc(x_2);
-x_89 = l_Lean_Parser_tokenFn(x_2, x_86);
-x_90 = lean_ctor_get(x_89, 3);
-lean_inc(x_90);
-if (lean_obj_tag(x_90) == 0)
-{
-lean_object* x_91; lean_object* x_92; 
-x_91 = lean_ctor_get(x_89, 0);
-lean_inc(x_91);
-x_92 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_91);
-lean_dec(x_91);
-if (lean_obj_tag(x_92) == 2)
-{
-lean_object* x_93; lean_object* x_94; uint8_t x_95; 
-x_93 = lean_ctor_get(x_92, 1);
-lean_inc(x_93);
-lean_dec(x_92);
-x_94 = l_Lean_Parser_Term_structInst___elambda__1___closed__7;
-x_95 = lean_string_dec_eq(x_93, x_94);
-lean_dec(x_93);
-if (x_95 == 0)
-{
-lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; 
-x_96 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
-x_97 = l_Lean_Parser_ParserState_mkErrorsAt(x_89, x_96, x_88);
-x_98 = lean_ctor_get(x_97, 0);
-lean_inc(x_98);
-x_99 = lean_ctor_get(x_97, 2);
-lean_inc(x_99);
-x_100 = lean_ctor_get(x_97, 3);
-lean_inc(x_100);
-x_63 = x_97;
-x_64 = x_98;
-x_65 = x_99;
-x_66 = x_100;
-goto block_85;
-}
-else
-{
-lean_object* x_101; lean_object* x_102; lean_object* x_103; 
-lean_dec(x_88);
-x_101 = lean_ctor_get(x_89, 0);
-lean_inc(x_101);
-x_102 = lean_ctor_get(x_89, 2);
-lean_inc(x_102);
-x_103 = lean_ctor_get(x_89, 3);
-lean_inc(x_103);
-x_63 = x_89;
-x_64 = x_101;
-x_65 = x_102;
-x_66 = x_103;
-goto block_85;
-}
-}
-else
-{
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; 
-lean_dec(x_92);
-x_104 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
-x_105 = l_Lean_Parser_ParserState_mkErrorsAt(x_89, x_104, x_88);
-x_106 = lean_ctor_get(x_105, 0);
-lean_inc(x_106);
-x_107 = lean_ctor_get(x_105, 2);
-lean_inc(x_107);
-x_108 = lean_ctor_get(x_105, 3);
-lean_inc(x_108);
-x_63 = x_105;
-x_64 = x_106;
-x_65 = x_107;
-x_66 = x_108;
-goto block_85;
-}
-}
-else
-{
-lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; 
-lean_dec(x_90);
-x_109 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
-x_110 = l_Lean_Parser_ParserState_mkErrorsAt(x_89, x_109, x_88);
-x_111 = lean_ctor_get(x_110, 0);
-lean_inc(x_111);
-x_112 = lean_ctor_get(x_110, 2);
-lean_inc(x_112);
-x_113 = lean_ctor_get(x_110, 3);
-lean_inc(x_113);
-x_63 = x_110;
-x_64 = x_111;
-x_65 = x_112;
-x_66 = x_113;
-goto block_85;
-}
-}
-else
-{
-lean_object* x_114; lean_object* x_115; lean_object* x_116; 
+x_88 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_87);
 lean_dec(x_87);
-x_114 = lean_ctor_get(x_86, 0);
-lean_inc(x_114);
-x_115 = lean_ctor_get(x_86, 2);
-lean_inc(x_115);
-x_116 = lean_ctor_get(x_86, 3);
-lean_inc(x_116);
-x_63 = x_86;
-x_64 = x_114;
-x_65 = x_115;
-x_66 = x_116;
-goto block_85;
+if (lean_obj_tag(x_88) == 2)
+{
+lean_object* x_89; lean_object* x_90; uint8_t x_91; 
+x_89 = lean_ctor_get(x_88, 1);
+lean_inc(x_89);
+lean_dec(x_88);
+x_90 = l_Lean_Parser_Term_structInst___elambda__1___closed__7;
+x_91 = lean_string_dec_eq(x_89, x_90);
+lean_dec(x_89);
+if (x_91 == 0)
+{
+lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; 
+x_92 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
+x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_85, x_92, x_84);
+x_94 = lean_ctor_get(x_93, 0);
+lean_inc(x_94);
+x_95 = lean_ctor_get(x_93, 2);
+lean_inc(x_95);
+x_96 = lean_ctor_get(x_93, 3);
+lean_inc(x_96);
+x_59 = x_93;
+x_60 = x_94;
+x_61 = x_95;
+x_62 = x_96;
+goto block_81;
 }
-block_85:
+else
 {
-if (lean_obj_tag(x_66) == 0)
+lean_object* x_97; lean_object* x_98; lean_object* x_99; 
+lean_dec(x_84);
+x_97 = lean_ctor_get(x_85, 0);
+lean_inc(x_97);
+x_98 = lean_ctor_get(x_85, 2);
+lean_inc(x_98);
+x_99 = lean_ctor_get(x_85, 3);
+lean_inc(x_99);
+x_59 = x_85;
+x_60 = x_97;
+x_61 = x_98;
+x_62 = x_99;
+goto block_81;
+}
+}
+else
 {
-lean_object* x_67; 
-lean_dec(x_65);
-lean_dec(x_64);
-x_67 = lean_ctor_get(x_63, 3);
-lean_inc(x_67);
-if (lean_obj_tag(x_67) == 0)
+lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; 
+lean_dec(x_88);
+x_100 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
+x_101 = l_Lean_Parser_ParserState_mkErrorsAt(x_85, x_100, x_84);
+x_102 = lean_ctor_get(x_101, 0);
+lean_inc(x_102);
+x_103 = lean_ctor_get(x_101, 2);
+lean_inc(x_103);
+x_104 = lean_ctor_get(x_101, 3);
+lean_inc(x_104);
+x_59 = x_101;
+x_60 = x_102;
+x_61 = x_103;
+x_62 = x_104;
+goto block_81;
+}
+}
+else
+{
+lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; 
+lean_dec(x_86);
+x_105 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
+x_106 = l_Lean_Parser_ParserState_mkErrorsAt(x_85, x_105, x_84);
+x_107 = lean_ctor_get(x_106, 0);
+lean_inc(x_107);
+x_108 = lean_ctor_get(x_106, 2);
+lean_inc(x_108);
+x_109 = lean_ctor_get(x_106, 3);
+lean_inc(x_109);
+x_59 = x_106;
+x_60 = x_107;
+x_61 = x_108;
+x_62 = x_109;
+goto block_81;
+}
+}
+else
+{
+lean_object* x_110; lean_object* x_111; lean_object* x_112; 
+lean_dec(x_83);
+x_110 = lean_ctor_get(x_82, 0);
+lean_inc(x_110);
+x_111 = lean_ctor_get(x_82, 2);
+lean_inc(x_111);
+x_112 = lean_ctor_get(x_82, 3);
+lean_inc(x_112);
+x_59 = x_82;
+x_60 = x_110;
+x_61 = x_111;
+x_62 = x_112;
+goto block_81;
+}
+block_81:
+{
+if (lean_obj_tag(x_62) == 0)
+{
+lean_object* x_63; 
+lean_dec(x_61);
+lean_dec(x_60);
+x_63 = lean_ctor_get(x_59, 3);
+lean_inc(x_63);
+if (lean_obj_tag(x_63) == 0)
+{
+lean_object* x_64; lean_object* x_65; 
+lean_dec(x_57);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_59, x_64, x_58);
+x_16 = x_65;
+goto block_53;
+}
+else
+{
+lean_object* x_66; uint8_t x_67; 
+lean_dec(x_63);
+x_66 = lean_ctor_get(x_59, 1);
+lean_inc(x_66);
+x_67 = lean_nat_dec_eq(x_66, x_57);
+lean_dec(x_66);
+if (x_67 == 0)
 {
 lean_object* x_68; lean_object* x_69; 
-lean_dec(x_61);
+lean_dec(x_57);
 x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_63, x_68, x_62);
-x_19 = x_69;
-goto block_57;
+x_69 = l_Lean_Parser_ParserState_mkNode(x_59, x_68, x_58);
+x_16 = x_69;
+goto block_53;
 }
 else
 {
-lean_object* x_70; uint8_t x_71; 
-lean_dec(x_67);
-x_70 = lean_ctor_get(x_63, 1);
-lean_inc(x_70);
-x_71 = lean_nat_dec_eq(x_70, x_61);
-lean_dec(x_70);
-if (x_71 == 0)
-{
-lean_object* x_72; lean_object* x_73; 
-lean_dec(x_61);
-x_72 = l_Lean_nullKind;
-x_73 = l_Lean_Parser_ParserState_mkNode(x_63, x_72, x_62);
-x_19 = x_73;
-goto block_57;
-}
-else
-{
-lean_object* x_74; lean_object* x_75; lean_object* x_76; 
-x_74 = l_Lean_Parser_ParserState_restore(x_63, x_62, x_61);
-x_75 = l_Lean_nullKind;
-x_76 = l_Lean_Parser_ParserState_mkNode(x_74, x_75, x_62);
-x_19 = x_76;
-goto block_57;
+lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_70 = l_Lean_Parser_ParserState_restore(x_59, x_58, x_57);
+x_71 = l_Lean_nullKind;
+x_72 = l_Lean_Parser_ParserState_mkNode(x_70, x_71, x_58);
+x_16 = x_72;
+goto block_53;
 }
 }
 }
 else
 {
-lean_object* x_77; lean_object* x_78; uint8_t x_79; 
-lean_dec(x_63);
-x_77 = l_Array_shrink___main___rarg(x_64, x_62);
-lean_inc(x_61);
-x_78 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_78, 0, x_77);
-lean_ctor_set(x_78, 1, x_61);
-lean_ctor_set(x_78, 2, x_65);
-lean_ctor_set(x_78, 3, x_66);
-x_79 = lean_nat_dec_eq(x_61, x_61);
-if (x_79 == 0)
-{
-lean_object* x_80; lean_object* x_81; 
-lean_dec(x_61);
-x_80 = l_Lean_nullKind;
-x_81 = l_Lean_Parser_ParserState_mkNode(x_78, x_80, x_62);
-x_19 = x_81;
-goto block_57;
-}
-else
-{
-lean_object* x_82; lean_object* x_83; lean_object* x_84; 
-x_82 = l_Lean_Parser_ParserState_restore(x_78, x_62, x_61);
-x_83 = l_Lean_nullKind;
-x_84 = l_Lean_Parser_ParserState_mkNode(x_82, x_83, x_62);
-x_19 = x_84;
-goto block_57;
-}
-}
-}
-}
-else
-{
-lean_object* x_117; lean_object* x_118; lean_object* x_119; 
+lean_object* x_73; lean_object* x_74; uint8_t x_75; 
 lean_dec(x_59);
-lean_dec(x_5);
-lean_dec(x_2);
+x_73 = l_Array_shrink___main___rarg(x_60, x_58);
+lean_inc(x_57);
+x_74 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_74, 0, x_73);
+lean_ctor_set(x_74, 1, x_57);
+lean_ctor_set(x_74, 2, x_61);
+lean_ctor_set(x_74, 3, x_62);
+x_75 = lean_nat_dec_eq(x_57, x_57);
+if (x_75 == 0)
+{
+lean_object* x_76; lean_object* x_77; 
+lean_dec(x_57);
+x_76 = l_Lean_nullKind;
+x_77 = l_Lean_Parser_ParserState_mkNode(x_74, x_76, x_58);
+x_16 = x_77;
+goto block_53;
+}
+else
+{
+lean_object* x_78; lean_object* x_79; lean_object* x_80; 
+x_78 = l_Lean_Parser_ParserState_restore(x_74, x_58, x_57);
+x_79 = l_Lean_nullKind;
+x_80 = l_Lean_Parser_ParserState_mkNode(x_78, x_79, x_58);
+x_16 = x_80;
+goto block_53;
+}
+}
+}
+}
+else
+{
+lean_object* x_113; lean_object* x_114; lean_object* x_115; 
+lean_dec(x_55);
 lean_dec(x_1);
-x_117 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
-x_118 = l_Lean_Parser_ParserState_mkNode(x_58, x_117, x_18);
-x_119 = l_Lean_Parser_mergeOrElseErrors(x_118, x_13, x_10);
-lean_dec(x_10);
-return x_119;
+x_113 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
+x_114 = l_Lean_Parser_ParserState_mkNode(x_54, x_113, x_15);
+x_115 = l_Lean_Parser_mergeOrElseErrors(x_114, x_10, x_7);
+lean_dec(x_7);
+return x_115;
 }
 }
 }
@@ -13501,7 +13224,7 @@ lean_object* _init_l_Lean_Parser_Term_structInst___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_structInst___closed__2;
@@ -13598,7 +13321,7 @@ lean_object* _init_l_Lean_Parser_Term_structInst___closed__12() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_structInst___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_structInst___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -13622,41 +13345,37 @@ x_1 = l_Lean_Parser_Term_structInst___closed__13;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, 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* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
+uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
+x_8 = lean_unbox(x_3);
+lean_dec(x_3);
+x_9 = lean_unbox(x_4);
 lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-return x_13;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_structInst___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
+return x_10;
 }
 }
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-uint8_t x_6; uint8_t x_7; lean_object* x_8; 
-x_6 = lean_unbox(x_1);
+uint8_t x_4; lean_object* x_5; 
+x_4 = lean_unbox(x_1);
 lean_dec(x_1);
-x_7 = lean_unbox(x_2);
-lean_dec(x_2);
-x_8 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(x_6, x_7, x_3, x_4, x_5);
-return x_8;
+x_5 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(x_4, x_2, x_3);
+return x_5;
 }
 }
 lean_object* l___regBuiltinParser_Lean_Parser_Term_structInst(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_structInst___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_structInst;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -13693,150 +13412,149 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_typeSpec___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_typeSpec___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_typeSpec___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_typeSpec___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -13848,7 +13566,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_typeSpec___elambda__1___closed__2;
-x_2 = l_Lean_Parser_Term_typeAscription___closed__3;
+x_2 = l_Lean_Parser_Term_typeAscription___closed__2;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
 }
@@ -13869,7 +13587,7 @@ lean_object* _init_l_Lean_Parser_Term_typeSpec___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_typeSpec___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_typeSpec___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -13893,50 +13611,50 @@ x_1 = l_Lean_Parser_Term_typeSpec___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_optType___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_optType___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
-lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-x_7 = l_Lean_Parser_Term_typeSpec___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
-lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+x_6 = l_Lean_Parser_Term_typeSpec___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_9; lean_object* x_10; 
-lean_dec(x_6);
-x_9 = l_Lean_nullKind;
-x_10 = l_Lean_Parser_ParserState_mkNode(x_7, x_9, x_5);
-return x_10;
+lean_object* x_8; lean_object* x_9; 
+lean_dec(x_5);
+x_8 = l_Lean_nullKind;
+x_9 = l_Lean_Parser_ParserState_mkNode(x_6, x_8, x_4);
+return x_9;
 }
 else
 {
-lean_object* x_11; uint8_t x_12; 
-lean_dec(x_8);
-x_11 = lean_ctor_get(x_7, 1);
-lean_inc(x_11);
-x_12 = lean_nat_dec_eq(x_11, x_6);
-lean_dec(x_11);
-if (x_12 == 0)
+lean_object* x_10; uint8_t x_11; 
+lean_dec(x_7);
+x_10 = lean_ctor_get(x_6, 1);
+lean_inc(x_10);
+x_11 = lean_nat_dec_eq(x_10, x_5);
+lean_dec(x_10);
+if (x_11 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_6);
-x_13 = l_Lean_nullKind;
-x_14 = l_Lean_Parser_ParserState_mkNode(x_7, x_13, x_5);
-return x_14;
+lean_object* x_12; lean_object* x_13; 
+lean_dec(x_5);
+x_12 = l_Lean_nullKind;
+x_13 = l_Lean_Parser_ParserState_mkNode(x_6, x_12, x_4);
+return x_13;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-x_15 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
-x_16 = l_Lean_nullKind;
-x_17 = l_Lean_Parser_ParserState_mkNode(x_15, x_16, x_5);
-return x_17;
+lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+x_14 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+x_15 = l_Lean_nullKind;
+x_16 = l_Lean_Parser_ParserState_mkNode(x_14, x_15, x_4);
+return x_16;
 }
 }
 }
@@ -13956,7 +13674,7 @@ lean_object* _init_l_Lean_Parser_Term_optType___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_optType___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_optType___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -14011,13 +13729,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_subtype___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_subtype___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_subtype___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_subtype___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_subtype___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_subtype___elambda__1___closed__5() {
@@ -14069,351 +13786,339 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_subtype___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_subtype___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_subtype___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_subtype___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+lean_dec(x_10);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_55; lean_object* x_85; lean_object* x_86; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
+x_15 = lean_array_get_size(x_14);
 lean_dec(x_14);
-if (x_15 == 0)
+lean_inc(x_1);
+x_85 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_86 = lean_ctor_get(x_85, 3);
+lean_inc(x_86);
+if (lean_obj_tag(x_86) == 0)
 {
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_87; lean_object* x_88; 
+x_87 = lean_ctor_get(x_85, 0);
+lean_inc(x_87);
+x_88 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_87);
+lean_dec(x_87);
+if (lean_obj_tag(x_88) == 2)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_58; lean_object* x_88; lean_object* x_89; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_88 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_89 = lean_ctor_get(x_88, 3);
+lean_object* x_89; lean_object* x_90; uint8_t x_91; 
+x_89 = lean_ctor_get(x_88, 1);
 lean_inc(x_89);
-if (lean_obj_tag(x_89) == 0)
-{
-lean_object* x_90; lean_object* x_91; 
-x_90 = lean_ctor_get(x_88, 0);
-lean_inc(x_90);
-x_91 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_90);
-lean_dec(x_90);
-if (lean_obj_tag(x_91) == 2)
-{
-lean_object* x_92; lean_object* x_93; uint8_t x_94; 
-x_92 = lean_ctor_get(x_91, 1);
-lean_inc(x_92);
-lean_dec(x_91);
-x_93 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
-x_94 = lean_string_dec_eq(x_92, x_93);
-lean_dec(x_92);
-if (x_94 == 0)
-{
-lean_object* x_95; lean_object* x_96; 
-x_95 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_10);
-x_96 = l_Lean_Parser_ParserState_mkErrorsAt(x_88, x_95, x_10);
-x_58 = x_96;
-goto block_87;
-}
-else
-{
-x_58 = x_88;
-goto block_87;
-}
-}
-else
-{
-lean_object* x_97; lean_object* x_98; 
-lean_dec(x_91);
-x_97 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_10);
-x_98 = l_Lean_Parser_ParserState_mkErrorsAt(x_88, x_97, x_10);
-x_58 = x_98;
-goto block_87;
-}
-}
-else
-{
-lean_object* x_99; lean_object* x_100; 
+lean_dec(x_88);
+x_90 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
+x_91 = lean_string_dec_eq(x_89, x_90);
 lean_dec(x_89);
-x_99 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_10);
-x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_88, x_99, x_10);
-x_58 = x_100;
-goto block_87;
+if (x_91 == 0)
+{
+lean_object* x_92; lean_object* x_93; 
+x_92 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_85, x_92, x_7);
+x_55 = x_93;
+goto block_84;
 }
-block_57:
+else
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_55 = x_85;
+goto block_84;
+}
+}
+else
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_termParser___closed__2;
-x_22 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
+lean_object* x_94; lean_object* x_95; 
+lean_dec(x_88);
+x_94 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_85, x_94, x_7);
+x_55 = x_95;
+goto block_84;
+}
+}
+else
+{
+lean_object* x_96; lean_object* x_97; 
+lean_dec(x_86);
+x_96 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_97 = l_Lean_Parser_ParserState_mkErrorsAt(x_85, x_96, x_7);
+x_55 = x_97;
+goto block_84;
+}
+block_54:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_22 = lean_ctor_get(x_20, 1);
+lean_inc(x_22);
+x_23 = l_Lean_Parser_tokenFn(x_1, x_20);
 x_24 = lean_ctor_get(x_23, 3);
 lean_inc(x_24);
 if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_25 = lean_ctor_get(x_23, 1);
+lean_object* x_25; lean_object* x_26; 
+x_25 = lean_ctor_get(x_23, 0);
 lean_inc(x_25);
-x_26 = l_Lean_Parser_tokenFn(x_2, x_23);
-x_27 = lean_ctor_get(x_26, 3);
+x_26 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_25);
+lean_dec(x_25);
+if (lean_obj_tag(x_26) == 2)
+{
+lean_object* x_27; lean_object* x_28; uint8_t x_29; 
+x_27 = lean_ctor_get(x_26, 1);
 lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
+lean_dec(x_26);
+x_28 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
+x_29 = lean_string_dec_eq(x_27, x_28);
+lean_dec(x_27);
+if (x_29 == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-x_28 = lean_ctor_get(x_26, 0);
-lean_inc(x_28);
-x_29 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_28);
-lean_dec(x_28);
-if (lean_obj_tag(x_29) == 2)
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_30 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22);
+x_32 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
+}
+else
 {
-lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_30 = lean_ctor_get(x_29, 1);
-lean_inc(x_30);
-lean_dec(x_29);
-x_31 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
-x_32 = lean_string_dec_eq(x_30, x_31);
-lean_dec(x_30);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_33 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_25);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_22);
 x_35 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_18);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_13, x_10);
-lean_dec(x_10);
+x_36 = l_Lean_Parser_ParserState_mkNode(x_23, x_35, x_15);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_10, x_7);
+lean_dec(x_7);
 return x_37;
 }
+}
 else
 {
-lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-lean_dec(x_25);
-x_38 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_26, x_38, x_18);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_13, x_10);
-lean_dec(x_10);
-return x_40;
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+lean_dec(x_26);
+x_38 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_38, x_22);
+x_40 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_15);
+x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_10, x_7);
+lean_dec(x_7);
+return x_42;
 }
 }
 else
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-lean_dec(x_29);
-x_41 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_41, x_25);
-x_43 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_18);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_13, x_10);
-lean_dec(x_10);
-return x_45;
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_24);
+x_43 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_43, x_22);
+x_45 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
+x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_10, x_7);
+lean_dec(x_7);
+return x_47;
 }
 }
 else
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-lean_dec(x_27);
-x_46 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_46, x_25);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_dec(x_21);
+lean_dec(x_1);
 x_48 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_18);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_13, x_10);
-lean_dec(x_10);
+x_49 = l_Lean_Parser_ParserState_mkNode(x_20, x_48, x_15);
+x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_10, x_7);
+lean_dec(x_7);
 return x_50;
 }
 }
 else
 {
 lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_dec(x_24);
-lean_dec(x_2);
+lean_dec(x_17);
+lean_dec(x_1);
 x_51 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
-x_52 = l_Lean_Parser_ParserState_mkNode(x_23, x_51, x_18);
-x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_13, x_10);
-lean_dec(x_10);
+x_52 = l_Lean_Parser_ParserState_mkNode(x_16, x_51, x_15);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_10, x_7);
+lean_dec(x_7);
 return x_53;
 }
 }
-else
+block_84:
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_54 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_19, x_54, x_18);
-x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_13, x_10);
-lean_dec(x_10);
-return x_56;
-}
-}
-block_87:
+lean_object* x_56; 
+x_56 = lean_ctor_get(x_55, 3);
+lean_inc(x_56);
+if (lean_obj_tag(x_56) == 0)
 {
-lean_object* x_59; 
-x_59 = lean_ctor_get(x_58, 3);
-lean_inc(x_59);
-if (lean_obj_tag(x_59) == 0)
-{
-lean_object* x_60; lean_object* x_61; 
-lean_inc(x_2);
+lean_object* x_57; lean_object* x_58; 
 lean_inc(x_1);
-x_60 = lean_apply_3(x_5, x_1, x_2, x_58);
-x_61 = lean_ctor_get(x_60, 3);
-lean_inc(x_61);
-if (lean_obj_tag(x_61) == 0)
+x_57 = l_Lean_Parser_ident___elambda__1(x_1, x_55);
+x_58 = lean_ctor_get(x_57, 3);
+lean_inc(x_58);
+if (lean_obj_tag(x_58) == 0)
 {
-lean_object* x_62; lean_object* x_63; 
-lean_inc(x_2);
-x_62 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_2, x_60);
+lean_object* x_59; lean_object* x_60; 
+lean_inc(x_1);
+x_59 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_57);
+x_60 = lean_ctor_get(x_59, 3);
+lean_inc(x_60);
+if (lean_obj_tag(x_60) == 0)
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_61 = lean_ctor_get(x_59, 1);
+lean_inc(x_61);
+lean_inc(x_1);
+x_62 = l_Lean_Parser_tokenFn(x_1, x_59);
 x_63 = lean_ctor_get(x_62, 3);
 lean_inc(x_63);
 if (lean_obj_tag(x_63) == 0)
 {
-lean_object* x_64; lean_object* x_65; lean_object* x_66; 
-x_64 = lean_ctor_get(x_62, 1);
+lean_object* x_64; lean_object* x_65; 
+x_64 = lean_ctor_get(x_62, 0);
 lean_inc(x_64);
-lean_inc(x_2);
-x_65 = l_Lean_Parser_tokenFn(x_2, x_62);
-x_66 = lean_ctor_get(x_65, 3);
-lean_inc(x_66);
-if (lean_obj_tag(x_66) == 0)
-{
-lean_object* x_67; lean_object* x_68; 
-x_67 = lean_ctor_get(x_65, 0);
-lean_inc(x_67);
-x_68 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_67);
-lean_dec(x_67);
-if (lean_obj_tag(x_68) == 2)
-{
-lean_object* x_69; lean_object* x_70; uint8_t x_71; 
-x_69 = lean_ctor_get(x_68, 1);
-lean_inc(x_69);
-lean_dec(x_68);
-x_70 = l_Lean_Parser_Term_subtype___elambda__1___closed__6;
-x_71 = lean_string_dec_eq(x_69, x_70);
-lean_dec(x_69);
-if (x_71 == 0)
-{
-lean_object* x_72; lean_object* x_73; 
-x_72 = l_Lean_Parser_Term_subtype___elambda__1___closed__9;
-x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_72, x_64);
-x_19 = x_73;
-goto block_57;
-}
-else
-{
+x_65 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_64);
 lean_dec(x_64);
-x_19 = x_65;
-goto block_57;
-}
-}
-else
+if (lean_obj_tag(x_65) == 2)
 {
-lean_object* x_74; lean_object* x_75; 
-lean_dec(x_68);
-x_74 = l_Lean_Parser_Term_subtype___elambda__1___closed__9;
-x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_74, x_64);
-x_19 = x_75;
-goto block_57;
-}
-}
-else
-{
-lean_object* x_76; lean_object* x_77; 
+lean_object* x_66; lean_object* x_67; uint8_t x_68; 
+x_66 = lean_ctor_get(x_65, 1);
+lean_inc(x_66);
+lean_dec(x_65);
+x_67 = l_Lean_Parser_Term_subtype___elambda__1___closed__6;
+x_68 = lean_string_dec_eq(x_66, x_67);
 lean_dec(x_66);
-x_76 = l_Lean_Parser_Term_subtype___elambda__1___closed__9;
-x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_76, x_64);
-x_19 = x_77;
-goto block_57;
+if (x_68 == 0)
+{
+lean_object* x_69; lean_object* x_70; 
+x_69 = l_Lean_Parser_Term_subtype___elambda__1___closed__9;
+x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_69, x_61);
+x_16 = x_70;
+goto block_54;
+}
+else
+{
+lean_dec(x_61);
+x_16 = x_62;
+goto block_54;
+}
+}
+else
+{
+lean_object* x_71; lean_object* x_72; 
+lean_dec(x_65);
+x_71 = l_Lean_Parser_Term_subtype___elambda__1___closed__9;
+x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_71, x_61);
+x_16 = x_72;
+goto block_54;
+}
+}
+else
+{
+lean_object* x_73; lean_object* x_74; 
+lean_dec(x_63);
+x_73 = l_Lean_Parser_Term_subtype___elambda__1___closed__9;
+x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_73, x_61);
+x_16 = x_74;
+goto block_54;
+}
+}
+else
+{
+lean_object* x_75; lean_object* x_76; lean_object* x_77; 
+lean_dec(x_60);
+lean_dec(x_1);
+x_75 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
+x_76 = l_Lean_Parser_ParserState_mkNode(x_59, x_75, x_15);
+x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_10, x_7);
+lean_dec(x_7);
+return x_77;
 }
 }
 else
 {
 lean_object* x_78; lean_object* x_79; lean_object* x_80; 
-lean_dec(x_63);
-lean_dec(x_2);
+lean_dec(x_58);
+lean_dec(x_1);
 x_78 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
-x_79 = l_Lean_Parser_ParserState_mkNode(x_62, x_78, x_18);
-x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_13, x_10);
-lean_dec(x_10);
+x_79 = l_Lean_Parser_ParserState_mkNode(x_57, x_78, x_15);
+x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_10, x_7);
+lean_dec(x_7);
 return x_80;
 }
 }
 else
 {
 lean_object* x_81; lean_object* x_82; lean_object* x_83; 
-lean_dec(x_61);
-lean_dec(x_2);
+lean_dec(x_56);
 lean_dec(x_1);
 x_81 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
-x_82 = l_Lean_Parser_ParserState_mkNode(x_60, x_81, x_18);
-x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_13, x_10);
-lean_dec(x_10);
+x_82 = l_Lean_Parser_ParserState_mkNode(x_55, x_81, x_15);
+x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_10, x_7);
+lean_dec(x_7);
 return x_83;
 }
 }
-else
-{
-lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-lean_dec(x_59);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_84 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
-x_85 = l_Lean_Parser_ParserState_mkNode(x_58, x_84, x_18);
-x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_13, x_10);
-lean_dec(x_10);
-return x_86;
-}
-}
 }
 }
 }
@@ -14442,7 +14147,7 @@ lean_object* _init_l_Lean_Parser_Term_subtype___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_explicitUniv___closed__4;
@@ -14476,7 +14181,7 @@ lean_object* _init_l_Lean_Parser_Term_subtype___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_subtype___closed__5;
@@ -14520,7 +14225,7 @@ lean_object* _init_l_Lean_Parser_Term_subtype___closed__10() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_subtype___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_subtype___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -14547,10 +14252,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_subtype(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_subtype___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_subtype;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -14597,216 +14302,216 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-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; 
-x_9 = lean_ctor_get(x_8, 0);
+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; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
+x_10 = l_Lean_Parser_termParser___closed__2;
+x_11 = lean_unsigned_to_nat(0u);
+lean_inc(x_5);
+x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_5, x_6);
+x_13 = lean_ctor_get(x_12, 3);
+lean_inc(x_13);
+if (lean_obj_tag(x_13) == 0)
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_31; lean_object* x_32; 
 lean_dec(x_9);
-x_11 = lean_ctor_get(x_8, 1);
-lean_inc(x_11);
-x_12 = l_Lean_Parser_termParser___closed__2;
-x_13 = lean_unsigned_to_nat(0u);
-lean_inc(x_7);
-x_14 = l_Lean_Parser_categoryParserFn(x_12, x_13, x_7, x_8);
-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_33; lean_object* x_34; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_16 = lean_ctor_get(x_14, 0);
+lean_dec(x_8);
+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 = lean_ctor_get(x_12, 1);
 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_inc(x_18);
-lean_inc(x_7);
-x_33 = l_Lean_Parser_tokenFn(x_7, x_14);
-x_34 = lean_ctor_get(x_33, 3);
-lean_inc(x_34);
-if (lean_obj_tag(x_34) == 0)
+lean_inc(x_5);
+x_31 = l_Lean_Parser_tokenFn(x_5, x_12);
+x_32 = lean_ctor_get(x_31, 3);
+lean_inc(x_32);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_35; lean_object* x_36; 
-x_35 = lean_ctor_get(x_33, 0);
+lean_object* x_33; lean_object* x_34; 
+x_33 = lean_ctor_get(x_31, 0);
+lean_inc(x_33);
+x_34 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_33);
+lean_dec(x_33);
+if (lean_obj_tag(x_34) == 2)
+{
+lean_object* x_35; lean_object* x_36; uint8_t x_37; 
+x_35 = lean_ctor_get(x_34, 1);
 lean_inc(x_35);
-x_36 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_35);
+lean_dec(x_34);
+x_36 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__1;
+x_37 = lean_string_dec_eq(x_35, x_36);
 lean_dec(x_35);
-if (lean_obj_tag(x_36) == 2)
+if (x_37 == 0)
 {
-lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_37 = lean_ctor_get(x_36, 1);
-lean_inc(x_37);
-lean_dec(x_36);
-x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__1;
-x_39 = lean_string_dec_eq(x_37, x_38);
-lean_dec(x_37);
-if (x_39 == 0)
-{
-lean_object* x_40; lean_object* x_41; 
-x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__4;
-lean_inc(x_18);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_18);
-x_19 = x_41;
-goto block_32;
+lean_object* x_38; lean_object* x_39; 
+x_38 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__4;
+lean_inc(x_16);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_16);
+x_17 = x_39;
+goto block_30;
 }
 else
 {
-x_19 = x_33;
-goto block_32;
+x_17 = x_31;
+goto block_30;
+}
+}
+else
+{
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_34);
+x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__4;
+lean_inc(x_16);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_16);
+x_17 = x_41;
+goto block_30;
 }
 }
 else
 {
 lean_object* x_42; lean_object* x_43; 
-lean_dec(x_36);
+lean_dec(x_32);
 x_42 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__4;
+lean_inc(x_16);
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_16);
+x_17 = x_43;
+goto block_30;
+}
+block_30:
+{
+lean_object* x_18; 
+x_18 = lean_ctor_get(x_17, 3);
 lean_inc(x_18);
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_42, x_18);
-x_19 = x_43;
-goto block_32;
-}
-}
-else
+if (lean_obj_tag(x_18) == 0)
 {
-lean_object* x_44; lean_object* x_45; 
-lean_dec(x_34);
-x_44 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__4;
-lean_inc(x_18);
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_44, x_18);
-x_19 = x_45;
-goto block_32;
-}
-block_32:
+lean_dec(x_16);
+lean_dec(x_15);
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
-{
-lean_dec(x_18);
-lean_dec(x_17);
-{
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_19;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_17;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
-lean_dec(x_20);
-lean_dec(x_7);
-x_22 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
-lean_dec(x_17);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+lean_dec(x_18);
+lean_dec(x_5);
+x_20 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
+lean_dec(x_15);
+x_21 = lean_ctor_get(x_20, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_nat_sub(x_22, x_2);
+lean_dec(x_22);
+x_24 = lean_unsigned_to_nat(1u);
+x_25 = lean_nat_dec_eq(x_23, x_24);
 lean_dec(x_23);
-x_25 = lean_nat_sub(x_24, x_3);
-lean_dec(x_24);
-x_26 = lean_unsigned_to_nat(1u);
-x_27 = lean_nat_dec_eq(x_25, x_26);
-lean_dec(x_25);
-if (x_27 == 0)
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; 
+x_26 = l_Lean_nullKind;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_2);
+return x_27;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_28; lean_object* x_29; 
 x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_22, x_28, x_3);
+x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_2);
 return x_29;
 }
 else
 {
+lean_dec(x_2);
+return x_20;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_13);
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Lean_nullKind;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_3);
-return x_31;
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_44 = lean_box(0);
+x_45 = l_Lean_Parser_ParserState_pushSyntax(x_12, x_44);
+x_46 = l_Lean_nullKind;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_2);
+return x_47;
 }
 else
 {
-lean_dec(x_3);
-return x_22;
-}
-}
-}
-}
-}
-else
-{
-lean_dec(x_15);
-lean_dec(x_7);
-if (x_5 == 0)
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_46 = lean_box(0);
-x_47 = l_Lean_Parser_ParserState_pushSyntax(x_14, x_46);
-x_48 = l_Lean_nullKind;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_3);
-return x_49;
-}
-else
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_50 = l_Lean_Parser_ParserState_restore(x_14, x_10, x_11);
-lean_dec(x_10);
-x_51 = lean_ctor_get(x_50, 0);
-lean_inc(x_51);
-x_52 = lean_array_get_size(x_51);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
+x_48 = l_Lean_Parser_ParserState_restore(x_12, x_8, x_9);
+lean_dec(x_8);
+x_49 = lean_ctor_get(x_48, 0);
+lean_inc(x_49);
+x_50 = lean_array_get_size(x_49);
+lean_dec(x_49);
+x_51 = lean_nat_sub(x_50, x_2);
+lean_dec(x_50);
+x_52 = lean_unsigned_to_nat(2u);
+x_53 = lean_nat_dec_eq(x_51, x_52);
 lean_dec(x_51);
-x_53 = lean_nat_sub(x_52, x_3);
-lean_dec(x_52);
-x_54 = lean_unsigned_to_nat(2u);
-x_55 = lean_nat_dec_eq(x_53, x_54);
-lean_dec(x_53);
-if (x_55 == 0)
+if (x_53 == 0)
+{
+lean_object* x_54; lean_object* x_55; 
+x_54 = l_Lean_nullKind;
+x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_2);
+return x_55;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_56; lean_object* x_57; 
 x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_50, x_56, x_3);
+x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_2);
 return x_57;
 }
 else
 {
-if (x_4 == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-x_58 = l_Lean_nullKind;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_50, x_58, x_3);
-return x_59;
-}
-else
-{
-lean_object* x_60; 
-lean_dec(x_3);
-x_60 = l_Lean_Parser_ParserState_popSyntax(x_50);
-return x_60;
+lean_object* x_58; 
+lean_dec(x_2);
+x_58 = l_Lean_Parser_ParserState_popSyntax(x_48);
+return x_58;
 }
 }
 }
 }
 }
 }
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = 0;
-x_9 = 1;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2(x_1, x_2, x_7, x_8, x_9, x_3, x_4, x_5);
-return x_10;
+lean_object* x_4; lean_object* x_5; uint8_t x_6; uint8_t x_7; lean_object* x_8; 
+x_4 = lean_ctor_get(x_3, 0);
+lean_inc(x_4);
+x_5 = lean_array_get_size(x_4);
+lean_dec(x_4);
+x_6 = 0;
+x_7 = 1;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2(x_1, x_5, x_6, x_7, x_2, x_3);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_listLit___elambda__1___closed__1() {
@@ -14840,13 +14545,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_listLit___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_listLit___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_listLit___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_listLit___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_listLit___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_listLit___elambda__1___closed__5() {
@@ -14931,227 +14635,221 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_listLit___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_listLit___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_listLit___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_listLit___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_56; lean_object* x_57; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_54; lean_object* x_55; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_54 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_55 = lean_ctor_get(x_54, 3);
+lean_inc(x_55);
+if (lean_obj_tag(x_55) == 0)
 {
-lean_object* x_58; lean_object* x_59; 
-x_58 = lean_ctor_get(x_56, 0);
+lean_object* x_56; lean_object* x_57; 
+x_56 = lean_ctor_get(x_54, 0);
+lean_inc(x_56);
+x_57 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_56);
+lean_dec(x_56);
+if (lean_obj_tag(x_57) == 2)
+{
+lean_object* x_58; lean_object* x_59; uint8_t x_60; 
+x_58 = lean_ctor_get(x_57, 1);
 lean_inc(x_58);
-x_59 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_58);
+lean_dec(x_57);
+x_59 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
+x_60 = lean_string_dec_eq(x_58, x_59);
 lean_dec(x_58);
-if (lean_obj_tag(x_59) == 2)
+if (x_60 == 0)
 {
-lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_60 = lean_ctor_get(x_59, 1);
-lean_inc(x_60);
-lean_dec(x_59);
-x_61 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
-x_62 = lean_string_dec_eq(x_60, x_61);
-lean_dec(x_60);
-if (x_62 == 0)
+lean_object* x_61; lean_object* x_62; 
+x_61 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+lean_inc(x_7);
+x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_7);
+x_16 = x_62;
+goto block_53;
+}
+else
+{
+x_16 = x_54;
+goto block_53;
+}
+}
+else
 {
 lean_object* x_63; lean_object* x_64; 
+lean_dec(x_57);
 x_63 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_8);
-x_17 = x_64;
-goto block_55;
-}
-else
-{
-x_17 = x_56;
-goto block_55;
+lean_inc(x_7);
+x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_63, x_7);
+x_16 = x_64;
+goto block_53;
 }
 }
 else
 {
 lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
+lean_dec(x_55);
 x_65 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_8);
-x_17 = x_66;
-goto block_55;
+lean_inc(x_7);
+x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_65, x_7);
+x_16 = x_66;
+goto block_53;
 }
-}
-else
+block_53:
 {
-lean_object* x_67; lean_object* x_68; 
-lean_dec(x_57);
-x_67 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_8);
-x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_8);
-x_17 = x_68;
-goto block_55;
-}
-block_55:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+uint8_t x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = 1;
+lean_inc(x_1);
+x_19 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_18, x_1, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-uint8_t x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = 0;
-x_20 = 1;
-lean_inc(x_2);
-x_21 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_19, x_20, x_1, x_2, x_17);
-lean_dec(x_1);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_19, 1);
+lean_inc(x_21);
+x_22 = l_Lean_Parser_tokenFn(x_1, x_19);
+x_23 = lean_ctor_get(x_22, 3);
 lean_inc(x_23);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
+if (lean_obj_tag(x_23) == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
+lean_object* x_24; lean_object* x_25; 
+x_24 = lean_ctor_get(x_22, 0);
+lean_inc(x_24);
+x_25 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_24);
+lean_dec(x_24);
+if (lean_obj_tag(x_25) == 2)
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_25, 1);
 lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
-{
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_31 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
-x_33 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_16);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_8);
-lean_dec(x_8);
-return x_38;
-}
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_39 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
-x_41 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
 lean_dec(x_25);
-x_44 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
-x_46 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
+x_27 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
+x_28 = lean_string_dec_eq(x_26, x_27);
+lean_dec(x_26);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_29 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+x_31 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_21);
+x_34 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
 }
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_22);
-lean_dec(x_2);
-x_49 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_16);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_11, x_8);
-lean_dec(x_8);
-return x_51;
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_25);
+x_37 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
+x_39 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_23);
+x_42 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
+x_44 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_20);
 lean_dec(x_1);
-x_52 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_17, x_52, x_16);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_8);
-lean_dec(x_8);
-return x_54;
+x_47 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_50 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_16, x_50, x_15);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_10, x_7);
+lean_dec(x_7);
+return x_52;
 }
 }
 }
@@ -15182,7 +14880,7 @@ lean_object* _init_l_Lean_Parser_Term_listLit___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_listLit___closed__2;
@@ -15246,7 +14944,7 @@ lean_object* _init_l_Lean_Parser_Term_listLit___closed__9() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_listLit___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_listLit___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -15270,43 +14968,37 @@ x_1 = l_Lean_Parser_Term_listLit___closed__10;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, 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* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
+uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
-lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-lean_dec(x_6);
-return x_13;
-}
-}
-lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-uint8_t x_6; uint8_t x_7; lean_object* x_8; 
-x_6 = lean_unbox(x_1);
-lean_dec(x_1);
-x_7 = lean_unbox(x_2);
-lean_dec(x_2);
-x_8 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_6, x_7, x_3, x_4, x_5);
+x_8 = lean_unbox(x_3);
 lean_dec(x_3);
-return x_8;
+x_9 = lean_unbox(x_4);
+lean_dec(x_4);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; lean_object* x_5; 
+x_4 = lean_unbox(x_1);
+lean_dec(x_1);
+x_5 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_4, x_2, x_3);
+return x_5;
 }
 }
 lean_object* l___regBuiltinParser_Lean_Parser_Term_listLit(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_listLit___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_listLit;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -15343,13 +15035,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_arrayLit___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_arrayLit___elambda__1___closed__5() {
@@ -15393,227 +15084,221 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_arrayLit___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_arrayLit___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_arrayLit___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_56; lean_object* x_57; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_54; lean_object* x_55; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_54 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_55 = lean_ctor_get(x_54, 3);
+lean_inc(x_55);
+if (lean_obj_tag(x_55) == 0)
 {
-lean_object* x_58; lean_object* x_59; 
-x_58 = lean_ctor_get(x_56, 0);
+lean_object* x_56; lean_object* x_57; 
+x_56 = lean_ctor_get(x_54, 0);
+lean_inc(x_56);
+x_57 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_56);
+lean_dec(x_56);
+if (lean_obj_tag(x_57) == 2)
+{
+lean_object* x_58; lean_object* x_59; uint8_t x_60; 
+x_58 = lean_ctor_get(x_57, 1);
 lean_inc(x_58);
-x_59 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_58);
+lean_dec(x_57);
+x_59 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__5;
+x_60 = lean_string_dec_eq(x_58, x_59);
 lean_dec(x_58);
-if (lean_obj_tag(x_59) == 2)
+if (x_60 == 0)
 {
-lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_60 = lean_ctor_get(x_59, 1);
-lean_inc(x_60);
-lean_dec(x_59);
-x_61 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__5;
-x_62 = lean_string_dec_eq(x_60, x_61);
-lean_dec(x_60);
-if (x_62 == 0)
+lean_object* x_61; lean_object* x_62; 
+x_61 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8;
+lean_inc(x_7);
+x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_7);
+x_16 = x_62;
+goto block_53;
+}
+else
+{
+x_16 = x_54;
+goto block_53;
+}
+}
+else
 {
 lean_object* x_63; lean_object* x_64; 
+lean_dec(x_57);
 x_63 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_8);
-x_17 = x_64;
-goto block_55;
-}
-else
-{
-x_17 = x_56;
-goto block_55;
+lean_inc(x_7);
+x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_63, x_7);
+x_16 = x_64;
+goto block_53;
 }
 }
 else
 {
 lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
+lean_dec(x_55);
 x_65 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_8);
-x_17 = x_66;
-goto block_55;
+lean_inc(x_7);
+x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_65, x_7);
+x_16 = x_66;
+goto block_53;
 }
-}
-else
+block_53:
 {
-lean_object* x_67; lean_object* x_68; 
-lean_dec(x_57);
-x_67 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8;
-lean_inc(x_8);
-x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_8);
-x_17 = x_68;
-goto block_55;
-}
-block_55:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+uint8_t x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = 1;
+lean_inc(x_1);
+x_19 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_18, x_1, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-uint8_t x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = 0;
-x_20 = 1;
-lean_inc(x_2);
-x_21 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_19, x_20, x_1, x_2, x_17);
-lean_dec(x_1);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_19, 1);
+lean_inc(x_21);
+x_22 = l_Lean_Parser_tokenFn(x_1, x_19);
+x_23 = lean_ctor_get(x_22, 3);
 lean_inc(x_23);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
+if (lean_obj_tag(x_23) == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
+lean_object* x_24; lean_object* x_25; 
+x_24 = lean_ctor_get(x_22, 0);
+lean_inc(x_24);
+x_25 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_24);
+lean_dec(x_24);
+if (lean_obj_tag(x_25) == 2)
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_25, 1);
 lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
-{
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_31 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
-x_33 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_16);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_8);
-lean_dec(x_8);
-return x_38;
-}
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_39 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
-x_41 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
 lean_dec(x_25);
-x_44 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
-x_46 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
+x_27 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
+x_28 = lean_string_dec_eq(x_26, x_27);
+lean_dec(x_26);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_29 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+x_31 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_21);
+x_34 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
 }
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_22);
-lean_dec(x_2);
-x_49 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_16);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_11, x_8);
-lean_dec(x_8);
-return x_51;
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_25);
+x_37 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
+x_39 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_23);
+x_42 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
+x_44 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_20);
 lean_dec(x_1);
-x_52 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_17, x_52, x_16);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_8);
-lean_dec(x_8);
-return x_54;
+x_47 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_50 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_16, x_50, x_15);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_10, x_7);
+lean_dec(x_7);
+return x_52;
 }
 }
 }
@@ -15666,7 +15351,7 @@ lean_object* _init_l_Lean_Parser_Term_arrayLit___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_arrayLit___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_arrayLit___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -15693,10 +15378,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_arrayLit(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_arrayLit;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -15733,152 +15418,147 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_explicit___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_explicit___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_explicit___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_explicit___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_explicit___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_explicit___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_explicit___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_explicit___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_explicit___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_27; lean_object* x_28; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_27 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_28 = lean_ctor_get(x_27, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_26; lean_object* x_27; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
+{
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
 lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = lean_ctor_get(x_27, 0);
-lean_inc(x_29);
-x_30 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_29);
-lean_dec(x_29);
-if (lean_obj_tag(x_30) == 2)
-{
-lean_object* x_31; lean_object* x_32; uint8_t x_33; 
-x_31 = lean_ctor_get(x_30, 1);
-lean_inc(x_31);
-lean_dec(x_30);
-x_32 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__6;
-x_33 = lean_string_dec_eq(x_31, x_32);
-lean_dec(x_31);
-if (x_33 == 0)
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
-lean_inc(x_8);
-x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_8);
-x_17 = x_35;
-goto block_26;
-}
-else
-{
-x_17 = x_27;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-lean_dec(x_30);
-x_36 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_36, x_8);
-x_17 = x_37;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
 lean_dec(x_28);
-x_38 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_38, x_8);
-x_17 = x_39;
-goto block_26;
-}
-block_26:
+if (lean_obj_tag(x_29) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
+lean_inc(x_30);
+lean_dec(x_29);
+x_31 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__6;
+x_32 = lean_string_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = l_Lean_Parser_Term_id___elambda__1(x_1, x_2, x_17);
-x_20 = l_Lean_Parser_Term_explicit___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
+lean_inc(x_7);
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_7);
+x_16 = x_34;
+goto block_25;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-lean_dec(x_18);
-lean_dec(x_2);
+x_16 = x_26;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_29);
+x_35 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_7);
+x_16 = x_36;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_27);
+x_37 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_7);
+x_16 = x_38;
+goto block_25;
+}
+block_25:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_Term_id___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Term_explicit___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_23 = l_Lean_Parser_Term_explicit___elambda__1___closed__2;
-x_24 = l_Lean_Parser_ParserState_mkNode(x_17, x_23, x_16);
-x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_11, x_8);
-lean_dec(x_8);
-return x_25;
+x_22 = l_Lean_Parser_Term_explicit___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -15933,7 +15613,7 @@ lean_object* _init_l_Lean_Parser_Term_explicit___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_explicit___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_explicit___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -15960,10 +15640,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_explicit(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_explicit___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_explicit___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_explicit;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -16000,13 +15680,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_inaccessible___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_inaccessible___elambda__1___closed__5() {
@@ -16058,222 +15737,222 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_inaccessible___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_inaccessible___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_inaccessible___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_56; lean_object* x_57; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_57 = lean_ctor_get(x_56, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_55; lean_object* x_56; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_55 = l_Lean_Parser_tokenFn(x_1, x_13);
+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);
-if (lean_obj_tag(x_57) == 0)
-{
-lean_object* x_58; lean_object* x_59; 
-x_58 = lean_ctor_get(x_56, 0);
-lean_inc(x_58);
-x_59 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_58);
-lean_dec(x_58);
-if (lean_obj_tag(x_59) == 2)
-{
-lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_60 = lean_ctor_get(x_59, 1);
-lean_inc(x_60);
-lean_dec(x_59);
-x_61 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__6;
-x_62 = lean_string_dec_eq(x_60, x_61);
-lean_dec(x_60);
-if (x_62 == 0)
-{
-lean_object* x_63; lean_object* x_64; 
-x_63 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_8);
-x_17 = x_64;
-goto block_55;
-}
-else
-{
-x_17 = x_56;
-goto block_55;
-}
-}
-else
-{
-lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
-x_65 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_8);
-x_17 = x_66;
-goto block_55;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; 
+x_58 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_57);
 lean_dec(x_57);
-x_67 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9;
-lean_inc(x_8);
-x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_8);
-x_17 = x_68;
-goto block_55;
+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);
+lean_inc(x_59);
+lean_dec(x_58);
+x_60 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__6;
+x_61 = lean_string_dec_eq(x_59, x_60);
+lean_dec(x_59);
+if (x_61 == 0)
+{
+lean_object* x_62; lean_object* x_63; 
+x_62 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9;
+lean_inc(x_7);
+x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_7);
+x_16 = x_63;
+goto block_54;
 }
-block_55:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_55;
+goto block_54;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = lean_ctor_get(x_21, 3);
+lean_object* x_64; lean_object* x_65; 
+lean_dec(x_58);
+x_64 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9;
+lean_inc(x_7);
+x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_7);
+x_16 = x_65;
+goto block_54;
+}
+}
+else
+{
+lean_object* x_66; lean_object* x_67; 
+lean_dec(x_56);
+x_66 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9;
+lean_inc(x_7);
+x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_7);
+x_16 = x_67;
+goto block_54;
+}
+block_54:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_22 = lean_ctor_get(x_20, 1);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
+x_23 = l_Lean_Parser_tokenFn(x_1, x_20);
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
-lean_inc(x_23);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
+lean_object* x_25; lean_object* x_26; 
+x_25 = lean_ctor_get(x_23, 0);
 lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
-lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
-{
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_31 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
-x_33 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_16);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_8);
-lean_dec(x_8);
-return x_38;
-}
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_39 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
-x_41 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+x_26 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_25);
 lean_dec(x_25);
-x_44 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
-x_46 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
-}
+if (lean_obj_tag(x_26) == 2)
+{
+lean_object* x_27; lean_object* x_28; uint8_t x_29; 
+x_27 = lean_ctor_get(x_26, 1);
+lean_inc(x_27);
+lean_dec(x_26);
+x_28 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_29 = lean_string_dec_eq(x_27, x_28);
+lean_dec(x_27);
+if (x_29 == 0)
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_30 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22);
+x_32 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_15);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_10, x_7);
+lean_dec(x_7);
+return x_34;
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
 lean_dec(x_22);
-lean_dec(x_2);
-x_49 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_16);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_11, x_8);
-lean_dec(x_8);
-return x_51;
+x_35 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_23, x_35, x_15);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_10, x_7);
+lean_dec(x_7);
+return x_37;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_52 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_17, x_52, x_16);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_8);
-lean_dec(x_8);
-return x_54;
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+lean_dec(x_26);
+x_38 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_38, x_22);
+x_40 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
+x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_15);
+x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_10, x_7);
+lean_dec(x_7);
+return x_42;
+}
+}
+else
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_24);
+x_43 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_43, x_22);
+x_45 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
+x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15);
+x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_10, x_7);
+lean_dec(x_7);
+return x_47;
+}
+}
+else
+{
+lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_dec(x_21);
+lean_dec(x_1);
+x_48 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
+x_49 = l_Lean_Parser_ParserState_mkNode(x_20, x_48, x_15);
+x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_10, x_7);
+lean_dec(x_7);
+return x_50;
+}
+}
+else
+{
+lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_51 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
+x_52 = l_Lean_Parser_ParserState_mkNode(x_16, x_51, x_15);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_10, x_7);
+lean_dec(x_7);
+return x_53;
 }
 }
 }
@@ -16294,10 +15973,10 @@ lean_object* _init_l_Lean_Parser_Term_inaccessible___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
+x_3 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
 x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
@@ -16338,7 +16017,7 @@ lean_object* _init_l_Lean_Parser_Term_inaccessible___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_inaccessible___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_inaccessible___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -16365,70 +16044,64 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_inaccessible(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_inaccessible;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_Term_binderIdent___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_binderIdent___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
+x_6 = l_Lean_Parser_ident___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_9;
+return x_6;
 }
 else
 {
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
-lean_dec(x_11);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
 lean_dec(x_7);
-x_15 = l_Lean_Parser_Term_hole___elambda__1(x_1, x_2, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+x_10 = lean_nat_dec_eq(x_9, x_5);
+lean_dec(x_9);
+if (x_10 == 0)
+{
 lean_dec(x_8);
-return x_16;
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = l_Lean_Parser_Term_hole___elambda__1(x_1, x_11);
+x_13 = l_Lean_Parser_mergeOrElseErrors(x_12, x_8, x_5);
+lean_dec(x_5);
+return x_13;
 }
 }
 }
@@ -16437,7 +16110,7 @@ lean_object* _init_l_Lean_Parser_Term_binderIdent___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_hole;
@@ -16451,7 +16124,7 @@ lean_object* _init_l_Lean_Parser_Term_binderIdent___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderIdent___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderIdent___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -16475,7 +16148,7 @@ x_1 = l_Lean_Parser_Term_binderIdent___closed__3;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_binderType___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Term_binderType___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_29; lean_object* x_30; 
@@ -16494,7 +16167,7 @@ if (lean_obj_tag(x_30) == 0)
 lean_object* x_31; lean_object* x_32; 
 x_31 = lean_ctor_get(x_29, 0);
 lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
+x_32 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_31);
 lean_dec(x_31);
 if (lean_obj_tag(x_32) == 2)
 {
@@ -16551,7 +16224,7 @@ if (lean_obj_tag(x_7) == 0)
 lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_8 = l_Lean_Parser_termParser___closed__2;
 x_9 = lean_unsigned_to_nat(0u);
-x_10 = l_Lean_Parser_categoryParserFn(x_8, x_9, x_1, x_6);
+x_10 = l_Lean_Parser_categoryParser___elambda__1(x_8, x_9, x_1, x_6);
 x_11 = lean_ctor_get(x_10, 3);
 lean_inc(x_11);
 if (lean_obj_tag(x_11) == 0)
@@ -16617,15 +16290,7 @@ return x_27;
 }
 }
 }
-lean_object* l_Lean_Parser_Term_binderType___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderType___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Term_binderType___elambda__2___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Term_binderType___elambda__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
@@ -16644,7 +16309,7 @@ if (lean_obj_tag(x_17) == 0)
 lean_object* x_18; lean_object* x_19; 
 x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-x_19 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_18);
+x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18);
 lean_dec(x_18);
 if (lean_obj_tag(x_19) == 2)
 {
@@ -16699,7 +16364,7 @@ if (lean_obj_tag(x_6) == 0)
 lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_7 = l_Lean_Parser_termParser___closed__2;
 x_8 = lean_unsigned_to_nat(0u);
-x_9 = l_Lean_Parser_categoryParserFn(x_7, x_8, x_1, x_5);
+x_9 = l_Lean_Parser_categoryParser___elambda__1(x_7, x_8, x_1, x_5);
 x_10 = l_Lean_nullKind;
 x_11 = l_Lean_Parser_ParserState_mkNode(x_9, x_10, x_4);
 return x_11;
@@ -16716,19 +16381,11 @@ return x_13;
 }
 }
 }
-lean_object* l_Lean_Parser_Term_binderType___elambda__2(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderType___elambda__2___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Term_binderType___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__3;
+x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
 x_2 = l_Lean_Parser_optionaInfo(x_1);
 return x_2;
 }
@@ -16737,7 +16394,7 @@ lean_object* _init_l_Lean_Parser_Term_binderType___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderType___elambda__1___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderType___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -16758,7 +16415,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_nullKind;
-x_2 = l_Lean_Parser_Term_typeAscription___closed__3;
+x_2 = l_Lean_Parser_Term_typeAscription___closed__2;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
 }
@@ -16767,7 +16424,7 @@ lean_object* _init_l_Lean_Parser_Term_binderType___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderType___elambda__2___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderType___elambda__2), 2, 0);
 return x_1;
 }
 }
@@ -16800,24 +16457,6 @@ return x_3;
 }
 }
 }
-lean_object* l_Lean_Parser_Term_binderType___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Term_binderType___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Term_binderType___elambda__2___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Term_binderType___elambda__2(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* l_Lean_Parser_Term_binderType___boxed(lean_object* x_1) {
 _start:
 {
@@ -16859,150 +16498,149 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_binderDefault___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_binderDefault___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_binderDefault___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_binderDefault___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_binderDefault___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_binderDefault___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_binderDefault___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_binderDefault___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_binderDefault___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_binderDefault___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_binderDefault___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_binderDefault___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_binderDefault___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -17035,7 +16673,7 @@ lean_object* _init_l_Lean_Parser_Term_binderDefault___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderDefault___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderDefault___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -17090,150 +16728,149 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_binderTactic___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_binderTactic___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_binderTactic___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_binderTactic___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_structInst___elambda__1___closed__7;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_structInst___elambda__1___closed__7;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_structInst___elambda__1___closed__10;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -17244,7 +16881,7 @@ lean_object* _init_l_Lean_Parser_Term_binderTactic___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_structInst___closed__2;
@@ -17278,7 +16915,7 @@ lean_object* _init_l_Lean_Parser_Term_binderTactic___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderTactic___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_binderTactic___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -17333,72 +16970,68 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_explicitBinder___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-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; 
-x_5 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__4;
-x_6 = lean_ctor_get(x_5, 1);
+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_explicitBinder___elambda__1___closed__4;
+x_5 = lean_ctor_get(x_4, 1);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_3, 0);
 lean_inc(x_6);
-x_7 = lean_ctor_get(x_4, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = lean_ctor_get(x_4, 1);
-lean_inc(x_9);
-lean_inc(x_3);
+x_7 = lean_array_get_size(x_6);
+lean_dec(x_6);
+x_8 = lean_ctor_get(x_3, 1);
+lean_inc(x_8);
 lean_inc(x_2);
-x_10 = lean_apply_3(x_6, x_2, x_3, x_4);
-x_11 = lean_ctor_get(x_10, 3);
+x_9 = lean_apply_2(x_5, x_2, x_3);
+x_10 = lean_ctor_get(x_9, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_dec(x_9);
-lean_dec(x_8);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_10;
-}
-else
-{
-lean_object* x_12; lean_object* x_13; uint8_t x_14; 
-x_12 = lean_ctor_get(x_11, 0);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_9, 1);
 lean_inc(x_12);
-lean_dec(x_11);
-x_13 = lean_ctor_get(x_10, 1);
-lean_inc(x_13);
-x_14 = lean_nat_dec_eq(x_13, x_9);
-lean_dec(x_13);
-if (x_14 == 0)
-{
+x_13 = lean_nat_dec_eq(x_12, x_8);
 lean_dec(x_12);
-lean_dec(x_9);
+if (x_13 == 0)
+{
+lean_dec(x_11);
 lean_dec(x_8);
-lean_dec(x_3);
+lean_dec(x_7);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_10;
+return x_9;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-lean_inc(x_9);
-x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_inc(x_8);
+x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+lean_dec(x_7);
+x_15 = lean_apply_2(x_1, x_2, x_14);
+x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
 lean_dec(x_8);
-x_16 = lean_apply_3(x_1, x_2, x_3, x_15);
-x_17 = l_Lean_Parser_mergeOrElseErrors(x_16, x_12, x_9);
-lean_dec(x_9);
-return x_17;
+return x_16;
 }
 }
 }
@@ -17406,22 +17039,29 @@ return x_17;
 lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_binderIdent___closed__2;
-x_3 = 0;
-x_4 = lean_box(x_1);
-x_5 = lean_box(x_3);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 6, 3);
-lean_closure_set(x_6, 0, x_4);
-lean_closure_set(x_6, 1, x_2);
-lean_closure_set(x_6, 2, x_5);
-return x_6;
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
+lean_closure_set(x_2, 0, x_1);
+return x_2;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__2() {
 _start:
 {
+lean_object* x_1; uint8_t x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_binderIdent___closed__2;
+x_2 = 0;
+x_3 = lean_box(x_2);
+x_4 = lean_alloc_closure((void*)(l_Lean_Parser_many1Fn___boxed), 4, 2);
+lean_closure_set(x_4, 0, x_1);
+lean_closure_set(x_4, 1, x_3);
+return x_4;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__3() {
+_start:
+{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_1 = l_Lean_Parser_Term_binderDefault;
 x_2 = lean_ctor_get(x_1, 0);
@@ -17433,54 +17073,64 @@ x_5 = l_Lean_Parser_orelseInfo(x_2, x_4);
 return x_5;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__3() {
+lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_binderDefault___closed__3;
 x_2 = l_Lean_Parser_Term_binderTactic___closed__4;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 2);
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__4() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_explicitBinder___closed__2;
-x_2 = l_Lean_Parser_optionaInfo(x_1);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_Parser_Term_explicitBinder___closed__3;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn___rarg), 4, 1);
-lean_closure_set(x_2, 0, x_1);
+x_2 = l_Lean_Parser_optionaInfo(x_1);
 return x_2;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__6() {
 _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_explicitBinder___closed__4;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__6;
-x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
-return x_3;
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_optionalFn), 3, 1);
+lean_closure_set(x_2, 0, x_1);
+return x_2;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__7() {
 _start:
 {
+lean_object* x_1; lean_object* x_2; 
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
+lean_closure_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__8() {
+_start:
+{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_explicitBinder___closed__5;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__7;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_explicitBinder___closed__9() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_explicitBinder___closed__6;
+x_2 = l_Lean_Parser_Term_explicitBinder___closed__7;
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);
 return x_3;
@@ -17489,51 +17139,48 @@ return x_3;
 lean_object* l_Lean_Parser_Term_explicitBinder(uint8_t x_1) {
 _start:
 {
-lean_object* x_2; 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; uint8_t 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_2; 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; 
 x_2 = l_Lean_Parser_Term_binderIdent;
 x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
 x_4 = l_Lean_Parser_Term_binderType(x_1);
 x_5 = lean_ctor_get(x_4, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_explicitBinder___closed__6;
+x_6 = l_Lean_Parser_Term_explicitBinder___closed__8;
 x_7 = l_Lean_Parser_andthenInfo(x_5, x_6);
 x_8 = lean_ctor_get(x_4, 1);
 lean_inc(x_8);
 lean_dec(x_4);
-x_9 = l_Lean_Parser_Term_explicitBinder___closed__7;
-x_10 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_9 = l_Lean_Parser_Term_explicitBinder___closed__9;
+x_10 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_10, 0, x_8);
 lean_closure_set(x_10, 1, x_9);
 x_11 = l_Lean_Parser_andthenInfo(x_3, x_7);
-x_12 = l_Lean_Parser_Term_explicitBinder___closed__1;
-x_13 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_12 = l_Lean_Parser_Term_explicitBinder___closed__2;
+x_13 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_13, 0, x_12);
 lean_closure_set(x_13, 1, x_10);
-x_14 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
+x_14 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 x_15 = l_Lean_Parser_andthenInfo(x_14, x_11);
-x_16 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__3;
-x_17 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_16 = l_Lean_Parser_Term_explicitBinder___closed__1;
+x_17 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_17, 0, x_16);
 lean_closure_set(x_17, 1, x_13);
 x_18 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__2;
 x_19 = l_Lean_Parser_nodeInfo(x_18, x_15);
-x_20 = 0;
-x_21 = lean_box(x_20);
-x_22 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_22, 0, x_21);
-lean_closure_set(x_22, 1, x_18);
-lean_closure_set(x_22, 2, x_17);
-x_23 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__4;
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = l_Lean_Parser_orelseInfo(x_24, x_19);
-x_26 = lean_alloc_closure((void*)(l_Lean_Parser_Term_explicitBinder___elambda__1), 4, 1);
-lean_closure_set(x_26, 0, x_22);
-x_27 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_27, 0, x_25);
-lean_ctor_set(x_27, 1, x_26);
-return x_27;
+x_20 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+lean_closure_set(x_20, 0, x_18);
+lean_closure_set(x_20, 1, x_17);
+x_21 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__4;
+x_22 = lean_ctor_get(x_21, 0);
+lean_inc(x_22);
+x_23 = l_Lean_Parser_orelseInfo(x_22, x_19);
+x_24 = lean_alloc_closure((void*)(l_Lean_Parser_Term_explicitBinder___elambda__1), 3, 1);
+lean_closure_set(x_24, 0, x_20);
+x_25 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_25, 0, x_23);
+lean_ctor_set(x_25, 1, x_24);
+return x_25;
 }
 }
 lean_object* l_Lean_Parser_Term_explicitBinder___boxed(lean_object* x_1) {
@@ -17577,72 +17224,68 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_implicitBinder___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_implicitBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_Term_implicitBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-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; 
-x_5 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__4;
-x_6 = lean_ctor_get(x_5, 1);
+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_implicitBinder___elambda__1___closed__4;
+x_5 = lean_ctor_get(x_4, 1);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_3, 0);
 lean_inc(x_6);
-x_7 = lean_ctor_get(x_4, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = lean_ctor_get(x_4, 1);
-lean_inc(x_9);
-lean_inc(x_3);
+x_7 = lean_array_get_size(x_6);
+lean_dec(x_6);
+x_8 = lean_ctor_get(x_3, 1);
+lean_inc(x_8);
 lean_inc(x_2);
-x_10 = lean_apply_3(x_6, x_2, x_3, x_4);
-x_11 = lean_ctor_get(x_10, 3);
+x_9 = lean_apply_2(x_5, x_2, x_3);
+x_10 = lean_ctor_get(x_9, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_dec(x_9);
-lean_dec(x_8);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_10;
-}
-else
-{
-lean_object* x_12; lean_object* x_13; uint8_t x_14; 
-x_12 = lean_ctor_get(x_11, 0);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_9, 1);
 lean_inc(x_12);
-lean_dec(x_11);
-x_13 = lean_ctor_get(x_10, 1);
-lean_inc(x_13);
-x_14 = lean_nat_dec_eq(x_13, x_9);
-lean_dec(x_13);
-if (x_14 == 0)
-{
+x_13 = lean_nat_dec_eq(x_12, x_8);
 lean_dec(x_12);
-lean_dec(x_9);
+if (x_13 == 0)
+{
+lean_dec(x_11);
 lean_dec(x_8);
-lean_dec(x_3);
+lean_dec(x_7);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_10;
+return x_9;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-lean_inc(x_9);
-x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_inc(x_8);
+x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+lean_dec(x_7);
+x_15 = lean_apply_2(x_1, x_2, x_14);
+x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
 lean_dec(x_8);
-x_16 = lean_apply_3(x_1, x_2, x_3, x_15);
-x_17 = l_Lean_Parser_mergeOrElseErrors(x_16, x_12, x_9);
-lean_dec(x_9);
-return x_17;
+return x_16;
 }
 }
 }
@@ -17652,7 +17295,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
@@ -17662,7 +17305,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
@@ -17670,7 +17313,7 @@ return x_2;
 lean_object* l_Lean_Parser_Term_implicitBinder(uint8_t x_1) {
 _start:
 {
-lean_object* x_2; 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; uint8_t 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_2; 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; 
 x_2 = l_Lean_Parser_Term_binderIdent;
 x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
@@ -17683,38 +17326,35 @@ x_8 = lean_ctor_get(x_4, 1);
 lean_inc(x_8);
 lean_dec(x_4);
 x_9 = l_Lean_Parser_Term_implicitBinder___closed__2;
-x_10 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_10 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_10, 0, x_8);
 lean_closure_set(x_10, 1, x_9);
 x_11 = l_Lean_Parser_andthenInfo(x_3, x_7);
-x_12 = l_Lean_Parser_Term_explicitBinder___closed__1;
-x_13 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_12 = l_Lean_Parser_Term_explicitBinder___closed__2;
+x_13 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_13, 0, x_12);
 lean_closure_set(x_13, 1, x_10);
 x_14 = l_Lean_Parser_Term_subtype___closed__1;
 x_15 = l_Lean_Parser_andthenInfo(x_14, x_11);
 x_16 = l_Lean_Parser_Term_implicitBinder___closed__1;
-x_17 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_17 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_17, 0, x_16);
 lean_closure_set(x_17, 1, x_13);
 x_18 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2;
 x_19 = l_Lean_Parser_nodeInfo(x_18, x_15);
-x_20 = 0;
-x_21 = lean_box(x_20);
-x_22 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn___boxed), 6, 3);
-lean_closure_set(x_22, 0, x_21);
-lean_closure_set(x_22, 1, x_18);
-lean_closure_set(x_22, 2, x_17);
-x_23 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__4;
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = l_Lean_Parser_orelseInfo(x_24, x_19);
-x_26 = lean_alloc_closure((void*)(l_Lean_Parser_Term_implicitBinder___elambda__1), 4, 1);
-lean_closure_set(x_26, 0, x_22);
-x_27 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_27, 0, x_25);
-lean_ctor_set(x_27, 1, x_26);
-return x_27;
+x_20 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2);
+lean_closure_set(x_20, 0, x_18);
+lean_closure_set(x_20, 1, x_17);
+x_21 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__4;
+x_22 = lean_ctor_get(x_21, 0);
+lean_inc(x_22);
+x_23 = l_Lean_Parser_orelseInfo(x_22, x_19);
+x_24 = lean_alloc_closure((void*)(l_Lean_Parser_Term_implicitBinder___elambda__1), 3, 1);
+lean_closure_set(x_24, 0, x_20);
+x_25 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_25, 0, x_23);
+lean_ctor_set(x_25, 1, x_24);
+return x_25;
 }
 }
 lean_object* l_Lean_Parser_Term_implicitBinder___boxed(lean_object* x_1) {
@@ -17758,254 +17398,249 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_instBinder___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_instBinder___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_instBinder___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_instBinder___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_instBinder___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_instBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_instBinder___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_instBinder___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_instBinder___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_61; lean_object* x_62; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_61 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_62 = lean_ctor_get(x_61, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_60; lean_object* x_61; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_60 = l_Lean_Parser_tokenFn(x_1, x_13);
+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 = lean_ctor_get(x_60, 0);
 lean_inc(x_62);
-if (lean_obj_tag(x_62) == 0)
-{
-lean_object* x_63; lean_object* x_64; 
-x_63 = lean_ctor_get(x_61, 0);
-lean_inc(x_63);
-x_64 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_63);
-lean_dec(x_63);
-if (lean_obj_tag(x_64) == 2)
-{
-lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_65 = lean_ctor_get(x_64, 1);
-lean_inc(x_65);
-lean_dec(x_64);
-x_66 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
-x_67 = lean_string_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_8);
-x_69 = l_Lean_Parser_ParserState_mkErrorsAt(x_61, x_68, x_8);
-x_17 = x_69;
-goto block_60;
-}
-else
-{
-x_17 = x_61;
-goto block_60;
-}
-}
-else
-{
-lean_object* x_70; lean_object* x_71; 
-lean_dec(x_64);
-x_70 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_8);
-x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_61, x_70, x_8);
-x_17 = x_71;
-goto block_60;
-}
-}
-else
-{
-lean_object* x_72; lean_object* x_73; 
+x_63 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_62);
 lean_dec(x_62);
-x_72 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
-lean_inc(x_8);
-x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_61, x_72, x_8);
-x_17 = x_73;
-goto block_60;
+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_listLit___elambda__1___closed__5;
+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_listLit___elambda__1___closed__12;
+lean_inc(x_7);
+x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_67, x_7);
+x_16 = x_68;
+goto block_59;
 }
-block_60:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_60;
+goto block_59;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
-x_19 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+lean_object* x_69; lean_object* x_70; 
+lean_dec(x_63);
+x_69 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+lean_inc(x_7);
+x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_69, x_7);
+x_16 = x_70;
+goto block_59;
+}
+}
+else
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_termParser___closed__2;
-x_22 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = lean_ctor_get(x_23, 3);
+lean_object* x_71; lean_object* x_72; 
+lean_dec(x_61);
+x_71 = l_Lean_Parser_Term_listLit___elambda__1___closed__12;
+lean_inc(x_7);
+x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_71, x_7);
+x_16 = x_72;
+goto block_59;
+}
+block_59:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = l_Lean_Parser_termParser___closed__2;
+x_21 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+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; 
+x_24 = lean_ctor_get(x_22, 1);
 lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
+x_25 = l_Lean_Parser_tokenFn(x_1, x_22);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_25 = lean_ctor_get(x_23, 1);
-lean_inc(x_25);
-x_26 = l_Lean_Parser_tokenFn(x_2, x_23);
-x_27 = lean_ctor_get(x_26, 3);
+lean_object* x_27; lean_object* x_28; 
+x_27 = lean_ctor_get(x_25, 0);
 lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; lean_object* x_29; 
-x_28 = lean_ctor_get(x_26, 0);
-lean_inc(x_28);
-x_29 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_28);
-lean_dec(x_28);
-if (lean_obj_tag(x_29) == 2)
-{
-lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_30 = lean_ctor_get(x_29, 1);
-lean_inc(x_30);
-lean_dec(x_29);
-x_31 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
-x_32 = lean_string_dec_eq(x_30, x_31);
-lean_dec(x_30);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_33 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_25);
-x_35 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_16);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_11, x_8);
-lean_dec(x_8);
-return x_37;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-lean_dec(x_25);
-x_38 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_26, x_38, x_16);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_11, x_8);
-lean_dec(x_8);
-return x_40;
-}
-}
-else
-{
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-lean_dec(x_29);
-x_41 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_41, x_25);
-x_43 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_16);
-x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_11, x_8);
-lean_dec(x_8);
-return x_45;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_28 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_27);
 lean_dec(x_27);
-x_46 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_46, x_25);
-x_48 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
-x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_16);
-x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_11, x_8);
-lean_dec(x_8);
-return x_50;
-}
+if (lean_obj_tag(x_28) == 2)
+{
+lean_object* x_29; lean_object* x_30; uint8_t x_31; 
+x_29 = lean_ctor_get(x_28, 1);
+lean_inc(x_29);
+lean_dec(x_28);
+x_30 = l_Lean_Parser_Term_listLit___elambda__1___closed__6;
+x_31 = lean_string_dec_eq(x_29, x_30);
+lean_dec(x_29);
+if (x_31 == 0)
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_32 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_32, x_24);
+x_34 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
 lean_dec(x_24);
-lean_dec(x_2);
-x_51 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
-x_52 = l_Lean_Parser_ParserState_mkNode(x_23, x_51, x_16);
-x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_11, x_8);
-lean_dec(x_8);
-return x_53;
+x_37 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
+x_38 = l_Lean_Parser_ParserState_mkNode(x_25, x_37, x_15);
+x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_10, x_7);
+lean_dec(x_7);
+return x_39;
 }
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_54 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_19, x_54, x_16);
-x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_11, x_8);
-lean_dec(x_8);
-return x_56;
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+lean_dec(x_28);
+x_40 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_40, x_24);
+x_42 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
+x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_15);
+x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_10, x_7);
+lean_dec(x_7);
+return x_44;
 }
 }
 else
 {
-lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_26);
+x_45 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
+x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_45, x_24);
+x_47 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_23);
 lean_dec(x_1);
-x_57 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
-x_58 = l_Lean_Parser_ParserState_mkNode(x_17, x_57, x_16);
-x_59 = l_Lean_Parser_mergeOrElseErrors(x_58, x_11, x_8);
-lean_dec(x_8);
-return x_59;
+x_50 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_22, x_50, x_15);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_10, x_7);
+lean_dec(x_7);
+return x_52;
+}
+}
+else
+{
+lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_53 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
+x_54 = l_Lean_Parser_ParserState_mkNode(x_18, x_53, x_15);
+x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_10, x_7);
+lean_dec(x_7);
+return x_55;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_56 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2;
+x_57 = l_Lean_Parser_ParserState_mkNode(x_16, x_56, x_15);
+x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_10, x_7);
+lean_dec(x_7);
+return x_58;
 }
 }
 }
@@ -18026,7 +17661,7 @@ lean_object* _init_l_Lean_Parser_Term_instBinder___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_listLit___closed__4;
@@ -18082,7 +17717,7 @@ lean_object* _init_l_Lean_Parser_Term_instBinder___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_instBinder___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_instBinder___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -18106,60 +17741,57 @@ x_1 = l_Lean_Parser_Term_instBinder___closed__8;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_bracktedBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_Parser_Term_bracktedBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_5, 1);
-lean_inc(x_8);
-lean_inc(x_4);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_4, 1);
+lean_inc(x_7);
 lean_inc(x_3);
-x_9 = lean_apply_3(x_2, x_3, x_4, x_5);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_2, x_3, x_4);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_4);
+lean_dec(x_6);
 lean_dec(x_3);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_apply_2(x_1, x_3, x_13);
+x_15 = l_Lean_Parser_mergeOrElseErrors(x_14, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_apply_3(x_1, x_3, x_4, x_14);
-x_16 = l_Lean_Parser_mergeOrElseErrors(x_15, x_11, x_8);
-lean_dec(x_8);
-return x_16;
+return x_15;
 }
 }
 }
@@ -18180,7 +17812,7 @@ x_8 = lean_ctor_get(x_3, 1);
 lean_inc(x_8);
 lean_dec(x_3);
 x_9 = l_Lean_Parser_Term_instBinder___closed__7;
-x_10 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn___rarg), 5, 2);
+x_10 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn), 4, 2);
 lean_closure_set(x_10, 0, x_8);
 lean_closure_set(x_10, 1, x_9);
 x_11 = lean_ctor_get(x_2, 0);
@@ -18189,7 +17821,7 @@ x_12 = l_Lean_Parser_orelseInfo(x_11, x_7);
 x_13 = lean_ctor_get(x_2, 1);
 lean_inc(x_13);
 lean_dec(x_2);
-x_14 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bracktedBinder___elambda__1), 5, 2);
+x_14 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bracktedBinder___elambda__1), 4, 2);
 lean_closure_set(x_14, 0, x_10);
 lean_closure_set(x_14, 1, x_13);
 x_15 = lean_alloc_ctor(0, 2, 0);
@@ -18239,13 +17871,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_depArrow___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_depArrow___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__5() {
@@ -18375,119 +18006,113 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_depArrow___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_depArrow___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_depArrow___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_depArrow___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_Term_depArrow___elambda__1___closed__5;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Term_depArrow___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
+lean_inc(x_1);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
 lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
-lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
 lean_inc(x_1);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_18 = lean_apply_2(x_4, x_1, x_15);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-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; 
-x_21 = l_Lean_Parser_Term_depArrow___elambda__1___closed__7;
-x_22 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9;
-x_23 = lean_unsigned_to_nat(25u);
-x_24 = l_Lean_Parser_Term_depArrow___elambda__1___closed__15;
-x_25 = l_Lean_Parser_Term_depArrow___elambda__1___closed__17;
-lean_inc(x_2);
-x_26 = l_Lean_Parser_unicodeSymbolCheckPrecFnAux(x_21, x_22, x_23, x_24, x_25, x_1, x_2, x_19);
-lean_dec(x_1);
-x_27 = lean_ctor_get(x_26, 3);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
+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; 
+x_20 = l_Lean_Parser_Term_depArrow___elambda__1___closed__7;
+x_21 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9;
+x_22 = lean_unsigned_to_nat(25u);
+x_23 = l_Lean_Parser_Term_depArrow___elambda__1___closed__15;
+x_24 = l_Lean_Parser_Term_depArrow___elambda__1___closed__17;
+lean_inc(x_1);
+x_25 = l_Lean_Parser_unicodeSymbolCheckPrecFnAux(x_20, x_21, x_22, x_23, x_24, x_1, x_18);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_28 = l_Lean_Parser_termParser___closed__2;
-x_29 = lean_unsigned_to_nat(0u);
-x_30 = l_Lean_Parser_categoryParserFn(x_28, x_29, x_2, x_26);
-x_31 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_18);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_13, x_10);
-lean_dec(x_10);
-return x_33;
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_27 = l_Lean_Parser_termParser___closed__2;
+x_28 = lean_unsigned_to_nat(0u);
+x_29 = l_Lean_Parser_categoryParser___elambda__1(x_27, x_28, x_1, x_25);
+x_30 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_17);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_12, x_9);
+lean_dec(x_9);
+return x_32;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-lean_dec(x_27);
-lean_dec(x_2);
-x_34 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2;
-x_35 = l_Lean_Parser_ParserState_mkNode(x_26, x_34, x_18);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_13, x_10);
-lean_dec(x_10);
-return x_36;
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_26);
+lean_dec(x_1);
+x_33 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_25, x_33, x_17);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_12, x_9);
+lean_dec(x_9);
+return x_35;
 }
 }
 else
 {
-lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_20);
-lean_dec(x_2);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_19);
 lean_dec(x_1);
-x_37 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_19, x_37, x_18);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_13, x_10);
-lean_dec(x_10);
-return x_39;
+x_36 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_18, x_36, x_17);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_12, x_9);
+lean_dec(x_9);
+return x_38;
 }
 }
 }
@@ -18518,7 +18143,7 @@ lean_object* _init_l_Lean_Parser_Term_depArrow___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_depArrow___closed__2;
@@ -18564,7 +18189,7 @@ lean_object* _init_l_Lean_Parser_Term_depArrow___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_depArrow___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_depArrow___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -18591,76 +18216,73 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_depArrow(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_depArrow;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_simpleBinder___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_simpleBinder___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-lean_inc(x_2);
-x_8 = l_Lean_Parser_Term_binderIdent___elambda__1(x_2, x_3, x_4);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
+x_4 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Term_binderIdent___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_10; uint8_t x_11; 
-lean_dec(x_6);
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_7, x_10);
-lean_dec(x_10);
-lean_dec(x_7);
-if (x_11 == 0)
+lean_object* x_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
+lean_dec(x_5);
+if (x_9 == 0)
 {
-x_4 = x_8;
+x_2 = x_6;
 goto _start;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_13 = l_Lean_Parser_manyAux___main___closed__1;
-x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
-return x_14;
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_15; uint8_t x_16; 
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_15 = lean_ctor_get(x_8, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_7, x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+lean_object* x_13; uint8_t x_14; 
 lean_dec(x_7);
-lean_dec(x_6);
-return x_8;
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_17;
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+return x_15;
 }
 }
 }
@@ -18696,103 +18318,96 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_simpleBinder___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_simpleBinder___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_simpleBinder___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_simpleBinder___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_simpleBinder___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_simpleBinder___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_simpleBinder___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_simpleBinder___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_simpleBinder___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
 lean_inc(x_1);
-x_17 = l_Lean_Parser_Term_binderIdent___elambda__1(x_1, x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = l_Lean_Parser_Term_binderIdent___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-uint8_t 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; 
-x_19 = 0;
-x_20 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_simpleBinder___elambda__1___spec__1(x_19, x_1, x_2, x_17);
-x_21 = l_Lean_nullKind;
-lean_inc(x_16);
-x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_16);
-x_23 = l_Lean_Parser_Term_simpleBinder___elambda__1___closed__2;
-x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_16);
-x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_11, x_8);
-lean_dec(x_8);
-return x_25;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_simpleBinder___elambda__1___spec__1(x_1, x_16);
+x_19 = l_Lean_nullKind;
+lean_inc(x_15);
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_Term_simpleBinder___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
 }
 else
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_26 = l_Lean_nullKind;
-lean_inc(x_16);
-x_27 = l_Lean_Parser_ParserState_mkNode(x_17, x_26, x_16);
-x_28 = l_Lean_Parser_Term_simpleBinder___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_16);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_11, x_8);
-lean_dec(x_8);
-return x_30;
+x_24 = l_Lean_nullKind;
+lean_inc(x_15);
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_Term_simpleBinder___elambda__1___closed__2;
+x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_15);
+x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_10, x_7);
+lean_dec(x_7);
+return x_28;
 }
 }
 }
@@ -18826,7 +18441,7 @@ lean_object* _init_l_Lean_Parser_Term_simpleBinder___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_simpleBinder___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_simpleBinder___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -18850,16 +18465,6 @@ x_1 = l_Lean_Parser_Term_simpleBinder___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_simpleBinder___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_simpleBinder___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-return x_6;
-}
-}
 lean_object* _init_l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1() {
 _start:
 {
@@ -18869,111 +18474,107 @@ x_2 = l_Lean_Parser_Term_bracktedBinder(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-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_21; lean_object* x_22; 
-x_5 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
-x_6 = lean_ctor_get(x_5, 1);
-lean_inc(x_6);
-x_7 = lean_ctor_get(x_4, 0);
+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_19; lean_object* x_20; 
+x_3 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = lean_ctor_get(x_4, 1);
-lean_inc(x_9);
-lean_inc(x_3);
-lean_inc(x_2);
-x_21 = l_Lean_Parser_Term_simpleBinder___elambda__1(x_2, x_3, x_4);
-x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_1);
+x_19 = l_Lean_Parser_Term_simpleBinder___elambda__1(x_1, x_2);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
+{
+lean_dec(x_4);
+x_8 = x_19;
+goto block_18;
+}
+else
+{
+lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+x_21 = lean_ctor_get(x_20, 0);
+lean_inc(x_21);
+lean_dec(x_20);
+x_22 = lean_ctor_get(x_19, 1);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_dec(x_6);
-x_10 = x_21;
-goto block_20;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
+x_23 = lean_nat_dec_eq(x_22, x_7);
 lean_dec(x_22);
-x_24 = lean_ctor_get(x_21, 1);
-lean_inc(x_24);
-x_25 = lean_nat_dec_eq(x_24, x_9);
-lean_dec(x_24);
-if (x_25 == 0)
+if (x_23 == 0)
 {
-lean_dec(x_23);
-lean_dec(x_6);
-x_10 = x_21;
-goto block_20;
+lean_dec(x_21);
+lean_dec(x_4);
+x_8 = x_19;
+goto block_18;
 }
 else
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_inc(x_7);
+x_24 = l_Lean_Parser_ParserState_restore(x_19, x_6, x_7);
+lean_inc(x_1);
+x_25 = lean_apply_2(x_4, x_1, x_24);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_21, x_7);
+x_8 = x_26;
+goto block_18;
+}
+}
+block_18:
+{
+lean_object* x_9; 
+x_9 = lean_ctor_get(x_8, 3);
 lean_inc(x_9);
-x_26 = l_Lean_Parser_ParserState_restore(x_21, x_8, x_9);
-lean_inc(x_3);
-lean_inc(x_2);
-x_27 = lean_apply_3(x_6, x_2, x_3, x_26);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_23, x_9);
-x_10 = x_28;
-goto block_20;
-}
-}
-block_20:
+if (lean_obj_tag(x_9) == 0)
 {
-lean_object* x_11; 
-x_11 = lean_ctor_get(x_10, 3);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
+lean_object* x_10; uint8_t x_11; 
+lean_dec(x_6);
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+x_11 = lean_nat_dec_eq(x_7, x_10);
+lean_dec(x_10);
+lean_dec(x_7);
+if (x_11 == 0)
 {
-lean_object* x_12; uint8_t x_13; 
-lean_dec(x_8);
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_9, x_12);
-lean_dec(x_12);
-lean_dec(x_9);
-if (x_13 == 0)
-{
-x_4 = x_10;
+x_2 = x_8;
 goto _start;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; 
-lean_dec(x_3);
-lean_dec(x_2);
-x_15 = l_Lean_Parser_manyAux___main___closed__1;
-x_16 = l_Lean_Parser_ParserState_mkUnexpectedError(x_10, x_15);
-return x_16;
+lean_object* x_13; lean_object* x_14; 
+lean_dec(x_1);
+x_13 = l_Lean_Parser_manyAux___main___closed__1;
+x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
+return x_14;
 }
 }
 else
 {
-lean_object* x_17; uint8_t x_18; 
-lean_dec(x_11);
-lean_dec(x_3);
-lean_dec(x_2);
-x_17 = lean_ctor_get(x_10, 1);
-lean_inc(x_17);
-x_18 = lean_nat_dec_eq(x_9, x_17);
-lean_dec(x_17);
-if (x_18 == 0)
-{
+lean_object* x_15; uint8_t x_16; 
 lean_dec(x_9);
-lean_dec(x_8);
-return x_10;
+lean_dec(x_1);
+x_15 = lean_ctor_get(x_8, 1);
+lean_inc(x_15);
+x_16 = lean_nat_dec_eq(x_7, x_15);
+lean_dec(x_15);
+if (x_16 == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+return x_8;
 }
 else
 {
-lean_object* x_19; 
-x_19 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
-lean_dec(x_8);
-return x_19;
+lean_object* x_17; 
+x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+return x_17;
 }
 }
 }
@@ -19010,13 +18611,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_forall___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_forall___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_forall___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_forall___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_forall___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_forall___elambda__1___closed__5() {
@@ -19060,7 +18660,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_forall___elambda__1___closed__8;
-x_2 = l_Lean_Parser_unicodeSymbolFn___rarg___closed__1;
+x_2 = l_Lean_Parser_unicodeSymbolFn___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
@@ -19109,445 +18709,435 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_forall___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_forall___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_forall___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Term_forall___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
+lean_inc(x_1);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
 lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
-lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_54 = l_Lean_Parser_Term_forall___elambda__1___closed__6;
-x_55 = l_Lean_Parser_Term_forall___elambda__1___closed__7;
-x_56 = l_Lean_Parser_Term_forall___elambda__1___closed__12;
-lean_inc(x_2);
-x_57 = l_Lean_Parser_unicodeSymbolFnAux(x_54, x_55, x_56, x_2, x_16);
-x_58 = lean_ctor_get(x_57, 3);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_53 = l_Lean_Parser_Term_forall___elambda__1___closed__6;
+x_54 = l_Lean_Parser_Term_forall___elambda__1___closed__7;
+x_55 = l_Lean_Parser_Term_forall___elambda__1___closed__12;
+lean_inc(x_1);
+x_56 = l_Lean_Parser_unicodeSymbolFnAux(x_53, x_54, x_55, x_1, x_15);
+x_57 = lean_ctor_get(x_56, 3);
+lean_inc(x_57);
+if (lean_obj_tag(x_57) == 0)
+{
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_58 = lean_ctor_get(x_56, 0);
 lean_inc(x_58);
-if (lean_obj_tag(x_58) == 0)
-{
-lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_59 = lean_ctor_get(x_57, 0);
-lean_inc(x_59);
-x_60 = lean_array_get_size(x_59);
-lean_dec(x_59);
-x_61 = lean_ctor_get(x_57, 1);
-lean_inc(x_61);
-lean_inc(x_2);
-lean_inc(x_1);
-x_62 = l_Lean_Parser_Term_simpleBinder___elambda__1(x_1, x_2, x_57);
-x_63 = lean_ctor_get(x_62, 3);
-lean_inc(x_63);
-if (lean_obj_tag(x_63) == 0)
-{
-uint8_t x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-lean_dec(x_61);
-lean_dec(x_5);
-x_64 = 0;
-lean_inc(x_2);
-x_65 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_64, x_1, x_2, x_62);
-x_66 = l_Lean_nullKind;
-x_67 = l_Lean_Parser_ParserState_mkNode(x_65, x_66, x_60);
-x_68 = lean_ctor_get(x_67, 3);
-lean_inc(x_68);
-if (lean_obj_tag(x_68) == 0)
-{
-lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-x_69 = lean_ctor_get(x_67, 1);
-lean_inc(x_69);
-lean_inc(x_2);
-x_70 = l_Lean_Parser_tokenFn(x_2, x_67);
-x_71 = lean_ctor_get(x_70, 3);
-lean_inc(x_71);
-if (lean_obj_tag(x_71) == 0)
-{
-lean_object* x_72; lean_object* x_73; 
-x_72 = lean_ctor_get(x_70, 0);
-lean_inc(x_72);
-x_73 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_72);
-lean_dec(x_72);
-if (lean_obj_tag(x_73) == 2)
-{
-lean_object* x_74; lean_object* x_75; uint8_t x_76; 
-x_74 = lean_ctor_get(x_73, 1);
-lean_inc(x_74);
-lean_dec(x_73);
-x_75 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_76 = lean_string_dec_eq(x_74, x_75);
-lean_dec(x_74);
-if (x_76 == 0)
-{
-lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
-lean_dec(x_2);
-x_77 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
-x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_70, x_77, x_69);
-x_79 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_80 = l_Lean_Parser_ParserState_mkNode(x_78, x_79, x_18);
-x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_13, x_10);
-lean_dec(x_10);
-return x_81;
-}
-else
-{
-lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-lean_dec(x_69);
-x_82 = l_Lean_Parser_termParser___closed__2;
-x_83 = lean_unsigned_to_nat(0u);
-x_84 = l_Lean_Parser_categoryParserFn(x_82, x_83, x_2, x_70);
-x_85 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_86 = l_Lean_Parser_ParserState_mkNode(x_84, x_85, x_18);
-x_87 = l_Lean_Parser_mergeOrElseErrors(x_86, x_13, x_10);
-lean_dec(x_10);
-return x_87;
-}
-}
-else
-{
-lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-lean_dec(x_73);
-lean_dec(x_2);
-x_88 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
-x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_70, x_88, x_69);
-x_90 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_91 = l_Lean_Parser_ParserState_mkNode(x_89, x_90, x_18);
-x_92 = l_Lean_Parser_mergeOrElseErrors(x_91, x_13, x_10);
-lean_dec(x_10);
-return x_92;
-}
-}
-else
-{
-lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; 
-lean_dec(x_71);
-lean_dec(x_2);
-x_93 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
-x_94 = l_Lean_Parser_ParserState_mkErrorsAt(x_70, x_93, x_69);
-x_95 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_18);
-x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_13, x_10);
-lean_dec(x_10);
-return x_97;
-}
-}
-else
-{
-lean_object* x_98; lean_object* x_99; lean_object* x_100; 
-lean_dec(x_68);
-lean_dec(x_2);
-x_98 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_99 = l_Lean_Parser_ParserState_mkNode(x_67, x_98, x_18);
-x_100 = l_Lean_Parser_mergeOrElseErrors(x_99, x_13, x_10);
-lean_dec(x_10);
-return x_100;
-}
-}
-else
-{
-lean_object* x_101; lean_object* x_102; uint8_t x_103; 
-x_101 = lean_ctor_get(x_63, 0);
-lean_inc(x_101);
-lean_dec(x_63);
-x_102 = lean_ctor_get(x_62, 1);
-lean_inc(x_102);
-x_103 = lean_nat_dec_eq(x_102, x_61);
-lean_dec(x_102);
-if (x_103 == 0)
-{
-lean_object* x_104; lean_object* x_105; lean_object* x_106; 
-lean_dec(x_101);
-lean_dec(x_61);
-lean_dec(x_5);
-lean_dec(x_1);
-x_104 = l_Lean_nullKind;
-x_105 = l_Lean_Parser_ParserState_mkNode(x_62, x_104, x_60);
-x_106 = lean_ctor_get(x_105, 3);
-lean_inc(x_106);
-if (lean_obj_tag(x_106) == 0)
-{
-lean_object* x_107; lean_object* x_108; lean_object* x_109; 
-x_107 = lean_ctor_get(x_105, 1);
-lean_inc(x_107);
-lean_inc(x_2);
-x_108 = l_Lean_Parser_tokenFn(x_2, x_105);
-x_109 = lean_ctor_get(x_108, 3);
-lean_inc(x_109);
-if (lean_obj_tag(x_109) == 0)
-{
-lean_object* x_110; lean_object* x_111; 
-x_110 = lean_ctor_get(x_108, 0);
-lean_inc(x_110);
-x_111 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_110);
-lean_dec(x_110);
-if (lean_obj_tag(x_111) == 2)
-{
-lean_object* x_112; lean_object* x_113; uint8_t x_114; 
-x_112 = lean_ctor_get(x_111, 1);
-lean_inc(x_112);
-lean_dec(x_111);
-x_113 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_114 = lean_string_dec_eq(x_112, x_113);
-lean_dec(x_112);
-if (x_114 == 0)
-{
-lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; 
-lean_dec(x_2);
-x_115 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
-x_116 = l_Lean_Parser_ParserState_mkErrorsAt(x_108, x_115, x_107);
-x_117 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_118 = l_Lean_Parser_ParserState_mkNode(x_116, x_117, x_18);
-x_119 = l_Lean_Parser_mergeOrElseErrors(x_118, x_13, x_10);
-lean_dec(x_10);
-return x_119;
-}
-else
-{
-lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; 
-lean_dec(x_107);
-x_120 = l_Lean_Parser_termParser___closed__2;
-x_121 = lean_unsigned_to_nat(0u);
-x_122 = l_Lean_Parser_categoryParserFn(x_120, x_121, x_2, x_108);
-x_123 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_124 = l_Lean_Parser_ParserState_mkNode(x_122, x_123, x_18);
-x_125 = l_Lean_Parser_mergeOrElseErrors(x_124, x_13, x_10);
-lean_dec(x_10);
-return x_125;
-}
-}
-else
-{
-lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; 
-lean_dec(x_111);
-lean_dec(x_2);
-x_126 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
-x_127 = l_Lean_Parser_ParserState_mkErrorsAt(x_108, x_126, x_107);
-x_128 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_129 = l_Lean_Parser_ParserState_mkNode(x_127, x_128, x_18);
-x_130 = l_Lean_Parser_mergeOrElseErrors(x_129, x_13, x_10);
-lean_dec(x_10);
-return x_130;
-}
-}
-else
-{
-lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; 
-lean_dec(x_109);
-lean_dec(x_2);
-x_131 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
-x_132 = l_Lean_Parser_ParserState_mkErrorsAt(x_108, x_131, x_107);
-x_133 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_134 = l_Lean_Parser_ParserState_mkNode(x_132, x_133, x_18);
-x_135 = l_Lean_Parser_mergeOrElseErrors(x_134, x_13, x_10);
-lean_dec(x_10);
-return x_135;
-}
-}
-else
-{
-lean_object* x_136; lean_object* x_137; lean_object* x_138; 
-lean_dec(x_106);
-lean_dec(x_2);
-x_136 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_137 = l_Lean_Parser_ParserState_mkNode(x_105, x_136, x_18);
-x_138 = l_Lean_Parser_mergeOrElseErrors(x_137, x_13, x_10);
-lean_dec(x_10);
-return x_138;
-}
-}
-else
-{
-lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; 
-lean_inc(x_61);
-x_139 = l_Lean_Parser_ParserState_restore(x_62, x_60, x_61);
-lean_inc(x_2);
-lean_inc(x_1);
-x_140 = lean_apply_3(x_5, x_1, x_2, x_139);
-x_141 = l_Lean_Parser_mergeOrElseErrors(x_140, x_101, x_61);
-lean_dec(x_61);
-x_142 = lean_ctor_get(x_141, 3);
-lean_inc(x_142);
-if (lean_obj_tag(x_142) == 0)
-{
-uint8_t x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; 
-x_143 = 0;
-lean_inc(x_2);
-x_144 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_143, x_1, x_2, x_141);
-x_145 = l_Lean_nullKind;
-x_146 = l_Lean_Parser_ParserState_mkNode(x_144, x_145, x_60);
-x_19 = x_146;
-goto block_53;
-}
-else
-{
-lean_object* x_147; lean_object* x_148; 
-lean_dec(x_142);
-lean_dec(x_1);
-x_147 = l_Lean_nullKind;
-x_148 = l_Lean_Parser_ParserState_mkNode(x_141, x_147, x_60);
-x_19 = x_148;
-goto block_53;
-}
-}
-}
-}
-else
-{
-lean_object* x_149; lean_object* x_150; lean_object* x_151; 
+x_59 = lean_array_get_size(x_58);
 lean_dec(x_58);
-lean_dec(x_5);
-lean_dec(x_2);
+x_60 = lean_ctor_get(x_56, 1);
+lean_inc(x_60);
+lean_inc(x_1);
+x_61 = l_Lean_Parser_Term_simpleBinder___elambda__1(x_1, x_56);
+x_62 = lean_ctor_get(x_61, 3);
+lean_inc(x_62);
+if (lean_obj_tag(x_62) == 0)
+{
+lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; 
+lean_dec(x_60);
+lean_dec(x_4);
+lean_inc(x_1);
+x_63 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_1, x_61);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_59);
+x_66 = lean_ctor_get(x_65, 3);
+lean_inc(x_66);
+if (lean_obj_tag(x_66) == 0)
+{
+lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+x_67 = lean_ctor_get(x_65, 1);
+lean_inc(x_67);
+lean_inc(x_1);
+x_68 = l_Lean_Parser_tokenFn(x_1, x_65);
+x_69 = lean_ctor_get(x_68, 3);
+lean_inc(x_69);
+if (lean_obj_tag(x_69) == 0)
+{
+lean_object* x_70; lean_object* x_71; 
+x_70 = lean_ctor_get(x_68, 0);
+lean_inc(x_70);
+x_71 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_70);
+lean_dec(x_70);
+if (lean_obj_tag(x_71) == 2)
+{
+lean_object* x_72; lean_object* x_73; uint8_t x_74; 
+x_72 = lean_ctor_get(x_71, 1);
+lean_inc(x_72);
+lean_dec(x_71);
+x_73 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_74 = lean_string_dec_eq(x_72, x_73);
+lean_dec(x_72);
+if (x_74 == 0)
+{
+lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
 lean_dec(x_1);
-x_149 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_150 = l_Lean_Parser_ParserState_mkNode(x_57, x_149, x_18);
-x_151 = l_Lean_Parser_mergeOrElseErrors(x_150, x_13, x_10);
-lean_dec(x_10);
-return x_151;
+x_75 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
+x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_75, x_67);
+x_77 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_78 = l_Lean_Parser_ParserState_mkNode(x_76, x_77, x_17);
+x_79 = l_Lean_Parser_mergeOrElseErrors(x_78, x_12, x_9);
+lean_dec(x_9);
+return x_79;
 }
-block_53:
+else
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+lean_dec(x_67);
+x_80 = l_Lean_Parser_termParser___closed__2;
+x_81 = lean_unsigned_to_nat(0u);
+x_82 = l_Lean_Parser_categoryParser___elambda__1(x_80, x_81, x_1, x_68);
+x_83 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_84 = l_Lean_Parser_ParserState_mkNode(x_82, x_83, x_17);
+x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_12, x_9);
+lean_dec(x_9);
+return x_85;
+}
+}
+else
+{
+lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
+lean_dec(x_71);
+lean_dec(x_1);
+x_86 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
+x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_86, x_67);
+x_88 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_17);
+x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_12, x_9);
+lean_dec(x_9);
+return x_90;
+}
+}
+else
+{
+lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+lean_dec(x_69);
+lean_dec(x_1);
+x_91 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
+x_92 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_91, x_67);
+x_93 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_94 = l_Lean_Parser_ParserState_mkNode(x_92, x_93, x_17);
+x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_12, x_9);
+lean_dec(x_9);
+return x_95;
+}
+}
+else
+{
+lean_object* x_96; lean_object* x_97; lean_object* x_98; 
+lean_dec(x_66);
+lean_dec(x_1);
+x_96 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_97 = l_Lean_Parser_ParserState_mkNode(x_65, x_96, x_17);
+x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_12, x_9);
+lean_dec(x_9);
+return x_98;
+}
+}
+else
+{
+lean_object* x_99; lean_object* x_100; uint8_t x_101; 
+x_99 = lean_ctor_get(x_62, 0);
+lean_inc(x_99);
+lean_dec(x_62);
+x_100 = lean_ctor_get(x_61, 1);
+lean_inc(x_100);
+x_101 = lean_nat_dec_eq(x_100, x_60);
+lean_dec(x_100);
+if (x_101 == 0)
+{
+lean_object* x_102; lean_object* x_103; lean_object* x_104; 
+lean_dec(x_99);
+lean_dec(x_60);
+lean_dec(x_4);
+x_102 = l_Lean_nullKind;
+x_103 = l_Lean_Parser_ParserState_mkNode(x_61, x_102, x_59);
+x_104 = lean_ctor_get(x_103, 3);
+lean_inc(x_104);
+if (lean_obj_tag(x_104) == 0)
+{
+lean_object* x_105; lean_object* x_106; lean_object* x_107; 
+x_105 = lean_ctor_get(x_103, 1);
+lean_inc(x_105);
+lean_inc(x_1);
+x_106 = l_Lean_Parser_tokenFn(x_1, x_103);
+x_107 = lean_ctor_get(x_106, 3);
+lean_inc(x_107);
+if (lean_obj_tag(x_107) == 0)
+{
+lean_object* x_108; lean_object* x_109; 
+x_108 = lean_ctor_get(x_106, 0);
+lean_inc(x_108);
+x_109 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_108);
+lean_dec(x_108);
+if (lean_obj_tag(x_109) == 2)
+{
+lean_object* x_110; lean_object* x_111; uint8_t x_112; 
+x_110 = lean_ctor_get(x_109, 1);
+lean_inc(x_110);
+lean_dec(x_109);
+x_111 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_112 = lean_string_dec_eq(x_110, x_111);
+lean_dec(x_110);
+if (x_112 == 0)
+{
+lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; 
+lean_dec(x_1);
+x_113 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
+x_114 = l_Lean_Parser_ParserState_mkErrorsAt(x_106, x_113, x_105);
+x_115 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_116 = l_Lean_Parser_ParserState_mkNode(x_114, x_115, x_17);
+x_117 = l_Lean_Parser_mergeOrElseErrors(x_116, x_12, x_9);
+lean_dec(x_9);
+return x_117;
+}
+else
+{
+lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; 
+lean_dec(x_105);
+x_118 = l_Lean_Parser_termParser___closed__2;
+x_119 = lean_unsigned_to_nat(0u);
+x_120 = l_Lean_Parser_categoryParser___elambda__1(x_118, x_119, x_1, x_106);
+x_121 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_122 = l_Lean_Parser_ParserState_mkNode(x_120, x_121, x_17);
+x_123 = l_Lean_Parser_mergeOrElseErrors(x_122, x_12, x_9);
+lean_dec(x_9);
+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_dec(x_109);
+lean_dec(x_1);
+x_124 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
+x_125 = l_Lean_Parser_ParserState_mkErrorsAt(x_106, x_124, x_105);
+x_126 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_127 = l_Lean_Parser_ParserState_mkNode(x_125, x_126, x_17);
+x_128 = l_Lean_Parser_mergeOrElseErrors(x_127, x_12, x_9);
+lean_dec(x_9);
+return x_128;
+}
+}
+else
+{
+lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
+lean_dec(x_107);
+lean_dec(x_1);
+x_129 = l_Lean_Parser_Term_forall___elambda__1___closed__13;
+x_130 = l_Lean_Parser_ParserState_mkErrorsAt(x_106, x_129, x_105);
+x_131 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_132 = l_Lean_Parser_ParserState_mkNode(x_130, x_131, x_17);
+x_133 = l_Lean_Parser_mergeOrElseErrors(x_132, x_12, x_9);
+lean_dec(x_9);
+return x_133;
+}
+}
+else
+{
+lean_object* x_134; lean_object* x_135; lean_object* x_136; 
+lean_dec(x_104);
+lean_dec(x_1);
+x_134 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_135 = l_Lean_Parser_ParserState_mkNode(x_103, x_134, x_17);
+x_136 = l_Lean_Parser_mergeOrElseErrors(x_135, x_12, x_9);
+lean_dec(x_9);
+return x_136;
+}
+}
+else
+{
+lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
+lean_inc(x_60);
+x_137 = l_Lean_Parser_ParserState_restore(x_61, x_59, x_60);
+lean_inc(x_1);
+x_138 = lean_apply_2(x_4, x_1, x_137);
+x_139 = l_Lean_Parser_mergeOrElseErrors(x_138, x_99, x_60);
+lean_dec(x_60);
+x_140 = lean_ctor_get(x_139, 3);
+lean_inc(x_140);
+if (lean_obj_tag(x_140) == 0)
+{
+lean_object* x_141; lean_object* x_142; lean_object* x_143; 
+lean_inc(x_1);
+x_141 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_1, x_139);
+x_142 = l_Lean_nullKind;
+x_143 = l_Lean_Parser_ParserState_mkNode(x_141, x_142, x_59);
+x_18 = x_143;
+goto block_52;
+}
+else
+{
+lean_object* x_144; lean_object* x_145; 
+lean_dec(x_140);
+x_144 = l_Lean_nullKind;
+x_145 = l_Lean_Parser_ParserState_mkNode(x_139, x_144, x_59);
+x_18 = x_145;
+goto block_52;
+}
+}
+}
+}
+else
+{
+lean_object* x_146; lean_object* x_147; lean_object* x_148; 
+lean_dec(x_57);
+lean_dec(x_4);
+lean_dec(x_1);
+x_146 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_147 = l_Lean_Parser_ParserState_mkNode(x_56, x_146, x_17);
+x_148 = l_Lean_Parser_mergeOrElseErrors(x_147, x_12, x_9);
+lean_dec(x_9);
+return x_148;
+}
+block_52:
+{
+lean_object* x_19; 
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+lean_inc(x_1);
+x_21 = l_Lean_Parser_tokenFn(x_1, x_18);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_21 = lean_ctor_get(x_19, 1);
-lean_inc(x_21);
-lean_inc(x_2);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_23 = lean_ctor_get(x_22, 3);
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_21, 0);
 lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
-{
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-lean_dec(x_2);
-x_29 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
-x_31 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_18);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_13, x_10);
-lean_dec(x_10);
-return x_33;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_21);
-x_34 = l_Lean_Parser_termParser___closed__2;
-x_35 = lean_unsigned_to_nat(0u);
-x_36 = l_Lean_Parser_categoryParserFn(x_34, x_35, x_2, x_22);
-x_37 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_18);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_13, x_10);
-lean_dec(x_10);
-return x_39;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-lean_dec(x_25);
-lean_dec(x_2);
-x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_40, x_21);
-x_42 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_18);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_13, x_10);
-lean_dec(x_10);
-return x_44;
-}
-}
-else
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_24 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_23);
 lean_dec(x_23);
-lean_dec(x_2);
-x_45 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
-x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_45, x_21);
-x_47 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_18);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_13, x_10);
-lean_dec(x_10);
-return x_49;
+if (lean_obj_tag(x_24) == 2)
+{
+lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_25 = lean_ctor_get(x_24, 1);
+lean_inc(x_25);
+lean_dec(x_24);
+x_26 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1;
+x_27 = lean_string_dec_eq(x_25, x_26);
+lean_dec(x_25);
+if (x_27 == 0)
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+lean_dec(x_1);
+x_28 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20);
+x_30 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_17);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_12, x_9);
+lean_dec(x_9);
+return x_32;
+}
+else
+{
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_20);
+x_33 = l_Lean_Parser_termParser___closed__2;
+x_34 = lean_unsigned_to_nat(0u);
+x_35 = l_Lean_Parser_categoryParser___elambda__1(x_33, x_34, x_1, x_21);
+x_36 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_17);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_12, x_9);
+lean_dec(x_9);
+return x_38;
 }
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_50 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_19, x_50, x_18);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_13, x_10);
-lean_dec(x_10);
-return x_52;
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_24);
+lean_dec(x_1);
+x_39 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_39, x_20);
+x_41 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_17);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_12, x_9);
+lean_dec(x_9);
+return x_43;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_22);
+lean_dec(x_1);
+x_44 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4;
+x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_44, x_20);
+x_46 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_17);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_12, x_9);
+lean_dec(x_9);
+return x_48;
+}
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_49 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_18, x_49, x_17);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_12, x_9);
+lean_dec(x_9);
+return x_51;
 }
 }
 }
@@ -19583,7 +19173,7 @@ lean_object* _init_l_Lean_Parser_Term_forall___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_explicitUniv___closed__2;
@@ -19637,7 +19227,7 @@ lean_object* _init_l_Lean_Parser_Term_forall___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_forall___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_forall___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -19661,23 +19251,13 @@ x_1 = l_Lean_Parser_Term_forall___closed__9;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-return x_6;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Term_forall(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_forall___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_forall;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -19705,7 +19285,7 @@ lean_object* _init_l_Lean_Parser_Term_matchAlt___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_explicitUniv___closed__2;
@@ -19716,24 +19296,33 @@ return x_4;
 lean_object* _init_l_Lean_Parser_Term_matchAlt___closed__4() {
 _start:
 {
-uint8_t x_1; uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_1 = 0;
-x_2 = 0;
-x_3 = lean_box(x_1);
-x_4 = lean_box(x_2);
-x_5 = lean_box(x_2);
-x_6 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1___boxed), 6, 3);
-lean_closure_set(x_6, 0, x_3);
-lean_closure_set(x_6, 1, x_4);
-lean_closure_set(x_6, 2, x_5);
-return x_6;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_termParser___closed__2;
+x_2 = lean_unsigned_to_nat(0u);
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 2);
+lean_closure_set(x_3, 0, x_1);
+lean_closure_set(x_3, 1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_matchAlt___closed__5() {
 _start:
 {
+uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = 0;
+x_2 = lean_box(x_1);
+x_3 = lean_box(x_1);
+x_4 = lean_alloc_closure((void*)(l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1___boxed), 4, 2);
+lean_closure_set(x_4, 0, x_2);
+lean_closure_set(x_4, 1, x_3);
+return x_4;
+}
+}
+lean_object* _init_l_Lean_Parser_Term_matchAlt___closed__6() {
+_start:
+{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_darrow;
@@ -19743,25 +19332,15 @@ x_5 = l_Lean_Parser_andthenInfo(x_4, x_2);
 return x_5;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_matchAlt___closed__6() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_darrow___closed__2;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__4;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_3, 0, x_1);
-lean_closure_set(x_3, 1, x_2);
-return x_3;
-}
-}
 lean_object* _init_l_Lean_Parser_Term_matchAlt___closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_matchAlt___closed__3;
-x_2 = l_Lean_Parser_Term_matchAlt___closed__5;
-x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+x_1 = l_Lean_Parser_darrow___closed__2;
+x_2 = l_Lean_Parser_Term_matchAlt___closed__4;
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_3, 0, x_1);
+lean_closure_set(x_3, 1, x_2);
 return x_3;
 }
 }
@@ -19769,11 +19348,9 @@ lean_object* _init_l_Lean_Parser_Term_matchAlt___closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_matchAlt___closed__4;
+x_1 = l_Lean_Parser_Term_matchAlt___closed__3;
 x_2 = l_Lean_Parser_Term_matchAlt___closed__6;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
-lean_closure_set(x_3, 0, x_1);
-lean_closure_set(x_3, 1, x_2);
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
 }
@@ -19781,31 +19358,42 @@ lean_object* _init_l_Lean_Parser_Term_matchAlt___closed__9() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_matchAlt___closed__7;
-x_2 = l_Lean_Parser_Term_matchAlt___closed__8;
-x_3 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_3, 0, x_1);
-lean_ctor_set(x_3, 1, x_2);
+x_1 = l_Lean_Parser_Term_matchAlt___closed__5;
+x_2 = l_Lean_Parser_Term_matchAlt___closed__7;
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
+lean_closure_set(x_3, 0, x_1);
+lean_closure_set(x_3, 1, x_2);
 return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_matchAlt___closed__10() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_matchAlt___closed__1;
-x_3 = l_Lean_Parser_Term_matchAlt___closed__2;
-x_4 = l_Lean_Parser_Term_matchAlt___closed__9;
-x_5 = l_Lean_Parser_nodeWithAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_matchAlt___closed__8;
+x_2 = l_Lean_Parser_Term_matchAlt___closed__9;
+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_matchAlt___closed__11() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_matchAlt___closed__1;
+x_2 = l_Lean_Parser_Term_matchAlt___closed__2;
+x_3 = l_Lean_Parser_Term_matchAlt___closed__10;
+x_4 = l_Lean_Parser_nodeWithAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_matchAlt() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Term_matchAlt___closed__10;
+x_1 = l_Lean_Parser_Term_matchAlt___closed__11;
 return x_1;
 }
 }
@@ -19866,2549 +19454,2591 @@ x_1 = lean_mk_string("alternatives must be indented");
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
-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; 
-x_10 = l_Lean_Parser_Term_matchAlt;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
+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; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_9, 2);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = l_Lean_FileMap_toPosition(x_10, x_11);
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
 lean_dec(x_12);
-x_14 = lean_ctor_get(x_9, 1);
-lean_inc(x_14);
-lean_inc(x_8);
-lean_inc(x_7);
-x_15 = lean_apply_3(x_11, x_7, x_8, x_9);
-x_16 = lean_ctor_get(x_15, 3);
+x_14 = l_Lean_Parser_Term_matchAlt;
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_8, 0);
 lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_34; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_17 = lean_ctor_get(x_15, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_51 = lean_ctor_get(x_8, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_51, 2);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_FileMap_toPosition(x_52, x_19);
-lean_dec(x_52);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-lean_dec(x_53);
-x_55 = lean_nat_dec_le(x_1, x_54);
-lean_dec(x_54);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
-x_57 = l_Lean_Parser_ParserState_mkError(x_15, x_56);
-x_34 = x_57;
-goto block_50;
-}
-else
-{
-x_34 = x_15;
-goto block_50;
-}
-block_33:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_dec(x_19);
-lean_dec(x_18);
-{
-uint8_t _tmp_5 = x_3;
-lean_object* _tmp_8 = x_20;
-x_6 = _tmp_5;
-x_9 = _tmp_8;
-}
-goto _start;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-lean_dec(x_21);
-lean_dec(x_8);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19);
-lean_dec(x_18);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_4);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_4);
-return x_30;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_4);
-return x_32;
-}
-else
-{
-lean_dec(x_4);
-return x_23;
-}
-}
-}
-}
-block_50:
-{
-lean_object* x_35; 
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_inc(x_8);
-x_37 = l_Lean_Parser_tokenFn(x_8, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36);
-x_20 = x_45;
-goto block_33;
-}
-else
-{
-lean_dec(x_36);
-x_20 = x_37;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36);
-x_20 = x_47;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_38);
-x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36);
-x_20 = x_49;
-goto block_33;
-}
-}
-else
-{
-lean_dec(x_35);
-x_20 = x_34;
-goto block_33;
-}
-}
-}
-else
-{
+x_17 = lean_array_get_size(x_16);
 lean_dec(x_16);
-lean_dec(x_8);
-lean_dec(x_7);
-if (x_6 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_58 = lean_box(0);
-x_59 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_58);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_4);
-return x_61;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_62 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_array_get_size(x_63);
-lean_dec(x_63);
-x_65 = lean_nat_sub(x_64, x_4);
-lean_dec(x_64);
-x_66 = lean_unsigned_to_nat(2u);
-x_67 = lean_nat_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_62, x_68, x_4);
-return x_69;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_nullKind;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_62, x_70, x_4);
-return x_71;
-}
-else
-{
-lean_object* x_72; 
-lean_dec(x_4);
-x_72 = l_Lean_Parser_ParserState_popSyntax(x_62);
-return x_72;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1(lean_object* x_1, uint8_t x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2(x_1, x_2, x_3, x_9, x_4, x_10, x_5, x_6, x_7);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
-_start:
-{
-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; 
-x_10 = l_Lean_Parser_Term_matchAlt;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_9, 1);
-lean_inc(x_14);
-lean_inc(x_8);
+x_18 = lean_ctor_get(x_8, 1);
+lean_inc(x_18);
 lean_inc(x_7);
-x_15 = lean_apply_3(x_11, x_7, x_8, x_9);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
+x_19 = lean_apply_2(x_15, x_7, x_8);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_34; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_17 = lean_ctor_get(x_15, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_38; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+lean_dec(x_18);
 lean_dec(x_17);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_51 = lean_ctor_get(x_8, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_51, 2);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_FileMap_toPosition(x_52, x_19);
-lean_dec(x_52);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-lean_dec(x_53);
-x_55 = lean_nat_dec_le(x_1, x_54);
-lean_dec(x_54);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
-x_57 = l_Lean_Parser_ParserState_mkError(x_15, x_56);
-x_34 = x_57;
-goto block_50;
-}
-else
-{
-x_34 = x_15;
-goto block_50;
-}
-block_33:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
+x_21 = lean_ctor_get(x_19, 0);
 lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_dec(x_19);
-lean_dec(x_18);
-{
-uint8_t _tmp_5 = x_3;
-lean_object* _tmp_8 = x_20;
-x_6 = _tmp_5;
-x_9 = _tmp_8;
-}
-goto _start;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_22 = lean_array_get_size(x_21);
 lean_dec(x_21);
-lean_dec(x_8);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19);
-lean_dec(x_18);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_4);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_4);
-return x_30;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_4);
-return x_32;
-}
-else
-{
-lean_dec(x_4);
-return x_23;
-}
-}
-}
-}
-block_50:
-{
-lean_object* x_35; 
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_inc(x_8);
-x_37 = l_Lean_Parser_tokenFn(x_8, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36);
-x_20 = x_45;
-goto block_33;
-}
-else
-{
-lean_dec(x_36);
-x_20 = x_37;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36);
-x_20 = x_47;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_38);
-x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36);
-x_20 = x_49;
-goto block_33;
-}
-}
-else
-{
-lean_dec(x_35);
-x_20 = x_34;
-goto block_33;
-}
-}
-}
-else
-{
-lean_dec(x_16);
-lean_dec(x_8);
-lean_dec(x_7);
-if (x_6 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_58 = lean_box(0);
-x_59 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_58);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_4);
-return x_61;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_62 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_array_get_size(x_63);
-lean_dec(x_63);
-x_65 = lean_nat_sub(x_64, x_4);
-lean_dec(x_64);
-x_66 = lean_unsigned_to_nat(2u);
-x_67 = lean_nat_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_62, x_68, x_4);
-return x_69;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_nullKind;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_62, x_70, x_4);
-return x_71;
-}
-else
-{
-lean_object* x_72; 
-lean_dec(x_4);
-x_72 = l_Lean_Parser_ParserState_popSyntax(x_62);
-return x_72;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3(lean_object* x_1, uint8_t x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4(x_1, x_2, x_3, x_9, x_4, x_10, x_5, x_6, x_7);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
-_start:
-{
-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; 
-x_10 = l_Lean_Parser_Term_matchAlt;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_9, 1);
-lean_inc(x_14);
-lean_inc(x_8);
-lean_inc(x_7);
-x_15 = lean_apply_3(x_11, x_7, x_8, x_9);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_34; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_17 = lean_ctor_get(x_15, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_51 = lean_ctor_get(x_8, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_51, 2);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_FileMap_toPosition(x_52, x_19);
-lean_dec(x_52);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-lean_dec(x_53);
-x_55 = lean_nat_dec_le(x_1, x_54);
-lean_dec(x_54);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
-x_57 = l_Lean_Parser_ParserState_mkError(x_15, x_56);
-x_34 = x_57;
-goto block_50;
-}
-else
-{
-x_34 = x_15;
-goto block_50;
-}
-block_33:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_dec(x_19);
-lean_dec(x_18);
-{
-uint8_t _tmp_5 = x_3;
-lean_object* _tmp_8 = x_20;
-x_6 = _tmp_5;
-x_9 = _tmp_8;
-}
-goto _start;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-lean_dec(x_21);
-lean_dec(x_8);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19);
-lean_dec(x_18);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_4);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_4);
-return x_30;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_4);
-return x_32;
-}
-else
-{
-lean_dec(x_4);
-return x_23;
-}
-}
-}
-}
-block_50:
-{
-lean_object* x_35; 
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_inc(x_8);
-x_37 = l_Lean_Parser_tokenFn(x_8, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36);
-x_20 = x_45;
-goto block_33;
-}
-else
-{
-lean_dec(x_36);
-x_20 = x_37;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36);
-x_20 = x_47;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_38);
-x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36);
-x_20 = x_49;
-goto block_33;
-}
-}
-else
-{
-lean_dec(x_35);
-x_20 = x_34;
-goto block_33;
-}
-}
-}
-else
-{
-lean_dec(x_16);
-lean_dec(x_8);
-lean_dec(x_7);
-if (x_6 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_58 = lean_box(0);
-x_59 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_58);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_4);
-return x_61;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_62 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_array_get_size(x_63);
-lean_dec(x_63);
-x_65 = lean_nat_sub(x_64, x_4);
-lean_dec(x_64);
-x_66 = lean_unsigned_to_nat(2u);
-x_67 = lean_nat_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_62, x_68, x_4);
-return x_69;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_nullKind;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_62, x_70, x_4);
-return x_71;
-}
-else
-{
-lean_object* x_72; 
-lean_dec(x_4);
-x_72 = l_Lean_Parser_ParserState_popSyntax(x_62);
-return x_72;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5(lean_object* x_1, uint8_t x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6(x_1, x_2, x_3, x_9, x_4, x_10, x_5, x_6, x_7);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
-_start:
-{
-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; 
-x_10 = l_Lean_Parser_Term_matchAlt;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_9, 1);
-lean_inc(x_14);
-lean_inc(x_8);
-lean_inc(x_7);
-x_15 = lean_apply_3(x_11, x_7, x_8, x_9);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_34; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_17 = lean_ctor_get(x_15, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_51 = lean_ctor_get(x_8, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_51, 2);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_FileMap_toPosition(x_52, x_19);
-lean_dec(x_52);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-lean_dec(x_53);
-x_55 = lean_nat_dec_le(x_1, x_54);
-lean_dec(x_54);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
-x_57 = l_Lean_Parser_ParserState_mkError(x_15, x_56);
-x_34 = x_57;
-goto block_50;
-}
-else
-{
-x_34 = x_15;
-goto block_50;
-}
-block_33:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_dec(x_19);
-lean_dec(x_18);
-{
-uint8_t _tmp_5 = x_3;
-lean_object* _tmp_8 = x_20;
-x_6 = _tmp_5;
-x_9 = _tmp_8;
-}
-goto _start;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-lean_dec(x_21);
-lean_dec(x_8);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19);
-lean_dec(x_18);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_4);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_4);
-return x_30;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_4);
-return x_32;
-}
-else
-{
-lean_dec(x_4);
-return x_23;
-}
-}
-}
-}
-block_50:
-{
-lean_object* x_35; 
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_inc(x_8);
-x_37 = l_Lean_Parser_tokenFn(x_8, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36);
-x_20 = x_45;
-goto block_33;
-}
-else
-{
-lean_dec(x_36);
-x_20 = x_37;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36);
-x_20 = x_47;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_38);
-x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36);
-x_20 = x_49;
-goto block_33;
-}
-}
-else
-{
-lean_dec(x_35);
-x_20 = x_34;
-goto block_33;
-}
-}
-}
-else
-{
-lean_dec(x_16);
-lean_dec(x_8);
-lean_dec(x_7);
-if (x_6 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_58 = lean_box(0);
-x_59 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_58);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_4);
-return x_61;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_62 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_array_get_size(x_63);
-lean_dec(x_63);
-x_65 = lean_nat_sub(x_64, x_4);
-lean_dec(x_64);
-x_66 = lean_unsigned_to_nat(2u);
-x_67 = lean_nat_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_62, x_68, x_4);
-return x_69;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_nullKind;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_62, x_70, x_4);
-return x_71;
-}
-else
-{
-lean_object* x_72; 
-lean_dec(x_4);
-x_72 = l_Lean_Parser_ParserState_popSyntax(x_62);
-return x_72;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(lean_object* x_1, uint8_t x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8(x_1, x_2, x_3, x_9, x_4, x_10, x_5, x_6, x_7);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
-_start:
-{
-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; 
-x_10 = l_Lean_Parser_Term_matchAlt;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_9, 1);
-lean_inc(x_14);
-lean_inc(x_8);
-lean_inc(x_7);
-x_15 = lean_apply_3(x_11, x_7, x_8, x_9);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_34; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_17 = lean_ctor_get(x_15, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_51 = lean_ctor_get(x_8, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_51, 2);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_FileMap_toPosition(x_52, x_19);
-lean_dec(x_52);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-lean_dec(x_53);
-x_55 = lean_nat_dec_le(x_1, x_54);
-lean_dec(x_54);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
-x_57 = l_Lean_Parser_ParserState_mkError(x_15, x_56);
-x_34 = x_57;
-goto block_50;
-}
-else
-{
-x_34 = x_15;
-goto block_50;
-}
-block_33:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_dec(x_19);
-lean_dec(x_18);
-{
-uint8_t _tmp_5 = x_3;
-lean_object* _tmp_8 = x_20;
-x_6 = _tmp_5;
-x_9 = _tmp_8;
-}
-goto _start;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-lean_dec(x_21);
-lean_dec(x_8);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19);
-lean_dec(x_18);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_4);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_4);
-return x_30;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_4);
-return x_32;
-}
-else
-{
-lean_dec(x_4);
-return x_23;
-}
-}
-}
-}
-block_50:
-{
-lean_object* x_35; 
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_inc(x_8);
-x_37 = l_Lean_Parser_tokenFn(x_8, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36);
-x_20 = x_45;
-goto block_33;
-}
-else
-{
-lean_dec(x_36);
-x_20 = x_37;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36);
-x_20 = x_47;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_38);
-x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36);
-x_20 = x_49;
-goto block_33;
-}
-}
-else
-{
-lean_dec(x_35);
-x_20 = x_34;
-goto block_33;
-}
-}
-}
-else
-{
-lean_dec(x_16);
-lean_dec(x_8);
-lean_dec(x_7);
-if (x_6 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_58 = lean_box(0);
-x_59 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_58);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_4);
-return x_61;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_62 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_array_get_size(x_63);
-lean_dec(x_63);
-x_65 = lean_nat_sub(x_64, x_4);
-lean_dec(x_64);
-x_66 = lean_unsigned_to_nat(2u);
-x_67 = lean_nat_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_62, x_68, x_4);
-return x_69;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_nullKind;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_62, x_70, x_4);
-return x_71;
-}
-else
-{
-lean_object* x_72; 
-lean_dec(x_4);
-x_72 = l_Lean_Parser_ParserState_popSyntax(x_62);
-return x_72;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9(lean_object* x_1, uint8_t x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10(x_1, x_2, x_3, x_9, x_4, x_10, x_5, x_6, x_7);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
-_start:
-{
-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; 
-x_10 = l_Lean_Parser_Term_matchAlt;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_9, 1);
-lean_inc(x_14);
-lean_inc(x_8);
-lean_inc(x_7);
-x_15 = lean_apply_3(x_11, x_7, x_8, x_9);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_34; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_17 = lean_ctor_get(x_15, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_51 = lean_ctor_get(x_8, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_51, 2);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_FileMap_toPosition(x_52, x_19);
-lean_dec(x_52);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-lean_dec(x_53);
-x_55 = lean_nat_dec_le(x_1, x_54);
-lean_dec(x_54);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
-x_57 = l_Lean_Parser_ParserState_mkError(x_15, x_56);
-x_34 = x_57;
-goto block_50;
-}
-else
-{
-x_34 = x_15;
-goto block_50;
-}
-block_33:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_dec(x_19);
-lean_dec(x_18);
-{
-uint8_t _tmp_5 = x_3;
-lean_object* _tmp_8 = x_20;
-x_6 = _tmp_5;
-x_9 = _tmp_8;
-}
-goto _start;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-lean_dec(x_21);
-lean_dec(x_8);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19);
-lean_dec(x_18);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_4);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_4);
-return x_30;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_4);
-return x_32;
-}
-else
-{
-lean_dec(x_4);
-return x_23;
-}
-}
-}
-}
-block_50:
-{
-lean_object* x_35; 
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_inc(x_8);
-x_37 = l_Lean_Parser_tokenFn(x_8, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36);
-x_20 = x_45;
-goto block_33;
-}
-else
-{
-lean_dec(x_36);
-x_20 = x_37;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36);
-x_20 = x_47;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_38);
-x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36);
-x_20 = x_49;
-goto block_33;
-}
-}
-else
-{
-lean_dec(x_35);
-x_20 = x_34;
-goto block_33;
-}
-}
-}
-else
-{
-lean_dec(x_16);
-lean_dec(x_8);
-lean_dec(x_7);
-if (x_6 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_58 = lean_box(0);
-x_59 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_58);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_4);
-return x_61;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_62 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_array_get_size(x_63);
-lean_dec(x_63);
-x_65 = lean_nat_sub(x_64, x_4);
-lean_dec(x_64);
-x_66 = lean_unsigned_to_nat(2u);
-x_67 = lean_nat_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_62, x_68, x_4);
-return x_69;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_nullKind;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_62, x_70, x_4);
-return x_71;
-}
-else
-{
-lean_object* x_72; 
-lean_dec(x_4);
-x_72 = l_Lean_Parser_ParserState_popSyntax(x_62);
-return x_72;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11(lean_object* x_1, uint8_t x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12(x_1, x_2, x_3, x_9, x_4, x_10, x_5, x_6, x_7);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
-_start:
-{
-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; 
-x_10 = l_Lean_Parser_Term_matchAlt;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_9, 1);
-lean_inc(x_14);
-lean_inc(x_8);
-lean_inc(x_7);
-x_15 = lean_apply_3(x_11, x_7, x_8, x_9);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_34; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_17 = lean_ctor_get(x_15, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_51 = lean_ctor_get(x_8, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_51, 2);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_FileMap_toPosition(x_52, x_19);
-lean_dec(x_52);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-lean_dec(x_53);
-x_55 = lean_nat_dec_le(x_1, x_54);
-lean_dec(x_54);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
-x_57 = l_Lean_Parser_ParserState_mkError(x_15, x_56);
-x_34 = x_57;
-goto block_50;
-}
-else
-{
-x_34 = x_15;
-goto block_50;
-}
-block_33:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_dec(x_19);
-lean_dec(x_18);
-{
-uint8_t _tmp_5 = x_3;
-lean_object* _tmp_8 = x_20;
-x_6 = _tmp_5;
-x_9 = _tmp_8;
-}
-goto _start;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-lean_dec(x_21);
-lean_dec(x_8);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19);
-lean_dec(x_18);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_4);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_4);
-return x_30;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_4);
-return x_32;
-}
-else
-{
-lean_dec(x_4);
-return x_23;
-}
-}
-}
-}
-block_50:
-{
-lean_object* x_35; 
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_inc(x_8);
-x_37 = l_Lean_Parser_tokenFn(x_8, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36);
-x_20 = x_45;
-goto block_33;
-}
-else
-{
-lean_dec(x_36);
-x_20 = x_37;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36);
-x_20 = x_47;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_38);
-x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36);
-x_20 = x_49;
-goto block_33;
-}
-}
-else
-{
-lean_dec(x_35);
-x_20 = x_34;
-goto block_33;
-}
-}
-}
-else
-{
-lean_dec(x_16);
-lean_dec(x_8);
-lean_dec(x_7);
-if (x_6 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_58 = lean_box(0);
-x_59 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_58);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_4);
-return x_61;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_62 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_array_get_size(x_63);
-lean_dec(x_63);
-x_65 = lean_nat_sub(x_64, x_4);
-lean_dec(x_64);
-x_66 = lean_unsigned_to_nat(2u);
-x_67 = lean_nat_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_62, x_68, x_4);
-return x_69;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_nullKind;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_62, x_70, x_4);
-return x_71;
-}
-else
-{
-lean_object* x_72; 
-lean_dec(x_4);
-x_72 = l_Lean_Parser_ParserState_popSyntax(x_62);
-return x_72;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(lean_object* x_1, uint8_t x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14(x_1, x_2, x_3, x_9, x_4, x_10, x_5, x_6, x_7);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
-_start:
-{
-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; 
-x_10 = l_Lean_Parser_Term_matchAlt;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_9, 1);
-lean_inc(x_14);
-lean_inc(x_8);
-lean_inc(x_7);
-x_15 = lean_apply_3(x_11, x_7, x_8, x_9);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_34; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_17 = lean_ctor_get(x_15, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_51 = lean_ctor_get(x_8, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_51, 2);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_FileMap_toPosition(x_52, x_19);
-lean_dec(x_52);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-lean_dec(x_53);
-x_55 = lean_nat_dec_le(x_1, x_54);
-lean_dec(x_54);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
-x_57 = l_Lean_Parser_ParserState_mkError(x_15, x_56);
-x_34 = x_57;
-goto block_50;
-}
-else
-{
-x_34 = x_15;
-goto block_50;
-}
-block_33:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_dec(x_19);
-lean_dec(x_18);
-{
-uint8_t _tmp_5 = x_3;
-lean_object* _tmp_8 = x_20;
-x_6 = _tmp_5;
-x_9 = _tmp_8;
-}
-goto _start;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-lean_dec(x_21);
-lean_dec(x_8);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19);
-lean_dec(x_18);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_4);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_4);
-return x_30;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_4);
-return x_32;
-}
-else
-{
-lean_dec(x_4);
-return x_23;
-}
-}
-}
-}
-block_50:
-{
-lean_object* x_35; 
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_inc(x_8);
-x_37 = l_Lean_Parser_tokenFn(x_8, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36);
-x_20 = x_45;
-goto block_33;
-}
-else
-{
-lean_dec(x_36);
-x_20 = x_37;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36);
-x_20 = x_47;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_38);
-x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36);
-x_20 = x_49;
-goto block_33;
-}
-}
-else
-{
-lean_dec(x_35);
-x_20 = x_34;
-goto block_33;
-}
-}
-}
-else
-{
-lean_dec(x_16);
-lean_dec(x_8);
-lean_dec(x_7);
-if (x_6 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_58 = lean_box(0);
-x_59 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_58);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_4);
-return x_61;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_62 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_array_get_size(x_63);
-lean_dec(x_63);
-x_65 = lean_nat_sub(x_64, x_4);
-lean_dec(x_64);
-x_66 = lean_unsigned_to_nat(2u);
-x_67 = lean_nat_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_62, x_68, x_4);
-return x_69;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_nullKind;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_62, x_70, x_4);
-return x_71;
-}
-else
-{
-lean_object* x_72; 
-lean_dec(x_4);
-x_72 = l_Lean_Parser_ParserState_popSyntax(x_62);
-return x_72;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(lean_object* x_1, uint8_t x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16(x_1, x_2, x_3, x_9, x_4, x_10, x_5, x_6, x_7);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
-_start:
-{
-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; 
-x_10 = l_Lean_Parser_Term_matchAlt;
-x_11 = lean_ctor_get(x_10, 1);
-lean_inc(x_11);
-x_12 = lean_ctor_get(x_9, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_9, 1);
-lean_inc(x_14);
-lean_inc(x_8);
-lean_inc(x_7);
-x_15 = lean_apply_3(x_11, x_7, x_8, x_9);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_34; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_17 = lean_ctor_get(x_15, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_51 = lean_ctor_get(x_8, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_51, 2);
-lean_inc(x_52);
-lean_dec(x_51);
-x_53 = l_Lean_FileMap_toPosition(x_52, x_19);
-lean_dec(x_52);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-lean_dec(x_53);
-x_55 = lean_nat_dec_le(x_1, x_54);
-lean_dec(x_54);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
-x_57 = l_Lean_Parser_ParserState_mkError(x_15, x_56);
-x_34 = x_57;
-goto block_50;
-}
-else
-{
-x_34 = x_15;
-goto block_50;
-}
-block_33:
-{
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_dec(x_19);
-lean_dec(x_18);
-{
-uint8_t _tmp_5 = x_3;
-lean_object* _tmp_8 = x_20;
-x_6 = _tmp_5;
-x_9 = _tmp_8;
-}
-goto _start;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-lean_dec(x_21);
-lean_dec(x_8);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19);
-lean_dec(x_18);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_4);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_nullKind;
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_29, x_4);
-return x_30;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_23, x_31, x_4);
-return x_32;
-}
-else
-{
-lean_dec(x_4);
-return x_23;
-}
-}
-}
-}
-block_50:
-{
-lean_object* x_35; 
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-if (lean_obj_tag(x_35) == 0)
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_inc(x_8);
-x_37 = l_Lean_Parser_tokenFn(x_8, x_34);
-x_38 = lean_ctor_get(x_37, 3);
-lean_inc(x_38);
-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_Lean_Parser_checkLeadingFn___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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-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___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36);
-x_20 = x_45;
-goto block_33;
-}
-else
-{
-lean_dec(x_36);
-x_20 = x_37;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-lean_dec(x_40);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36);
-x_20 = x_47;
-goto block_33;
-}
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-lean_dec(x_38);
-x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36);
-x_20 = x_49;
-goto block_33;
-}
-}
-else
-{
-lean_dec(x_35);
-x_20 = x_34;
-goto block_33;
-}
-}
-}
-else
-{
-lean_dec(x_16);
-lean_dec(x_8);
-lean_dec(x_7);
-if (x_6 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-lean_dec(x_14);
-lean_dec(x_13);
-x_58 = lean_box(0);
-x_59 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_58);
-x_60 = l_Lean_nullKind;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_4);
-return x_61;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_62 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-x_64 = lean_array_get_size(x_63);
-lean_dec(x_63);
-x_65 = lean_nat_sub(x_64, x_4);
-lean_dec(x_64);
-x_66 = lean_unsigned_to_nat(2u);
-x_67 = lean_nat_dec_eq(x_65, x_66);
-lean_dec(x_65);
-if (x_67 == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = l_Lean_nullKind;
-x_69 = l_Lean_Parser_ParserState_mkNode(x_62, x_68, x_4);
-return x_69;
-}
-else
-{
-if (x_5 == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = l_Lean_nullKind;
-x_71 = l_Lean_Parser_ParserState_mkNode(x_62, x_70, x_4);
-return x_71;
-}
-else
-{
-lean_object* x_72; 
-lean_dec(x_4);
-x_72 = l_Lean_Parser_ParserState_popSyntax(x_62);
-return x_72;
-}
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(lean_object* x_1, uint8_t x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = 0;
-x_11 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18(x_1, x_2, x_3, x_9, x_4, x_10, x_5, x_6, x_7);
-return x_11;
-}
-}
-lean_object* l_Lean_Parser_Term_matchAlts___elambda__1(uint8_t 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; 
-x_5 = lean_ctor_get(x_3, 0);
-lean_inc(x_5);
-x_6 = lean_ctor_get(x_5, 2);
-lean_inc(x_6);
-lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-x_8 = l_Lean_FileMap_toPosition(x_6, x_7);
-lean_dec(x_6);
-if (x_1 == 0)
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_9 = lean_ctor_get(x_8, 1);
-lean_inc(x_9);
-lean_dec(x_8);
-lean_inc(x_3);
-x_10 = l_Lean_Parser_tokenFn(x_3, x_4);
-x_11 = lean_ctor_get(x_10, 3);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; lean_object* x_13; 
-x_12 = lean_ctor_get(x_10, 0);
-lean_inc(x_12);
-x_13 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_12);
-lean_dec(x_12);
-if (lean_obj_tag(x_13) == 2)
-{
-lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_14 = lean_ctor_get(x_13, 1);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-x_16 = lean_string_dec_eq(x_14, x_15);
-lean_dec(x_14);
-if (x_16 == 0)
-{
-lean_object* x_17; lean_object* x_18; 
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_17 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_18 = l_Lean_Parser_ParserState_mkErrorsAt(x_10, x_17, x_7);
-return x_18;
-}
-else
-{
-uint8_t x_19; uint8_t x_20; lean_object* x_21; 
-lean_dec(x_7);
-x_19 = 0;
-x_20 = 0;
-x_21 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(x_9, x_19, x_20, x_20, x_2, x_3, x_10);
-lean_dec(x_9);
-return x_21;
-}
-}
-else
-{
-lean_object* x_22; lean_object* x_23; 
-lean_dec(x_13);
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_22 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_10, x_22, x_7);
-return x_23;
-}
-}
-else
-{
-lean_object* x_24; lean_object* x_25; 
-lean_dec(x_11);
-lean_dec(x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-x_24 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_10, x_24, x_7);
-return x_25;
-}
-}
-else
-{
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_53; lean_object* x_54; 
-x_26 = lean_ctor_get(x_8, 1);
-lean_inc(x_26);
-lean_dec(x_8);
-x_27 = lean_ctor_get(x_4, 0);
-lean_inc(x_27);
-x_28 = lean_array_get_size(x_27);
-lean_dec(x_27);
-lean_inc(x_3);
-x_53 = l_Lean_Parser_tokenFn(x_3, x_4);
-x_54 = lean_ctor_get(x_53, 3);
-lean_inc(x_54);
-if (lean_obj_tag(x_54) == 0)
-{
-lean_object* x_55; lean_object* x_56; 
-x_55 = lean_ctor_get(x_53, 0);
+x_23 = lean_ctor_get(x_19, 1);
+lean_inc(x_23);
+x_55 = lean_ctor_get(x_7, 0);
 lean_inc(x_55);
-x_56 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_55);
+x_56 = lean_ctor_get(x_55, 2);
+lean_inc(x_56);
 lean_dec(x_55);
-if (lean_obj_tag(x_56) == 2)
-{
-lean_object* x_57; lean_object* x_58; uint8_t x_59; 
-x_57 = lean_ctor_get(x_56, 1);
-lean_inc(x_57);
+x_57 = l_Lean_FileMap_toPosition(x_56, x_23);
 lean_dec(x_56);
-x_58 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
-x_59 = lean_string_dec_eq(x_57, x_58);
+x_58 = lean_ctor_get(x_57, 1);
+lean_inc(x_58);
 lean_dec(x_57);
+x_59 = lean_nat_dec_le(x_13, x_58);
+lean_dec(x_58);
+lean_dec(x_13);
 if (x_59 == 0)
 {
 lean_object* x_60; lean_object* x_61; 
-x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-lean_inc(x_7);
-x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_60, x_7);
-x_29 = x_61;
-goto block_52;
+x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+x_61 = l_Lean_Parser_ParserState_mkError(x_19, x_60);
+x_38 = x_61;
+goto block_54;
 }
 else
 {
-x_29 = x_53;
-goto block_52;
+x_38 = x_19;
+goto block_54;
 }
+block_37:
+{
+lean_object* x_25; 
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_dec(x_23);
+lean_dec(x_22);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_24;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
 }
 else
 {
-lean_object* x_62; lean_object* x_63; 
-lean_dec(x_56);
-x_62 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-lean_inc(x_7);
-x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_62, x_7);
-x_29 = x_63;
-goto block_52;
-}
-}
-else
-{
-lean_object* x_64; lean_object* x_65; 
-lean_dec(x_54);
-x_64 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
-lean_inc(x_7);
-x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_64, x_7);
-x_29 = x_65;
-goto block_52;
-}
-block_52:
-{
-lean_object* x_30; 
-x_30 = lean_ctor_get(x_29, 3);
-lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+lean_dec(x_25);
 lean_dec(x_7);
-x_31 = l_Lean_nullKind;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_29, x_31, x_28);
-x_33 = lean_ctor_get(x_32, 3);
-lean_inc(x_33);
-if (lean_obj_tag(x_33) == 0)
+x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_27, 0);
+lean_inc(x_28);
+x_29 = lean_array_get_size(x_28);
+lean_dec(x_28);
+x_30 = lean_nat_sub(x_29, x_4);
+lean_dec(x_29);
+x_31 = lean_unsigned_to_nat(1u);
+x_32 = lean_nat_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
 {
-uint8_t x_34; uint8_t x_35; lean_object* x_36; 
-x_34 = 0;
-x_35 = 0;
-x_36 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(x_26, x_34, x_35, x_35, x_2, x_3, x_32);
-lean_dec(x_26);
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_nullKind;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_4);
+return x_34;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_4);
 return x_36;
 }
 else
 {
-lean_dec(x_33);
-lean_dec(x_26);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_32;
+lean_dec(x_4);
+return x_27;
+}
+}
+}
+}
+block_54:
+{
+lean_object* x_39; 
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_40 = lean_ctor_get(x_38, 1);
+lean_inc(x_40);
+lean_inc(x_7);
+x_41 = l_Lean_Parser_tokenFn(x_7, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+x_44 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_43);
+lean_dec(x_43);
+if (lean_obj_tag(x_44) == 2)
+{
+lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_47 = lean_string_dec_eq(x_45, x_46);
+lean_dec(x_45);
+if (x_47 == 0)
+{
+lean_object* x_48; lean_object* x_49; 
+x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40);
+x_24 = x_49;
+goto block_37;
+}
+else
+{
+lean_dec(x_40);
+x_24 = x_41;
+goto block_37;
 }
 }
 else
 {
-lean_object* x_37; uint8_t x_38; 
-lean_dec(x_30);
-x_37 = lean_ctor_get(x_29, 1);
-lean_inc(x_37);
-x_38 = lean_nat_dec_eq(x_37, x_7);
-lean_dec(x_37);
-if (x_38 == 0)
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+x_50 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40);
+x_24 = x_51;
+goto block_37;
+}
+}
+else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_42);
+x_52 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40);
+x_24 = x_53;
+goto block_37;
+}
+}
+else
+{
+lean_dec(x_39);
+x_24 = x_38;
+goto block_37;
+}
+}
+}
+else
+{
+lean_dec(x_20);
+lean_dec(x_13);
 lean_dec(x_7);
-x_39 = l_Lean_nullKind;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_29, x_39, x_28);
-x_41 = lean_ctor_get(x_40, 3);
-lean_inc(x_41);
-if (lean_obj_tag(x_41) == 0)
+if (x_6 == 0)
 {
-uint8_t x_42; uint8_t x_43; lean_object* x_44; 
-x_42 = 0;
-x_43 = 0;
-x_44 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(x_26, x_42, x_43, x_43, x_2, x_3, x_40);
-lean_dec(x_26);
-return x_44;
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_62 = lean_box(0);
+x_63 = l_Lean_Parser_ParserState_pushSyntax(x_19, x_62);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_4);
+return x_65;
 }
 else
 {
-lean_dec(x_41);
-lean_dec(x_26);
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_66 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
+lean_dec(x_17);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_4);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(2u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_4);
+return x_73;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_nullKind;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_4);
+return x_75;
+}
+else
+{
+lean_object* x_76; 
+lean_dec(x_4);
+x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
+return x_76;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2(x_1, x_2, x_3, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+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; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_9, 2);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = l_Lean_FileMap_toPosition(x_10, x_11);
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_Term_matchAlt;
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_8, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = lean_ctor_get(x_8, 1);
+lean_inc(x_18);
+lean_inc(x_7);
+x_19 = lean_apply_2(x_15, x_7, x_8);
+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_24; lean_object* x_38; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_ctor_get(x_19, 1);
+lean_inc(x_23);
+x_55 = lean_ctor_get(x_7, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_55, 2);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_FileMap_toPosition(x_56, x_23);
+lean_dec(x_56);
+x_58 = lean_ctor_get(x_57, 1);
+lean_inc(x_58);
+lean_dec(x_57);
+x_59 = lean_nat_dec_le(x_13, x_58);
+lean_dec(x_58);
+lean_dec(x_13);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+x_61 = l_Lean_Parser_ParserState_mkError(x_19, x_60);
+x_38 = x_61;
+goto block_54;
+}
+else
+{
+x_38 = x_19;
+goto block_54;
+}
+block_37:
+{
+lean_object* x_25; 
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_dec(x_23);
+lean_dec(x_22);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_24;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+lean_dec(x_25);
+lean_dec(x_7);
+x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_27, 0);
+lean_inc(x_28);
+x_29 = lean_array_get_size(x_28);
+lean_dec(x_28);
+x_30 = lean_nat_sub(x_29, x_4);
+lean_dec(x_29);
+x_31 = lean_unsigned_to_nat(1u);
+x_32 = lean_nat_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_nullKind;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_4);
+return x_34;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_4);
+return x_36;
+}
+else
+{
+lean_dec(x_4);
+return x_27;
+}
+}
+}
+}
+block_54:
+{
+lean_object* x_39; 
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_40 = lean_ctor_get(x_38, 1);
+lean_inc(x_40);
+lean_inc(x_7);
+x_41 = l_Lean_Parser_tokenFn(x_7, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+x_44 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_43);
+lean_dec(x_43);
+if (lean_obj_tag(x_44) == 2)
+{
+lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_47 = lean_string_dec_eq(x_45, x_46);
+lean_dec(x_45);
+if (x_47 == 0)
+{
+lean_object* x_48; lean_object* x_49; 
+x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40);
+x_24 = x_49;
+goto block_37;
+}
+else
+{
+lean_dec(x_40);
+x_24 = x_41;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+x_50 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40);
+x_24 = x_51;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_42);
+x_52 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40);
+x_24 = x_53;
+goto block_37;
+}
+}
+else
+{
+lean_dec(x_39);
+x_24 = x_38;
+goto block_37;
+}
+}
+}
+else
+{
+lean_dec(x_20);
+lean_dec(x_13);
+lean_dec(x_7);
+if (x_6 == 0)
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_62 = lean_box(0);
+x_63 = l_Lean_Parser_ParserState_pushSyntax(x_19, x_62);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_4);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_66 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
+lean_dec(x_17);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_4);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(2u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_4);
+return x_73;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_nullKind;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_4);
+return x_75;
+}
+else
+{
+lean_object* x_76; 
+lean_dec(x_4);
+x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
+return x_76;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4(x_1, x_2, x_3, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+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; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_9, 2);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = l_Lean_FileMap_toPosition(x_10, x_11);
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_Term_matchAlt;
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_8, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = lean_ctor_get(x_8, 1);
+lean_inc(x_18);
+lean_inc(x_7);
+x_19 = lean_apply_2(x_15, x_7, x_8);
+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_24; lean_object* x_38; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_ctor_get(x_19, 1);
+lean_inc(x_23);
+x_55 = lean_ctor_get(x_7, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_55, 2);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_FileMap_toPosition(x_56, x_23);
+lean_dec(x_56);
+x_58 = lean_ctor_get(x_57, 1);
+lean_inc(x_58);
+lean_dec(x_57);
+x_59 = lean_nat_dec_le(x_13, x_58);
+lean_dec(x_58);
+lean_dec(x_13);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+x_61 = l_Lean_Parser_ParserState_mkError(x_19, x_60);
+x_38 = x_61;
+goto block_54;
+}
+else
+{
+x_38 = x_19;
+goto block_54;
+}
+block_37:
+{
+lean_object* x_25; 
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_dec(x_23);
+lean_dec(x_22);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_24;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+lean_dec(x_25);
+lean_dec(x_7);
+x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_27, 0);
+lean_inc(x_28);
+x_29 = lean_array_get_size(x_28);
+lean_dec(x_28);
+x_30 = lean_nat_sub(x_29, x_4);
+lean_dec(x_29);
+x_31 = lean_unsigned_to_nat(1u);
+x_32 = lean_nat_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_nullKind;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_4);
+return x_34;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_4);
+return x_36;
+}
+else
+{
+lean_dec(x_4);
+return x_27;
+}
+}
+}
+}
+block_54:
+{
+lean_object* x_39; 
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_40 = lean_ctor_get(x_38, 1);
+lean_inc(x_40);
+lean_inc(x_7);
+x_41 = l_Lean_Parser_tokenFn(x_7, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+x_44 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_43);
+lean_dec(x_43);
+if (lean_obj_tag(x_44) == 2)
+{
+lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_47 = lean_string_dec_eq(x_45, x_46);
+lean_dec(x_45);
+if (x_47 == 0)
+{
+lean_object* x_48; lean_object* x_49; 
+x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40);
+x_24 = x_49;
+goto block_37;
+}
+else
+{
+lean_dec(x_40);
+x_24 = x_41;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+x_50 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40);
+x_24 = x_51;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_42);
+x_52 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40);
+x_24 = x_53;
+goto block_37;
+}
+}
+else
+{
+lean_dec(x_39);
+x_24 = x_38;
+goto block_37;
+}
+}
+}
+else
+{
+lean_dec(x_20);
+lean_dec(x_13);
+lean_dec(x_7);
+if (x_6 == 0)
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_62 = lean_box(0);
+x_63 = l_Lean_Parser_ParserState_pushSyntax(x_19, x_62);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_4);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_66 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
+lean_dec(x_17);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_4);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(2u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_4);
+return x_73;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_nullKind;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_4);
+return x_75;
+}
+else
+{
+lean_object* x_76; 
+lean_dec(x_4);
+x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
+return x_76;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6(x_1, x_2, x_3, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+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; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_9, 2);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = l_Lean_FileMap_toPosition(x_10, x_11);
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_Term_matchAlt;
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_8, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = lean_ctor_get(x_8, 1);
+lean_inc(x_18);
+lean_inc(x_7);
+x_19 = lean_apply_2(x_15, x_7, x_8);
+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_24; lean_object* x_38; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_ctor_get(x_19, 1);
+lean_inc(x_23);
+x_55 = lean_ctor_get(x_7, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_55, 2);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_FileMap_toPosition(x_56, x_23);
+lean_dec(x_56);
+x_58 = lean_ctor_get(x_57, 1);
+lean_inc(x_58);
+lean_dec(x_57);
+x_59 = lean_nat_dec_le(x_13, x_58);
+lean_dec(x_58);
+lean_dec(x_13);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+x_61 = l_Lean_Parser_ParserState_mkError(x_19, x_60);
+x_38 = x_61;
+goto block_54;
+}
+else
+{
+x_38 = x_19;
+goto block_54;
+}
+block_37:
+{
+lean_object* x_25; 
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_dec(x_23);
+lean_dec(x_22);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_24;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+lean_dec(x_25);
+lean_dec(x_7);
+x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_27, 0);
+lean_inc(x_28);
+x_29 = lean_array_get_size(x_28);
+lean_dec(x_28);
+x_30 = lean_nat_sub(x_29, x_4);
+lean_dec(x_29);
+x_31 = lean_unsigned_to_nat(1u);
+x_32 = lean_nat_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_nullKind;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_4);
+return x_34;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_4);
+return x_36;
+}
+else
+{
+lean_dec(x_4);
+return x_27;
+}
+}
+}
+}
+block_54:
+{
+lean_object* x_39; 
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_40 = lean_ctor_get(x_38, 1);
+lean_inc(x_40);
+lean_inc(x_7);
+x_41 = l_Lean_Parser_tokenFn(x_7, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+x_44 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_43);
+lean_dec(x_43);
+if (lean_obj_tag(x_44) == 2)
+{
+lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_47 = lean_string_dec_eq(x_45, x_46);
+lean_dec(x_45);
+if (x_47 == 0)
+{
+lean_object* x_48; lean_object* x_49; 
+x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40);
+x_24 = x_49;
+goto block_37;
+}
+else
+{
+lean_dec(x_40);
+x_24 = x_41;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+x_50 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40);
+x_24 = x_51;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_42);
+x_52 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40);
+x_24 = x_53;
+goto block_37;
+}
+}
+else
+{
+lean_dec(x_39);
+x_24 = x_38;
+goto block_37;
+}
+}
+}
+else
+{
+lean_dec(x_20);
+lean_dec(x_13);
+lean_dec(x_7);
+if (x_6 == 0)
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_62 = lean_box(0);
+x_63 = l_Lean_Parser_ParserState_pushSyntax(x_19, x_62);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_4);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_66 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
+lean_dec(x_17);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_4);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(2u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_4);
+return x_73;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_nullKind;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_4);
+return x_75;
+}
+else
+{
+lean_object* x_76; 
+lean_dec(x_4);
+x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
+return x_76;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8(x_1, x_2, x_3, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+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; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_9, 2);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = l_Lean_FileMap_toPosition(x_10, x_11);
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_Term_matchAlt;
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_8, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = lean_ctor_get(x_8, 1);
+lean_inc(x_18);
+lean_inc(x_7);
+x_19 = lean_apply_2(x_15, x_7, x_8);
+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_24; lean_object* x_38; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_ctor_get(x_19, 1);
+lean_inc(x_23);
+x_55 = lean_ctor_get(x_7, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_55, 2);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_FileMap_toPosition(x_56, x_23);
+lean_dec(x_56);
+x_58 = lean_ctor_get(x_57, 1);
+lean_inc(x_58);
+lean_dec(x_57);
+x_59 = lean_nat_dec_le(x_13, x_58);
+lean_dec(x_58);
+lean_dec(x_13);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+x_61 = l_Lean_Parser_ParserState_mkError(x_19, x_60);
+x_38 = x_61;
+goto block_54;
+}
+else
+{
+x_38 = x_19;
+goto block_54;
+}
+block_37:
+{
+lean_object* x_25; 
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_dec(x_23);
+lean_dec(x_22);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_24;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+lean_dec(x_25);
+lean_dec(x_7);
+x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_27, 0);
+lean_inc(x_28);
+x_29 = lean_array_get_size(x_28);
+lean_dec(x_28);
+x_30 = lean_nat_sub(x_29, x_4);
+lean_dec(x_29);
+x_31 = lean_unsigned_to_nat(1u);
+x_32 = lean_nat_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_nullKind;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_4);
+return x_34;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_4);
+return x_36;
+}
+else
+{
+lean_dec(x_4);
+return x_27;
+}
+}
+}
+}
+block_54:
+{
+lean_object* x_39; 
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_40 = lean_ctor_get(x_38, 1);
+lean_inc(x_40);
+lean_inc(x_7);
+x_41 = l_Lean_Parser_tokenFn(x_7, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+x_44 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_43);
+lean_dec(x_43);
+if (lean_obj_tag(x_44) == 2)
+{
+lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_47 = lean_string_dec_eq(x_45, x_46);
+lean_dec(x_45);
+if (x_47 == 0)
+{
+lean_object* x_48; lean_object* x_49; 
+x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40);
+x_24 = x_49;
+goto block_37;
+}
+else
+{
+lean_dec(x_40);
+x_24 = x_41;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+x_50 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40);
+x_24 = x_51;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_42);
+x_52 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40);
+x_24 = x_53;
+goto block_37;
+}
+}
+else
+{
+lean_dec(x_39);
+x_24 = x_38;
+goto block_37;
+}
+}
+}
+else
+{
+lean_dec(x_20);
+lean_dec(x_13);
+lean_dec(x_7);
+if (x_6 == 0)
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_62 = lean_box(0);
+x_63 = l_Lean_Parser_ParserState_pushSyntax(x_19, x_62);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_4);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_66 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
+lean_dec(x_17);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_4);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(2u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_4);
+return x_73;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_nullKind;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_4);
+return x_75;
+}
+else
+{
+lean_object* x_76; 
+lean_dec(x_4);
+x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
+return x_76;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10(x_1, x_2, x_3, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+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; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_9, 2);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = l_Lean_FileMap_toPosition(x_10, x_11);
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_Term_matchAlt;
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_8, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = lean_ctor_get(x_8, 1);
+lean_inc(x_18);
+lean_inc(x_7);
+x_19 = lean_apply_2(x_15, x_7, x_8);
+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_24; lean_object* x_38; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_ctor_get(x_19, 1);
+lean_inc(x_23);
+x_55 = lean_ctor_get(x_7, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_55, 2);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_FileMap_toPosition(x_56, x_23);
+lean_dec(x_56);
+x_58 = lean_ctor_get(x_57, 1);
+lean_inc(x_58);
+lean_dec(x_57);
+x_59 = lean_nat_dec_le(x_13, x_58);
+lean_dec(x_58);
+lean_dec(x_13);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+x_61 = l_Lean_Parser_ParserState_mkError(x_19, x_60);
+x_38 = x_61;
+goto block_54;
+}
+else
+{
+x_38 = x_19;
+goto block_54;
+}
+block_37:
+{
+lean_object* x_25; 
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_dec(x_23);
+lean_dec(x_22);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_24;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+lean_dec(x_25);
+lean_dec(x_7);
+x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_27, 0);
+lean_inc(x_28);
+x_29 = lean_array_get_size(x_28);
+lean_dec(x_28);
+x_30 = lean_nat_sub(x_29, x_4);
+lean_dec(x_29);
+x_31 = lean_unsigned_to_nat(1u);
+x_32 = lean_nat_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_nullKind;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_4);
+return x_34;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_4);
+return x_36;
+}
+else
+{
+lean_dec(x_4);
+return x_27;
+}
+}
+}
+}
+block_54:
+{
+lean_object* x_39; 
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_40 = lean_ctor_get(x_38, 1);
+lean_inc(x_40);
+lean_inc(x_7);
+x_41 = l_Lean_Parser_tokenFn(x_7, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+x_44 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_43);
+lean_dec(x_43);
+if (lean_obj_tag(x_44) == 2)
+{
+lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_47 = lean_string_dec_eq(x_45, x_46);
+lean_dec(x_45);
+if (x_47 == 0)
+{
+lean_object* x_48; lean_object* x_49; 
+x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40);
+x_24 = x_49;
+goto block_37;
+}
+else
+{
+lean_dec(x_40);
+x_24 = x_41;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+x_50 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40);
+x_24 = x_51;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_42);
+x_52 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40);
+x_24 = x_53;
+goto block_37;
+}
+}
+else
+{
+lean_dec(x_39);
+x_24 = x_38;
+goto block_37;
+}
+}
+}
+else
+{
+lean_dec(x_20);
+lean_dec(x_13);
+lean_dec(x_7);
+if (x_6 == 0)
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_62 = lean_box(0);
+x_63 = l_Lean_Parser_ParserState_pushSyntax(x_19, x_62);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_4);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_66 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
+lean_dec(x_17);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_4);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(2u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_4);
+return x_73;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_nullKind;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_4);
+return x_75;
+}
+else
+{
+lean_object* x_76; 
+lean_dec(x_4);
+x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
+return x_76;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12(x_1, x_2, x_3, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+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; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_9, 2);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = l_Lean_FileMap_toPosition(x_10, x_11);
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_Term_matchAlt;
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_8, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = lean_ctor_get(x_8, 1);
+lean_inc(x_18);
+lean_inc(x_7);
+x_19 = lean_apply_2(x_15, x_7, x_8);
+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_24; lean_object* x_38; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_ctor_get(x_19, 1);
+lean_inc(x_23);
+x_55 = lean_ctor_get(x_7, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_55, 2);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_FileMap_toPosition(x_56, x_23);
+lean_dec(x_56);
+x_58 = lean_ctor_get(x_57, 1);
+lean_inc(x_58);
+lean_dec(x_57);
+x_59 = lean_nat_dec_le(x_13, x_58);
+lean_dec(x_58);
+lean_dec(x_13);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+x_61 = l_Lean_Parser_ParserState_mkError(x_19, x_60);
+x_38 = x_61;
+goto block_54;
+}
+else
+{
+x_38 = x_19;
+goto block_54;
+}
+block_37:
+{
+lean_object* x_25; 
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_dec(x_23);
+lean_dec(x_22);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_24;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+lean_dec(x_25);
+lean_dec(x_7);
+x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_27, 0);
+lean_inc(x_28);
+x_29 = lean_array_get_size(x_28);
+lean_dec(x_28);
+x_30 = lean_nat_sub(x_29, x_4);
+lean_dec(x_29);
+x_31 = lean_unsigned_to_nat(1u);
+x_32 = lean_nat_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_nullKind;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_4);
+return x_34;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_4);
+return x_36;
+}
+else
+{
+lean_dec(x_4);
+return x_27;
+}
+}
+}
+}
+block_54:
+{
+lean_object* x_39; 
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_40 = lean_ctor_get(x_38, 1);
+lean_inc(x_40);
+lean_inc(x_7);
+x_41 = l_Lean_Parser_tokenFn(x_7, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+x_44 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_43);
+lean_dec(x_43);
+if (lean_obj_tag(x_44) == 2)
+{
+lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_47 = lean_string_dec_eq(x_45, x_46);
+lean_dec(x_45);
+if (x_47 == 0)
+{
+lean_object* x_48; lean_object* x_49; 
+x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40);
+x_24 = x_49;
+goto block_37;
+}
+else
+{
+lean_dec(x_40);
+x_24 = x_41;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+x_50 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40);
+x_24 = x_51;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_42);
+x_52 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40);
+x_24 = x_53;
+goto block_37;
+}
+}
+else
+{
+lean_dec(x_39);
+x_24 = x_38;
+goto block_37;
+}
+}
+}
+else
+{
+lean_dec(x_20);
+lean_dec(x_13);
+lean_dec(x_7);
+if (x_6 == 0)
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_62 = lean_box(0);
+x_63 = l_Lean_Parser_ParserState_pushSyntax(x_19, x_62);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_4);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_66 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
+lean_dec(x_17);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_4);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(2u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_4);
+return x_73;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_nullKind;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_4);
+return x_75;
+}
+else
+{
+lean_object* x_76; 
+lean_dec(x_4);
+x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
+return x_76;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14(x_1, x_2, x_3, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+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; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_9, 2);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = l_Lean_FileMap_toPosition(x_10, x_11);
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_Term_matchAlt;
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_8, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = lean_ctor_get(x_8, 1);
+lean_inc(x_18);
+lean_inc(x_7);
+x_19 = lean_apply_2(x_15, x_7, x_8);
+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_24; lean_object* x_38; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_ctor_get(x_19, 1);
+lean_inc(x_23);
+x_55 = lean_ctor_get(x_7, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_55, 2);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_FileMap_toPosition(x_56, x_23);
+lean_dec(x_56);
+x_58 = lean_ctor_get(x_57, 1);
+lean_inc(x_58);
+lean_dec(x_57);
+x_59 = lean_nat_dec_le(x_13, x_58);
+lean_dec(x_58);
+lean_dec(x_13);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+x_61 = l_Lean_Parser_ParserState_mkError(x_19, x_60);
+x_38 = x_61;
+goto block_54;
+}
+else
+{
+x_38 = x_19;
+goto block_54;
+}
+block_37:
+{
+lean_object* x_25; 
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_dec(x_23);
+lean_dec(x_22);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_24;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+lean_dec(x_25);
+lean_dec(x_7);
+x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_27, 0);
+lean_inc(x_28);
+x_29 = lean_array_get_size(x_28);
+lean_dec(x_28);
+x_30 = lean_nat_sub(x_29, x_4);
+lean_dec(x_29);
+x_31 = lean_unsigned_to_nat(1u);
+x_32 = lean_nat_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_nullKind;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_4);
+return x_34;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_4);
+return x_36;
+}
+else
+{
+lean_dec(x_4);
+return x_27;
+}
+}
+}
+}
+block_54:
+{
+lean_object* x_39; 
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_40 = lean_ctor_get(x_38, 1);
+lean_inc(x_40);
+lean_inc(x_7);
+x_41 = l_Lean_Parser_tokenFn(x_7, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+x_44 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_43);
+lean_dec(x_43);
+if (lean_obj_tag(x_44) == 2)
+{
+lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_47 = lean_string_dec_eq(x_45, x_46);
+lean_dec(x_45);
+if (x_47 == 0)
+{
+lean_object* x_48; lean_object* x_49; 
+x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40);
+x_24 = x_49;
+goto block_37;
+}
+else
+{
+lean_dec(x_40);
+x_24 = x_41;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+x_50 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40);
+x_24 = x_51;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_42);
+x_52 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40);
+x_24 = x_53;
+goto block_37;
+}
+}
+else
+{
+lean_dec(x_39);
+x_24 = x_38;
+goto block_37;
+}
+}
+}
+else
+{
+lean_dec(x_20);
+lean_dec(x_13);
+lean_dec(x_7);
+if (x_6 == 0)
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_62 = lean_box(0);
+x_63 = l_Lean_Parser_ParserState_pushSyntax(x_19, x_62);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_4);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_66 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
+lean_dec(x_17);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_4);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(2u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_4);
+return x_73;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_nullKind;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_4);
+return x_75;
+}
+else
+{
+lean_object* x_76; 
+lean_dec(x_4);
+x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
+return x_76;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16(x_1, x_2, x_3, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, uint8_t x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+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; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_9, 2);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = l_Lean_FileMap_toPosition(x_10, x_11);
+x_13 = lean_ctor_get(x_12, 1);
+lean_inc(x_13);
+lean_dec(x_12);
+x_14 = l_Lean_Parser_Term_matchAlt;
+x_15 = lean_ctor_get(x_14, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_8, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+x_18 = lean_ctor_get(x_8, 1);
+lean_inc(x_18);
+lean_inc(x_7);
+x_19 = lean_apply_2(x_15, x_7, x_8);
+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_24; lean_object* x_38; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+x_23 = lean_ctor_get(x_19, 1);
+lean_inc(x_23);
+x_55 = lean_ctor_get(x_7, 0);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_55, 2);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_FileMap_toPosition(x_56, x_23);
+lean_dec(x_56);
+x_58 = lean_ctor_get(x_57, 1);
+lean_inc(x_58);
+lean_dec(x_57);
+x_59 = lean_nat_dec_le(x_13, x_58);
+lean_dec(x_58);
+lean_dec(x_13);
+if (x_59 == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6;
+x_61 = l_Lean_Parser_ParserState_mkError(x_19, x_60);
+x_38 = x_61;
+goto block_54;
+}
+else
+{
+x_38 = x_19;
+goto block_54;
+}
+block_37:
+{
+lean_object* x_25; 
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_dec(x_23);
+lean_dec(x_22);
+{
+uint8_t _tmp_5 = x_3;
+lean_object* _tmp_7 = x_24;
+x_6 = _tmp_5;
+x_8 = _tmp_7;
+}
+goto _start;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+lean_dec(x_25);
+lean_dec(x_7);
+x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23);
+lean_dec(x_22);
+x_28 = lean_ctor_get(x_27, 0);
+lean_inc(x_28);
+x_29 = lean_array_get_size(x_28);
+lean_dec(x_28);
+x_30 = lean_nat_sub(x_29, x_4);
+lean_dec(x_29);
+x_31 = lean_unsigned_to_nat(1u);
+x_32 = lean_nat_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_nullKind;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_27, x_33, x_4);
+return x_34;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_nullKind;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_4);
+return x_36;
+}
+else
+{
+lean_dec(x_4);
+return x_27;
+}
+}
+}
+}
+block_54:
+{
+lean_object* x_39; 
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+if (lean_obj_tag(x_39) == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_40 = lean_ctor_get(x_38, 1);
+lean_inc(x_40);
+lean_inc(x_7);
+x_41 = l_Lean_Parser_tokenFn(x_7, x_38);
+x_42 = lean_ctor_get(x_41, 3);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; 
+x_43 = lean_ctor_get(x_41, 0);
+lean_inc(x_43);
+x_44 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_43);
+lean_dec(x_43);
+if (lean_obj_tag(x_44) == 2)
+{
+lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_45 = lean_ctor_get(x_44, 1);
+lean_inc(x_45);
+lean_dec(x_44);
+x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_47 = lean_string_dec_eq(x_45, x_46);
+lean_dec(x_45);
+if (x_47 == 0)
+{
+lean_object* x_48; lean_object* x_49; 
+x_48 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40);
+x_24 = x_49;
+goto block_37;
+}
+else
+{
+lean_dec(x_40);
+x_24 = x_41;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_44);
+x_50 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40);
+x_24 = x_51;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+lean_dec(x_42);
+x_52 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40);
+x_24 = x_53;
+goto block_37;
+}
+}
+else
+{
+lean_dec(x_39);
+x_24 = x_38;
+goto block_37;
+}
+}
+}
+else
+{
+lean_dec(x_20);
+lean_dec(x_13);
+lean_dec(x_7);
+if (x_6 == 0)
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_18);
+lean_dec(x_17);
+x_62 = lean_box(0);
+x_63 = l_Lean_Parser_ParserState_pushSyntax(x_19, x_62);
+x_64 = l_Lean_nullKind;
+x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_4);
+return x_65;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_66 = l_Lean_Parser_ParserState_restore(x_19, x_17, x_18);
+lean_dec(x_17);
+x_67 = lean_ctor_get(x_66, 0);
+lean_inc(x_67);
+x_68 = lean_array_get_size(x_67);
+lean_dec(x_67);
+x_69 = lean_nat_sub(x_68, x_4);
+lean_dec(x_68);
+x_70 = lean_unsigned_to_nat(2u);
+x_71 = lean_nat_dec_eq(x_69, x_70);
+lean_dec(x_69);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; 
+x_72 = l_Lean_nullKind;
+x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_4);
+return x_73;
+}
+else
+{
+if (x_5 == 0)
+{
+lean_object* x_74; lean_object* x_75; 
+x_74 = l_Lean_nullKind;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_4);
+return x_75;
+}
+else
+{
+lean_object* x_76; 
+lean_dec(x_4);
+x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
+return x_76;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = 0;
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18(x_1, x_2, x_3, x_8, x_4, x_9, x_5, x_6);
+return x_10;
+}
+}
+lean_object* l_Lean_Parser_Term_matchAlts___elambda__1(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (x_1 == 0)
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_2);
+x_5 = l_Lean_Parser_tokenFn(x_2, x_3);
+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; 
+x_7 = lean_ctor_get(x_5, 0);
+lean_inc(x_7);
+x_8 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_7);
+lean_dec(x_7);
+if (lean_obj_tag(x_8) == 2)
+{
+lean_object* x_9; lean_object* x_10; uint8_t x_11; 
+x_9 = lean_ctor_get(x_8, 1);
+lean_inc(x_9);
+lean_dec(x_8);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_11 = lean_string_dec_eq(x_9, x_10);
+lean_dec(x_9);
+if (x_11 == 0)
+{
+lean_object* x_12; lean_object* x_13; 
 lean_dec(x_3);
 lean_dec(x_2);
-return x_40;
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_13 = l_Lean_Parser_ParserState_mkErrorsAt(x_5, x_12, x_4);
+return x_13;
+}
+else
+{
+uint8_t x_14; lean_object* x_15; 
+lean_dec(x_4);
+x_14 = 0;
+lean_inc(x_2);
+x_15 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(x_2, x_3, x_14, x_14, x_2, x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_15;
 }
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-x_45 = l_Lean_Parser_ParserState_restore(x_29, x_28, x_7);
-x_46 = l_Lean_nullKind;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_28);
-x_48 = lean_ctor_get(x_47, 3);
+lean_object* x_16; lean_object* x_17; 
+lean_dec(x_8);
+lean_dec(x_3);
+lean_dec(x_2);
+x_16 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_5, x_16, x_4);
+return x_17;
+}
+}
+else
+{
+lean_object* x_18; lean_object* x_19; 
+lean_dec(x_6);
+lean_dec(x_3);
+lean_dec(x_2);
+x_18 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_5, x_18, x_4);
+return x_19;
+}
+}
+else
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_44; lean_object* x_45; 
+x_20 = lean_ctor_get(x_3, 1);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_3, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
+lean_dec(x_21);
+lean_inc(x_3);
+lean_inc(x_2);
+x_44 = l_Lean_Parser_tokenFn(x_2, x_3);
+x_45 = lean_ctor_get(x_44, 3);
+lean_inc(x_45);
+if (lean_obj_tag(x_45) == 0)
+{
+lean_object* x_46; lean_object* x_47; 
+x_46 = lean_ctor_get(x_44, 0);
+lean_inc(x_46);
+x_47 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_46);
+lean_dec(x_46);
+if (lean_obj_tag(x_47) == 2)
+{
+lean_object* x_48; lean_object* x_49; uint8_t x_50; 
+x_48 = lean_ctor_get(x_47, 1);
 lean_inc(x_48);
-if (lean_obj_tag(x_48) == 0)
+lean_dec(x_47);
+x_49 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2;
+x_50 = lean_string_dec_eq(x_48, x_49);
+lean_dec(x_48);
+if (x_50 == 0)
 {
-uint8_t x_49; uint8_t x_50; lean_object* x_51; 
-x_49 = 0;
-x_50 = 0;
-x_51 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(x_26, x_49, x_50, x_50, x_2, x_3, x_47);
-lean_dec(x_26);
-return x_51;
+lean_object* x_51; lean_object* x_52; 
+x_51 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+lean_inc(x_20);
+x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_51, x_20);
+x_23 = x_52;
+goto block_43;
 }
 else
 {
-lean_dec(x_48);
-lean_dec(x_26);
+x_23 = x_44;
+goto block_43;
+}
+}
+else
+{
+lean_object* x_53; lean_object* x_54; 
+lean_dec(x_47);
+x_53 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+lean_inc(x_20);
+x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_53, x_20);
+x_23 = x_54;
+goto block_43;
+}
+}
+else
+{
+lean_object* x_55; lean_object* x_56; 
+lean_dec(x_45);
+x_55 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__5;
+lean_inc(x_20);
+x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_55, x_20);
+x_23 = x_56;
+goto block_43;
+}
+block_43:
+{
+lean_object* x_24; 
+x_24 = lean_ctor_get(x_23, 3);
+lean_inc(x_24);
+if (lean_obj_tag(x_24) == 0)
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+lean_dec(x_20);
+x_25 = l_Lean_nullKind;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_23, x_25, x_22);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
+{
+uint8_t x_28; lean_object* x_29; 
+x_28 = 0;
+lean_inc(x_2);
+x_29 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(x_2, x_3, x_28, x_28, x_2, x_26);
 lean_dec(x_3);
 lean_dec(x_2);
-return x_47;
+return x_29;
+}
+else
+{
+lean_dec(x_27);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_26;
+}
+}
+else
+{
+lean_object* x_30; uint8_t x_31; 
+lean_dec(x_24);
+x_30 = lean_ctor_get(x_23, 1);
+lean_inc(x_30);
+x_31 = lean_nat_dec_eq(x_30, x_20);
+lean_dec(x_30);
+if (x_31 == 0)
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_20);
+x_32 = l_Lean_nullKind;
+x_33 = l_Lean_Parser_ParserState_mkNode(x_23, x_32, x_22);
+x_34 = lean_ctor_get(x_33, 3);
+lean_inc(x_34);
+if (lean_obj_tag(x_34) == 0)
+{
+uint8_t x_35; lean_object* x_36; 
+x_35 = 0;
+lean_inc(x_2);
+x_36 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(x_2, x_3, x_35, x_35, x_2, x_33);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_36;
+}
+else
+{
+lean_dec(x_34);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_33;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_37 = l_Lean_Parser_ParserState_restore(x_23, x_22, x_20);
+x_38 = l_Lean_nullKind;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_22);
+x_40 = lean_ctor_get(x_39, 3);
+lean_inc(x_40);
+if (lean_obj_tag(x_40) == 0)
+{
+uint8_t x_41; lean_object* x_42; 
+x_41 = 0;
+lean_inc(x_2);
+x_42 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(x_2, x_3, x_41, x_41, x_2, x_39);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_42;
+}
+else
+{
+lean_dec(x_40);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_39;
 }
 }
 }
@@ -22482,7 +22112,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; 
 x_2 = lean_box(x_1);
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Term_matchAlts___elambda__1___boxed), 4, 1);
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Term_matchAlts___elambda__1___boxed), 3, 1);
 lean_closure_set(x_3, 0, x_2);
 if (x_1 == 0)
 {
@@ -22504,302 +22134,284 @@ return x_7;
 }
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, 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* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
-uint8_t x_10; uint8_t x_11; uint8_t x_12; uint8_t x_13; lean_object* x_14; 
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_3);
-lean_dec(x_3);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = lean_unbox(x_6);
-lean_dec(x_6);
-x_14 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2(x_1, x_10, x_11, x_4, x_12, x_13, x_7, x_8, x_9);
-lean_dec(x_1);
-return x_14;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-uint8_t x_8; uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_unbox(x_2);
-lean_dec(x_2);
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
 x_9 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_unbox(x_4);
-lean_dec(x_4);
-x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1(x_1, x_8, x_9, x_10, x_5, x_6, x_7);
-lean_dec(x_1);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_10; uint8_t x_11; uint8_t x_12; uint8_t x_13; lean_object* x_14; 
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_3);
-lean_dec(x_3);
-x_12 = lean_unbox(x_5);
+x_10 = lean_unbox(x_5);
 lean_dec(x_5);
-x_13 = lean_unbox(x_6);
+x_11 = lean_unbox(x_6);
 lean_dec(x_6);
-x_14 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4(x_1, x_10, x_11, x_4, x_12, x_13, x_7, x_8, x_9);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_14;
+return x_12;
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_8; uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_unbox(x_2);
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_3);
+lean_dec(x_3);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1(x_1, x_2, x_7, x_8, x_5, x_6);
 lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
 x_9 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_unbox(x_4);
-lean_dec(x_4);
-x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3(x_1, x_8, x_9, x_10, x_5, x_6, x_7);
-lean_dec(x_1);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_10; uint8_t x_11; uint8_t x_12; uint8_t x_13; lean_object* x_14; 
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_3);
-lean_dec(x_3);
-x_12 = lean_unbox(x_5);
+x_10 = lean_unbox(x_5);
 lean_dec(x_5);
-x_13 = lean_unbox(x_6);
+x_11 = lean_unbox(x_6);
 lean_dec(x_6);
-x_14 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6(x_1, x_10, x_11, x_4, x_12, x_13, x_7, x_8, x_9);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_14;
+return x_12;
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_8; uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_unbox(x_2);
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_3);
+lean_dec(x_3);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3(x_1, x_2, x_7, x_8, x_5, x_6);
 lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
 x_9 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_unbox(x_4);
-lean_dec(x_4);
-x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5(x_1, x_8, x_9, x_10, x_5, x_6, x_7);
-lean_dec(x_1);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_10; uint8_t x_11; uint8_t x_12; uint8_t x_13; lean_object* x_14; 
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_3);
-lean_dec(x_3);
-x_12 = lean_unbox(x_5);
+x_10 = lean_unbox(x_5);
 lean_dec(x_5);
-x_13 = lean_unbox(x_6);
+x_11 = lean_unbox(x_6);
 lean_dec(x_6);
-x_14 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8(x_1, x_10, x_11, x_4, x_12, x_13, x_7, x_8, x_9);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_14;
+return x_12;
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_8; uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_unbox(x_2);
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_3);
+lean_dec(x_3);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5(x_1, x_2, x_7, x_8, x_5, x_6);
 lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
 x_9 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_unbox(x_4);
-lean_dec(x_4);
-x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(x_1, x_8, x_9, x_10, x_5, x_6, x_7);
-lean_dec(x_1);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_10; uint8_t x_11; uint8_t x_12; uint8_t x_13; lean_object* x_14; 
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_3);
-lean_dec(x_3);
-x_12 = lean_unbox(x_5);
+x_10 = lean_unbox(x_5);
 lean_dec(x_5);
-x_13 = lean_unbox(x_6);
+x_11 = lean_unbox(x_6);
 lean_dec(x_6);
-x_14 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10(x_1, x_10, x_11, x_4, x_12, x_13, x_7, x_8, x_9);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_14;
+return x_12;
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_8; uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_unbox(x_2);
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_3);
+lean_dec(x_3);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(x_1, x_2, x_7, x_8, x_5, x_6);
 lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
 x_9 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_unbox(x_4);
-lean_dec(x_4);
-x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9(x_1, x_8, x_9, x_10, x_5, x_6, x_7);
-lean_dec(x_1);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_10; uint8_t x_11; uint8_t x_12; uint8_t x_13; lean_object* x_14; 
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_3);
-lean_dec(x_3);
-x_12 = lean_unbox(x_5);
+x_10 = lean_unbox(x_5);
 lean_dec(x_5);
-x_13 = lean_unbox(x_6);
+x_11 = lean_unbox(x_6);
 lean_dec(x_6);
-x_14 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12(x_1, x_10, x_11, x_4, x_12, x_13, x_7, x_8, x_9);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_14;
+return x_12;
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_8; uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_unbox(x_2);
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_3);
+lean_dec(x_3);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9(x_1, x_2, x_7, x_8, x_5, x_6);
 lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
 x_9 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_unbox(x_4);
-lean_dec(x_4);
-x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11(x_1, x_8, x_9, x_10, x_5, x_6, x_7);
-lean_dec(x_1);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_10; uint8_t x_11; uint8_t x_12; uint8_t x_13; lean_object* x_14; 
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_3);
-lean_dec(x_3);
-x_12 = lean_unbox(x_5);
+x_10 = lean_unbox(x_5);
 lean_dec(x_5);
-x_13 = lean_unbox(x_6);
+x_11 = lean_unbox(x_6);
 lean_dec(x_6);
-x_14 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14(x_1, x_10, x_11, x_4, x_12, x_13, x_7, x_8, x_9);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_14;
+return x_12;
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_8; uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_unbox(x_2);
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_3);
+lean_dec(x_3);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11(x_1, x_2, x_7, x_8, x_5, x_6);
 lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
 x_9 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_unbox(x_4);
-lean_dec(x_4);
-x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(x_1, x_8, x_9, x_10, x_5, x_6, x_7);
-lean_dec(x_1);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_10; uint8_t x_11; uint8_t x_12; uint8_t x_13; lean_object* x_14; 
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_3);
-lean_dec(x_3);
-x_12 = lean_unbox(x_5);
+x_10 = lean_unbox(x_5);
 lean_dec(x_5);
-x_13 = lean_unbox(x_6);
+x_11 = lean_unbox(x_6);
 lean_dec(x_6);
-x_14 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16(x_1, x_10, x_11, x_4, x_12, x_13, x_7, x_8, x_9);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_14;
+return x_12;
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_8; uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_unbox(x_2);
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_3);
+lean_dec(x_3);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(x_1, x_2, x_7, x_8, x_5, x_6);
 lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
 x_9 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_unbox(x_4);
-lean_dec(x_4);
-x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(x_1, x_8, x_9, x_10, x_5, x_6, x_7);
-lean_dec(x_1);
-return x_11;
-}
-}
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18___boxed(lean_object* x_1, lean_object* x_2, 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) {
-_start:
-{
-uint8_t x_10; uint8_t x_11; uint8_t x_12; uint8_t x_13; lean_object* x_14; 
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_3);
-lean_dec(x_3);
-x_12 = lean_unbox(x_5);
+x_10 = lean_unbox(x_5);
 lean_dec(x_5);
-x_13 = lean_unbox(x_6);
+x_11 = lean_unbox(x_6);
 lean_dec(x_6);
-x_14 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18(x_1, x_10, x_11, x_4, x_12, x_13, x_7, x_8, x_9);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_14;
+return x_12;
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_8; uint8_t x_9; uint8_t x_10; lean_object* x_11; 
-x_8 = lean_unbox(x_2);
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_3);
+lean_dec(x_3);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(x_1, x_2, x_7, x_8, x_5, x_6);
 lean_dec(x_2);
+lean_dec(x_1);
+return x_9;
+}
+}
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
 x_9 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = lean_unbox(x_4);
-lean_dec(x_4);
-x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(x_1, x_8, x_9, x_10, x_5, x_6, x_7);
+x_10 = lean_unbox(x_5);
+lean_dec(x_5);
+x_11 = lean_unbox(x_6);
+lean_dec(x_6);
+x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_11;
+return x_12;
 }
 }
-lean_object* l_Lean_Parser_Term_matchAlts___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_3);
+lean_dec(x_3);
+x_8 = lean_unbox(x_4);
+lean_dec(x_4);
+x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(x_1, x_2, x_7, x_8, x_5, x_6);
+lean_dec(x_2);
 lean_dec(x_1);
-x_6 = l_Lean_Parser_Term_matchAlts___elambda__1(x_5, x_2, x_3, x_4);
-return x_6;
+return x_9;
+}
+}
+lean_object* l_Lean_Parser_Term_matchAlts___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; lean_object* x_5; 
+x_4 = lean_unbox(x_1);
+lean_dec(x_1);
+x_5 = l_Lean_Parser_Term_matchAlts___elambda__1(x_4, x_2, x_3);
+return x_5;
 }
 }
 lean_object* l_Lean_Parser_Term_matchAlts___boxed(lean_object* x_1) {
@@ -22843,13 +22455,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_match___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_match___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_match___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_match___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_match___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_match___elambda__1___closed__5() {
@@ -22959,267 +22570,256 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_match___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_match___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_match___elambda__1___closed__9;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_match___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_Term_match___elambda__1___closed__9;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Term_match___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_64; lean_object* x_65; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_64 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_65 = lean_ctor_get(x_64, 3);
-lean_inc(x_65);
-if (lean_obj_tag(x_65) == 0)
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_62; lean_object* x_63; 
+lean_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+lean_inc(x_1);
+x_62 = l_Lean_Parser_tokenFn(x_1, x_15);
+x_63 = lean_ctor_get(x_62, 3);
+lean_inc(x_63);
+if (lean_obj_tag(x_63) == 0)
 {
-lean_object* x_66; lean_object* x_67; 
-x_66 = lean_ctor_get(x_64, 0);
+lean_object* x_64; lean_object* x_65; 
+x_64 = lean_ctor_get(x_62, 0);
+lean_inc(x_64);
+x_65 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_64);
+lean_dec(x_64);
+if (lean_obj_tag(x_65) == 2)
+{
+lean_object* x_66; lean_object* x_67; uint8_t x_68; 
+x_66 = lean_ctor_get(x_65, 1);
 lean_inc(x_66);
-x_67 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_66);
+lean_dec(x_65);
+x_67 = l_Lean_Parser_Term_match___elambda__1___closed__6;
+x_68 = lean_string_dec_eq(x_66, x_67);
 lean_dec(x_66);
-if (lean_obj_tag(x_67) == 2)
+if (x_68 == 0)
 {
-lean_object* x_68; lean_object* x_69; uint8_t x_70; 
-x_68 = lean_ctor_get(x_67, 1);
-lean_inc(x_68);
-lean_dec(x_67);
-x_69 = l_Lean_Parser_Term_match___elambda__1___closed__6;
-x_70 = lean_string_dec_eq(x_68, x_69);
-lean_dec(x_68);
-if (x_70 == 0)
+lean_object* x_69; lean_object* x_70; 
+x_69 = l_Lean_Parser_Term_match___elambda__1___closed__15;
+lean_inc(x_9);
+x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_69, x_9);
+x_18 = x_70;
+goto block_61;
+}
+else
+{
+x_18 = x_62;
+goto block_61;
+}
+}
+else
 {
 lean_object* x_71; lean_object* x_72; 
+lean_dec(x_65);
 x_71 = l_Lean_Parser_Term_match___elambda__1___closed__15;
-lean_inc(x_10);
-x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_10);
-x_19 = x_72;
-goto block_63;
-}
-else
-{
-x_19 = x_64;
-goto block_63;
+lean_inc(x_9);
+x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_71, x_9);
+x_18 = x_72;
+goto block_61;
 }
 }
 else
 {
 lean_object* x_73; lean_object* x_74; 
-lean_dec(x_67);
+lean_dec(x_63);
 x_73 = l_Lean_Parser_Term_match___elambda__1___closed__15;
-lean_inc(x_10);
-x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_10);
-x_19 = x_74;
-goto block_63;
+lean_inc(x_9);
+x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_73, x_9);
+x_18 = x_74;
+goto block_61;
 }
-}
-else
+block_61:
 {
-lean_object* x_75; lean_object* x_76; 
-lean_dec(x_65);
-x_75 = l_Lean_Parser_Term_match___elambda__1___closed__15;
-lean_inc(x_10);
-x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_10);
-x_19 = x_76;
-goto block_63;
-}
-block_63:
+lean_object* x_19; 
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+uint8_t x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = 0;
+lean_inc(x_1);
+x_21 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_20, x_20, x_1, x_18);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-uint8_t x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = 0;
-x_22 = 0;
-lean_inc(x_2);
-x_23 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_21, x_22, x_22, x_1, x_2, x_19);
+lean_object* x_23; lean_object* x_24; 
+lean_inc(x_1);
+x_23 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_21);
 x_24 = lean_ctor_get(x_23, 3);
 lean_inc(x_24);
 if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_25; lean_object* x_26; 
-lean_inc(x_2);
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_25 = lean_ctor_get(x_23, 1);
+lean_inc(x_25);
 lean_inc(x_1);
-x_25 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_2, x_23);
-x_26 = lean_ctor_get(x_25, 3);
-lean_inc(x_26);
-if (lean_obj_tag(x_26) == 0)
-{
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_27 = lean_ctor_get(x_25, 1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_23);
+x_27 = lean_ctor_get(x_26, 3);
 lean_inc(x_27);
-lean_inc(x_2);
-x_28 = l_Lean_Parser_tokenFn(x_2, x_25);
-x_29 = lean_ctor_get(x_28, 3);
-lean_inc(x_29);
-if (lean_obj_tag(x_29) == 0)
+if (lean_obj_tag(x_27) == 0)
 {
-lean_object* x_30; lean_object* x_31; 
-x_30 = lean_ctor_get(x_28, 0);
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
+lean_inc(x_28);
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
+lean_dec(x_28);
+if (lean_obj_tag(x_29) == 2)
+{
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
 lean_inc(x_30);
-x_31 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_30);
-lean_dec(x_30);
-if (lean_obj_tag(x_31) == 2)
-{
-lean_object* x_32; lean_object* x_33; uint8_t x_34; 
-x_32 = lean_ctor_get(x_31, 1);
-lean_inc(x_32);
-lean_dec(x_31);
-x_33 = l_Lean_Parser_Term_match___elambda__1___closed__8;
-x_34 = lean_string_dec_eq(x_32, x_33);
-lean_dec(x_32);
-if (x_34 == 0)
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_35 = l_Lean_Parser_Term_match___elambda__1___closed__12;
-x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_27);
-x_37 = l_Lean_Parser_Term_match___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_18);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_13, x_10);
-lean_dec(x_10);
-return x_39;
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_40 = lean_apply_3(x_5, x_1, x_2, x_28);
-x_41 = l_Lean_Parser_Term_match___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_18);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_13, x_10);
-lean_dec(x_10);
-return x_43;
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-lean_dec(x_31);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_44 = l_Lean_Parser_Term_match___elambda__1___closed__12;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_44, x_27);
-x_46 = l_Lean_Parser_Term_match___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_18);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_13, x_10);
-lean_dec(x_10);
-return x_48;
-}
-}
-else
-{
-lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
 lean_dec(x_29);
-lean_dec(x_5);
-lean_dec(x_2);
+x_31 = l_Lean_Parser_Term_match___elambda__1___closed__8;
+x_32 = lean_string_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
+{
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_4);
 lean_dec(x_1);
-x_49 = l_Lean_Parser_Term_match___elambda__1___closed__12;
-x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_49, x_27);
-x_51 = l_Lean_Parser_Term_match___elambda__1___closed__2;
-x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_18);
-x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_13, x_10);
-lean_dec(x_10);
-return x_53;
+x_33 = l_Lean_Parser_Term_match___elambda__1___closed__12;
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_25);
+x_35 = l_Lean_Parser_Term_match___elambda__1___closed__2;
+x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_17);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_12, x_9);
+lean_dec(x_9);
+return x_37;
+}
+else
+{
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_25);
+x_38 = lean_apply_2(x_4, x_1, x_26);
+x_39 = l_Lean_Parser_Term_match___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_17);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_12, x_9);
+lean_dec(x_9);
+return x_41;
 }
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-lean_dec(x_26);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_29);
+lean_dec(x_4);
 lean_dec(x_1);
-x_54 = l_Lean_Parser_Term_match___elambda__1___closed__2;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_25, x_54, x_18);
-x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_13, x_10);
-lean_dec(x_10);
-return x_56;
+x_42 = l_Lean_Parser_Term_match___elambda__1___closed__12;
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_42, x_25);
+x_44 = l_Lean_Parser_Term_match___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_17);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_12, x_9);
+lean_dec(x_9);
+return x_46;
 }
 }
 else
 {
-lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_27);
+lean_dec(x_4);
+lean_dec(x_1);
+x_47 = l_Lean_Parser_Term_match___elambda__1___closed__12;
+x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_47, x_25);
+x_49 = l_Lean_Parser_Term_match___elambda__1___closed__2;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_48, x_49, x_17);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_12, x_9);
+lean_dec(x_9);
+return x_51;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; 
 lean_dec(x_24);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-x_57 = l_Lean_Parser_Term_match___elambda__1___closed__2;
-x_58 = l_Lean_Parser_ParserState_mkNode(x_23, x_57, x_18);
-x_59 = l_Lean_Parser_mergeOrElseErrors(x_58, x_13, x_10);
-lean_dec(x_10);
-return x_59;
+x_52 = l_Lean_Parser_Term_match___elambda__1___closed__2;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_23, x_52, x_17);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_12, x_9);
+lean_dec(x_9);
+return x_54;
 }
 }
 else
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_dec(x_22);
+lean_dec(x_4);
 lean_dec(x_1);
-x_60 = l_Lean_Parser_Term_match___elambda__1___closed__2;
-x_61 = l_Lean_Parser_ParserState_mkNode(x_19, x_60, x_18);
-x_62 = l_Lean_Parser_mergeOrElseErrors(x_61, x_13, x_10);
-lean_dec(x_10);
-return x_62;
+x_55 = l_Lean_Parser_Term_match___elambda__1___closed__2;
+x_56 = l_Lean_Parser_ParserState_mkNode(x_21, x_55, x_17);
+x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_12, x_9);
+lean_dec(x_9);
+return x_57;
+}
+}
+else
+{
+lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+lean_dec(x_19);
+lean_dec(x_4);
+lean_dec(x_1);
+x_58 = l_Lean_Parser_Term_match___elambda__1___closed__2;
+x_59 = l_Lean_Parser_ParserState_mkNode(x_18, x_58, x_17);
+x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_12, x_9);
+lean_dec(x_9);
+return x_60;
 }
 }
 }
@@ -23316,7 +22916,7 @@ lean_object* _init_l_Lean_Parser_Term_match___closed__9() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_match___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_match___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -23343,10 +22943,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_match(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_match___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_match___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_match;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -23383,13 +22983,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_nomatch___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_nomatch___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_nomatch___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_nomatch___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_nomatch___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_nomatch___elambda__1___closed__5() {
@@ -23441,141 +23040,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_nomatch___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_nomatch___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_nomatch___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_nomatch___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_nomatch___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_nomatch___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -23596,7 +23195,7 @@ lean_object* _init_l_Lean_Parser_Term_nomatch___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_nomatch___closed__1;
@@ -23630,7 +23229,7 @@ lean_object* _init_l_Lean_Parser_Term_nomatch___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_nomatch___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_nomatch___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -23657,10 +23256,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_nomatch(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_nomatch;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -23697,13 +23296,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_parser_x21___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_parser_x21___elambda__1___closed__5() {
@@ -23755,141 +23353,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_parser_x21___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_parser_x21___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_parser_x21___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -23910,7 +23508,7 @@ lean_object* _init_l_Lean_Parser_Term_parser_x21___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_parser_x21___closed__1;
@@ -23944,7 +23542,7 @@ lean_object* _init_l_Lean_Parser_Term_parser_x21___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_parser_x21___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_parser_x21___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -23971,10 +23569,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_parser_x21(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_parser_x21;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -24011,13 +23609,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_tparser_x21___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_tparser_x21___elambda__1___closed__5() {
@@ -24069,141 +23666,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_tparser_x21___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -24224,7 +23821,7 @@ lean_object* _init_l_Lean_Parser_Term_tparser_x21___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_tparser_x21___closed__1;
@@ -24258,7 +23855,7 @@ lean_object* _init_l_Lean_Parser_Term_tparser_x21___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tparser_x21___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tparser_x21___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -24285,10 +23882,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_tparser_x21(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_tparser_x21;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -24325,13 +23922,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_borrowed___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_borrowed___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_borrowed___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_borrowed___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_borrowed___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_borrowed___elambda__1___closed__5() {
@@ -24393,141 +23989,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_borrowed___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_borrowed___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_borrowed___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_borrowed___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_borrowed___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_borrowed___elambda__1___closed__10;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_borrowed___elambda__1___closed__10;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_borrowed___elambda__1___closed__10;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_borrowed___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = l_Lean_Parser_Term_borrowed___elambda__1___closed__7;
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_borrowed___elambda__1___closed__10;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_borrowed___elambda__1___closed__10;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_borrowed___elambda__1___closed__10;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = l_Lean_Parser_Term_borrowed___elambda__1___closed__7;
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -24547,12 +24143,11 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Term_borrowed___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_termParser___closed__2;
-x_3 = l_Lean_Parser_Term_borrowed___elambda__1___closed__7;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_termParser___closed__2;
+x_2 = l_Lean_Parser_Term_borrowed___elambda__1___closed__7;
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_borrowed___closed__3() {
@@ -24593,7 +24188,7 @@ lean_object* _init_l_Lean_Parser_Term_borrowed___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_borrowed___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_borrowed___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -24620,10 +24215,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_borrowed(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_borrowed;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -24660,90 +24255,72 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_quotedName___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_quotedName___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_quotedName___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_quotedName___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_quotedName___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_quotedName___elambda__1___closed__5() {
+lean_object* l_Lean_Parser_Term_quotedName___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 0;
-x_2 = l_Lean_Parser_nameLit(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Term_quotedName___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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_quotedName___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_quotedName___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_quotedName___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
 {
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
-lean_dec(x_13);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-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_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
 lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-x_19 = lean_apply_3(x_5, x_1, x_2, x_16);
-x_20 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_18);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_13, x_10);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+x_12 = lean_nat_dec_eq(x_11, x_7);
+lean_dec(x_11);
+if (x_12 == 0)
+{
 lean_dec(x_10);
-return x_22;
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_nameLit___elambda__1(x_1, x_13);
+x_17 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2;
+x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_15);
+x_19 = l_Lean_Parser_mergeOrElseErrors(x_18, x_10, x_7);
+lean_dec(x_7);
+return x_19;
 }
 }
 }
@@ -24752,7 +24329,7 @@ lean_object* _init_l_Lean_Parser_Term_quotedName___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_quotedName___elambda__1___closed__5;
+x_1 = l_Lean_Parser_nameLit;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2;
@@ -24776,7 +24353,7 @@ lean_object* _init_l_Lean_Parser_Term_quotedName___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_quotedName___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_quotedName___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -24803,10 +24380,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_quotedName(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_quotedName;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -24815,13 +24392,12 @@ return x_6;
 lean_object* _init_l_Lean_Parser_Term_antiquot___closed__1() {
 _start:
 {
-lean_object* x_1; uint8_t x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
 x_1 = lean_box(0);
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_2, x_3, x_1, x_4);
-return x_5;
+x_2 = l_Lean_Parser_termParser___closed__1;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_2, x_1, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_antiquot() {
@@ -24845,10 +24421,10 @@ return x_3;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_antiquot(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l___regBuiltinParser_Lean_Parser_Term_antiquot___closed__1;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l___regBuiltinParser_Lean_Parser_Term_antiquot___closed__1;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_antiquot;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -24885,13 +24461,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_match__syntax___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_match__syntax___elambda__1___closed__5() {
@@ -24935,245 +24510,237 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_match__syntax___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_match__syntax___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; 
-x_4 = l_Lean_Parser_Term_match___elambda__1___closed__9;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
+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; 
+x_3 = l_Lean_Parser_Term_match___elambda__1___closed__9;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__4;
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 0);
 lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
-lean_inc(x_2);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-x_12 = lean_ctor_get(x_11, 3);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+x_11 = lean_ctor_get(x_10, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_10;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; 
-x_13 = lean_ctor_get(x_12, 0);
+lean_dec(x_11);
+x_13 = lean_ctor_get(x_10, 1);
 lean_inc(x_13);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-x_15 = lean_nat_dec_eq(x_14, x_10);
-lean_dec(x_14);
-if (x_15 == 0)
-{
+x_14 = lean_nat_dec_eq(x_13, x_9);
 lean_dec(x_13);
-lean_dec(x_10);
+if (x_14 == 0)
+{
+lean_dec(x_12);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_11;
+return x_10;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_59; lean_object* x_60; 
-lean_inc(x_10);
-x_16 = l_Lean_Parser_ParserState_restore(x_11, x_9, x_10);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-x_18 = lean_array_get_size(x_17);
-lean_dec(x_17);
-lean_inc(x_2);
-x_59 = l_Lean_Parser_tokenFn(x_2, x_16);
-x_60 = lean_ctor_get(x_59, 3);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_58; lean_object* x_59; 
+lean_inc(x_9);
+x_15 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_array_get_size(x_16);
+lean_dec(x_16);
+lean_inc(x_1);
+x_58 = l_Lean_Parser_tokenFn(x_1, x_15);
+x_59 = lean_ctor_get(x_58, 3);
+lean_inc(x_59);
+if (lean_obj_tag(x_59) == 0)
+{
+lean_object* x_60; lean_object* x_61; 
+x_60 = lean_ctor_get(x_58, 0);
 lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
-{
-lean_object* x_61; lean_object* x_62; 
-x_61 = lean_ctor_get(x_59, 0);
-lean_inc(x_61);
-x_62 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_61);
-lean_dec(x_61);
-if (lean_obj_tag(x_62) == 2)
-{
-lean_object* x_63; lean_object* x_64; uint8_t x_65; 
-x_63 = lean_ctor_get(x_62, 1);
-lean_inc(x_63);
-lean_dec(x_62);
-x_64 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__5;
-x_65 = lean_string_dec_eq(x_63, x_64);
-lean_dec(x_63);
-if (x_65 == 0)
-{
-lean_object* x_66; lean_object* x_67; 
-x_66 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8;
-lean_inc(x_10);
-x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_59, x_66, x_10);
-x_19 = x_67;
-goto block_58;
-}
-else
-{
-x_19 = x_59;
-goto block_58;
-}
-}
-else
-{
-lean_object* x_68; lean_object* x_69; 
-lean_dec(x_62);
-x_68 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8;
-lean_inc(x_10);
-x_69 = l_Lean_Parser_ParserState_mkErrorsAt(x_59, x_68, x_10);
-x_19 = x_69;
-goto block_58;
-}
-}
-else
-{
-lean_object* x_70; lean_object* x_71; 
+x_61 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_60);
 lean_dec(x_60);
-x_70 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8;
-lean_inc(x_10);
-x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_59, x_70, x_10);
-x_19 = x_71;
-goto block_58;
+if (lean_obj_tag(x_61) == 2)
+{
+lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_62 = lean_ctor_get(x_61, 1);
+lean_inc(x_62);
+lean_dec(x_61);
+x_63 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__5;
+x_64 = lean_string_dec_eq(x_62, x_63);
+lean_dec(x_62);
+if (x_64 == 0)
+{
+lean_object* x_65; lean_object* x_66; 
+x_65 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8;
+lean_inc(x_9);
+x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_58, x_65, x_9);
+x_18 = x_66;
+goto block_57;
 }
-block_58:
+else
 {
-lean_object* x_20; 
-x_20 = lean_ctor_get(x_19, 3);
-lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+x_18 = x_58;
+goto block_57;
+}
+}
+else
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = l_Lean_Parser_termParser___closed__2;
-x_22 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_23 = l_Lean_Parser_categoryParserFn(x_21, x_22, x_2, x_19);
-x_24 = lean_ctor_get(x_23, 3);
+lean_object* x_67; lean_object* x_68; 
+lean_dec(x_61);
+x_67 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8;
+lean_inc(x_9);
+x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_58, x_67, x_9);
+x_18 = x_68;
+goto block_57;
+}
+}
+else
+{
+lean_object* x_69; lean_object* x_70; 
+lean_dec(x_59);
+x_69 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8;
+lean_inc(x_9);
+x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_58, x_69, x_9);
+x_18 = x_70;
+goto block_57;
+}
+block_57:
+{
+lean_object* x_19; 
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_20 = l_Lean_Parser_termParser___closed__2;
+x_21 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_22 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_21, x_1, x_18);
+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; 
+x_24 = lean_ctor_get(x_22, 1);
 lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
+lean_inc(x_1);
+x_25 = l_Lean_Parser_tokenFn(x_1, x_22);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_25 = lean_ctor_get(x_23, 1);
-lean_inc(x_25);
-lean_inc(x_2);
-x_26 = l_Lean_Parser_tokenFn(x_2, x_23);
-x_27 = lean_ctor_get(x_26, 3);
+lean_object* x_27; lean_object* x_28; 
+x_27 = lean_ctor_get(x_25, 0);
 lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; lean_object* x_29; 
-x_28 = lean_ctor_get(x_26, 0);
-lean_inc(x_28);
-x_29 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_28);
-lean_dec(x_28);
-if (lean_obj_tag(x_29) == 2)
-{
-lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_30 = lean_ctor_get(x_29, 1);
-lean_inc(x_30);
-lean_dec(x_29);
-x_31 = l_Lean_Parser_Term_match___elambda__1___closed__8;
-x_32 = lean_string_dec_eq(x_30, x_31);
-lean_dec(x_30);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_33 = l_Lean_Parser_Term_match___elambda__1___closed__12;
-x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_25);
-x_35 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
-x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_18);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_13, x_10);
-lean_dec(x_10);
-return x_37;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_25);
-x_38 = lean_apply_3(x_5, x_1, x_2, x_26);
-x_39 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_18);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_13, x_10);
-lean_dec(x_10);
-return x_41;
-}
-}
-else
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-lean_dec(x_29);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_42 = l_Lean_Parser_Term_match___elambda__1___closed__12;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_42, x_25);
-x_44 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_18);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_13, x_10);
-lean_dec(x_10);
-return x_46;
-}
-}
-else
-{
-lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+x_28 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_27);
 lean_dec(x_27);
-lean_dec(x_5);
-lean_dec(x_2);
+if (lean_obj_tag(x_28) == 2)
+{
+lean_object* x_29; lean_object* x_30; uint8_t x_31; 
+x_29 = lean_ctor_get(x_28, 1);
+lean_inc(x_29);
+lean_dec(x_28);
+x_30 = l_Lean_Parser_Term_match___elambda__1___closed__8;
+x_31 = lean_string_dec_eq(x_29, x_30);
+lean_dec(x_29);
+if (x_31 == 0)
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_4);
 lean_dec(x_1);
-x_47 = l_Lean_Parser_Term_match___elambda__1___closed__12;
-x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_47, x_25);
-x_49 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_48, x_49, x_18);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_13, x_10);
-lean_dec(x_10);
-return x_51;
-}
+x_32 = l_Lean_Parser_Term_match___elambda__1___closed__12;
+x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_32, x_24);
+x_34 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_17);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_12, x_9);
+lean_dec(x_9);
+return x_36;
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
 lean_dec(x_24);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_52 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_23, x_52, x_18);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_13, x_10);
-lean_dec(x_10);
-return x_54;
+x_37 = lean_apply_2(x_4, x_1, x_25);
+x_38 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_17);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_12, x_9);
+lean_dec(x_9);
+return x_40;
 }
 }
 else
 {
-lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-lean_dec(x_20);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_28);
+lean_dec(x_4);
 lean_dec(x_1);
-x_55 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
-x_56 = l_Lean_Parser_ParserState_mkNode(x_19, x_55, x_18);
-x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_13, x_10);
-lean_dec(x_10);
-return x_57;
+x_41 = l_Lean_Parser_Term_match___elambda__1___closed__12;
+x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_41, x_24);
+x_43 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
+x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_17);
+x_45 = l_Lean_Parser_mergeOrElseErrors(x_44, x_12, x_9);
+lean_dec(x_9);
+return x_45;
+}
+}
+else
+{
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_dec(x_26);
+lean_dec(x_4);
+lean_dec(x_1);
+x_46 = l_Lean_Parser_Term_match___elambda__1___closed__12;
+x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_25, x_46, x_24);
+x_48 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
+x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_17);
+x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_12, x_9);
+lean_dec(x_9);
+return x_50;
+}
+}
+else
+{
+lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+lean_dec(x_23);
+lean_dec(x_4);
+lean_dec(x_1);
+x_51 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
+x_52 = l_Lean_Parser_ParserState_mkNode(x_22, x_51, x_17);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_12, x_9);
+lean_dec(x_9);
+return x_53;
+}
+}
+else
+{
+lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+lean_dec(x_19);
+lean_dec(x_4);
+lean_dec(x_1);
+x_54 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
+x_55 = l_Lean_Parser_ParserState_mkNode(x_18, x_54, x_17);
+x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_12, x_9);
+lean_dec(x_9);
+return x_56;
 }
 }
 }
@@ -25194,7 +24761,7 @@ lean_object* _init_l_Lean_Parser_Term_match__syntax___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_match___closed__3;
@@ -25238,7 +24805,7 @@ lean_object* _init_l_Lean_Parser_Term_match__syntax___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_match__syntax___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_match__syntax___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -25265,10 +24832,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_match__syntax(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_match__syntax;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -25282,75 +24849,66 @@ x_1 = lean_mk_string("expected space before binders");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_letIdLhs___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_letIdLhs___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; 
-x_4 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-x_6 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
-lean_inc(x_7);
-lean_inc(x_2);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_3 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
 lean_inc(x_1);
-x_8 = lean_apply_3(x_7, x_1, x_2, x_3);
+x_5 = l_Lean_Parser_ident___elambda__1(x_1, x_2);
+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; 
+x_7 = l_Lean_Parser_Term_letIdLhs___elambda__1___closed__1;
+x_8 = l_Lean_Parser_checkWsBeforeFn(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; 
-x_10 = l_Lean_Parser_Term_letIdLhs___elambda__1___closed__1;
-x_11 = l_Lean_Parser_checkWsBeforeFn(x_10, x_2, x_8);
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_13 = lean_ctor_get(x_11, 0);
-lean_inc(x_13);
-x_14 = lean_array_get_size(x_13);
-lean_dec(x_13);
-x_15 = 0;
-lean_inc(x_2);
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_10 = lean_ctor_get(x_8, 0);
+lean_inc(x_10);
+x_11 = lean_array_get_size(x_10);
+lean_dec(x_10);
 lean_inc(x_1);
-x_16 = l_Lean_Parser_manyAux___main(x_15, x_5, x_1, x_2, x_11);
-x_17 = l_Lean_nullKind;
-x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_14);
-x_19 = lean_ctor_get(x_18, 3);
-lean_inc(x_19);
-if (lean_obj_tag(x_19) == 0)
+x_12 = l_Lean_Parser_manyAux___main(x_4, x_1, x_8);
+x_13 = l_Lean_nullKind;
+x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_11);
+x_15 = lean_ctor_get(x_14, 3);
+lean_inc(x_15);
+if (lean_obj_tag(x_15) == 0)
 {
-lean_object* x_20; 
-x_20 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_2, x_18);
-return x_20;
+lean_object* x_16; 
+x_16 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_14);
+return x_16;
 }
 else
 {
-lean_dec(x_19);
-lean_dec(x_2);
+lean_dec(x_15);
 lean_dec(x_1);
-return x_18;
-}
-}
-else
-{
-lean_dec(x_12);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
+return x_14;
 }
 }
 else
 {
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
 return x_8;
 }
 }
+else
+{
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_5;
+}
+}
 }
 lean_object* _init_l_Lean_Parser_Term_letIdLhs___closed__1() {
 _start:
@@ -25389,7 +24947,7 @@ lean_object* _init_l_Lean_Parser_Term_letIdLhs___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_letIdLhs___closed__3;
@@ -25401,7 +24959,7 @@ lean_object* _init_l_Lean_Parser_Term_letIdLhs___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_letIdLhs___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_letIdLhs___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -25448,7 +25006,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___rarg___boxed), 4, 1);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
@@ -25471,7 +25029,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_letIdLhs___closed__5;
 x_2 = l_Lean_Parser_Term_letIdDecl___closed__3;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);
 return x_3;
@@ -25482,7 +25040,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_Parser_Term_letIdDecl___closed__5;
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn___rarg), 4, 1);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_tryFn), 3, 1);
 lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
@@ -25491,7 +25049,7 @@ lean_object* _init_l_Lean_Parser_Term_letIdDecl___closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_letIdDecl___closed__4;
@@ -25504,8 +25062,8 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_letIdDecl___closed__6;
-x_2 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__4;
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn___rarg), 5, 2);
+x_2 = l_Lean_Parser_Term_matchAlt___closed__4;
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);
 return x_3;
@@ -25526,13 +25084,12 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Term_letIdDecl___closed__10() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_letIdDecl___closed__1;
-x_3 = l_Lean_Parser_Term_letIdDecl___closed__2;
-x_4 = l_Lean_Parser_Term_letIdDecl___closed__9;
-x_5 = l_Lean_Parser_nodeWithAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_letIdDecl___closed__1;
+x_2 = l_Lean_Parser_Term_letIdDecl___closed__2;
+x_3 = l_Lean_Parser_Term_letIdDecl___closed__9;
+x_4 = l_Lean_Parser_nodeWithAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_letIdDecl() {
@@ -25543,228 +25100,226 @@ x_1 = l_Lean_Parser_Term_letIdDecl___closed__10;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_letPatDecl___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_letPatDecl___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_4 = lean_ctor_get(x_3, 0);
+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_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+x_3 = lean_ctor_get(x_2, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_2, 1);
 lean_inc(x_4);
-x_5 = lean_ctor_get(x_3, 1);
-lean_inc(x_5);
-x_6 = lean_array_get_size(x_4);
-lean_dec(x_4);
-x_24 = l_Lean_Parser_termParser___closed__2;
-x_25 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_26 = l_Lean_Parser_categoryParserFn(x_24, x_25, x_2, x_3);
-x_27 = lean_ctor_get(x_26, 3);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
+x_5 = lean_array_get_size(x_3);
+lean_dec(x_3);
+x_23 = l_Lean_Parser_termParser___closed__2;
+x_24 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_25 = l_Lean_Parser_categoryParser___elambda__1(x_23, x_24, x_1, x_2);
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Lean_Parser_pushNone___elambda__1___rarg(x_26);
-x_29 = lean_ctor_get(x_28, 3);
-lean_inc(x_29);
-if (lean_obj_tag(x_29) == 0)
+lean_object* x_27; lean_object* x_28; 
+x_27 = l_Lean_Parser_pushNone___elambda__1___rarg(x_25);
+x_28 = lean_ctor_get(x_27, 3);
+lean_inc(x_28);
+if (lean_obj_tag(x_28) == 0)
 {
-lean_object* x_30; lean_object* x_31; 
-lean_inc(x_2);
-x_30 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_2, x_28);
-x_31 = lean_ctor_get(x_30, 3);
+lean_object* x_29; lean_object* x_30; 
+lean_inc(x_1);
+x_29 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_27);
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_31 = lean_ctor_get(x_29, 1);
 lean_inc(x_31);
-if (lean_obj_tag(x_31) == 0)
+lean_inc(x_1);
+x_32 = l_Lean_Parser_tokenFn(x_1, x_29);
+x_33 = lean_ctor_get(x_32, 3);
+lean_inc(x_33);
+if (lean_obj_tag(x_33) == 0)
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_32 = lean_ctor_get(x_30, 1);
-lean_inc(x_32);
-lean_inc(x_2);
-x_33 = l_Lean_Parser_tokenFn(x_2, x_30);
-x_34 = lean_ctor_get(x_33, 3);
+lean_object* x_34; lean_object* x_35; 
+x_34 = lean_ctor_get(x_32, 0);
 lean_inc(x_34);
-if (lean_obj_tag(x_34) == 0)
+x_35 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_34);
+lean_dec(x_34);
+if (lean_obj_tag(x_35) == 2)
 {
-lean_object* x_35; lean_object* x_36; 
-x_35 = lean_ctor_get(x_33, 0);
-lean_inc(x_35);
-x_36 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_35);
+lean_object* x_36; lean_object* x_37; uint8_t x_38; 
+x_36 = lean_ctor_get(x_35, 1);
+lean_inc(x_36);
 lean_dec(x_35);
-if (lean_obj_tag(x_36) == 2)
-{
-lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_37 = lean_ctor_get(x_36, 1);
-lean_inc(x_37);
+x_37 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
+x_38 = lean_string_dec_eq(x_36, x_37);
 lean_dec(x_36);
-x_38 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_39 = lean_string_dec_eq(x_37, x_38);
-lean_dec(x_37);
-if (x_39 == 0)
+if (x_38 == 0)
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_40 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_40, x_32);
-x_42 = lean_ctor_get(x_41, 0);
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_39 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_39, x_31);
+x_41 = lean_ctor_get(x_40, 0);
+lean_inc(x_41);
+x_42 = lean_ctor_get(x_40, 2);
 lean_inc(x_42);
-x_43 = lean_ctor_get(x_41, 2);
+x_43 = lean_ctor_get(x_40, 3);
 lean_inc(x_43);
-x_44 = lean_ctor_get(x_41, 3);
-lean_inc(x_44);
+x_6 = x_40;
 x_7 = x_41;
 x_8 = x_42;
 x_9 = x_43;
-x_10 = x_44;
-goto block_23;
+goto block_22;
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_dec(x_32);
-x_45 = lean_ctor_get(x_33, 0);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_31);
+x_44 = lean_ctor_get(x_32, 0);
+lean_inc(x_44);
+x_45 = lean_ctor_get(x_32, 2);
 lean_inc(x_45);
-x_46 = lean_ctor_get(x_33, 2);
+x_46 = lean_ctor_get(x_32, 3);
 lean_inc(x_46);
-x_47 = lean_ctor_get(x_33, 3);
-lean_inc(x_47);
-x_7 = x_33;
+x_6 = x_32;
+x_7 = x_44;
 x_8 = x_45;
 x_9 = x_46;
-x_10 = x_47;
-goto block_23;
+goto block_22;
 }
 }
 else
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_36);
-x_48 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_48, x_32);
-x_50 = lean_ctor_get(x_49, 0);
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_35);
+x_47 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_47, x_31);
+x_49 = lean_ctor_get(x_48, 0);
+lean_inc(x_49);
+x_50 = lean_ctor_get(x_48, 2);
 lean_inc(x_50);
-x_51 = lean_ctor_get(x_49, 2);
+x_51 = lean_ctor_get(x_48, 3);
 lean_inc(x_51);
-x_52 = lean_ctor_get(x_49, 3);
-lean_inc(x_52);
+x_6 = x_48;
 x_7 = x_49;
 x_8 = x_50;
 x_9 = x_51;
-x_10 = x_52;
-goto block_23;
+goto block_22;
 }
 }
 else
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-lean_dec(x_34);
-x_53 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_33, x_53, x_32);
-x_55 = lean_ctor_get(x_54, 0);
+lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
+lean_dec(x_33);
+x_52 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_52, x_31);
+x_54 = lean_ctor_get(x_53, 0);
+lean_inc(x_54);
+x_55 = lean_ctor_get(x_53, 2);
 lean_inc(x_55);
-x_56 = lean_ctor_get(x_54, 2);
+x_56 = lean_ctor_get(x_53, 3);
 lean_inc(x_56);
-x_57 = lean_ctor_get(x_54, 3);
-lean_inc(x_57);
+x_6 = x_53;
 x_7 = x_54;
 x_8 = x_55;
 x_9 = x_56;
-x_10 = x_57;
-goto block_23;
+goto block_22;
 }
 }
 else
 {
-lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-lean_dec(x_31);
-x_58 = lean_ctor_get(x_30, 0);
+lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+lean_dec(x_30);
+x_57 = lean_ctor_get(x_29, 0);
+lean_inc(x_57);
+x_58 = lean_ctor_get(x_29, 2);
 lean_inc(x_58);
-x_59 = lean_ctor_get(x_30, 2);
+x_59 = lean_ctor_get(x_29, 3);
 lean_inc(x_59);
-x_60 = lean_ctor_get(x_30, 3);
-lean_inc(x_60);
-x_7 = x_30;
+x_6 = x_29;
+x_7 = x_57;
 x_8 = x_58;
 x_9 = x_59;
-x_10 = x_60;
-goto block_23;
+goto block_22;
 }
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-lean_dec(x_29);
-lean_dec(x_1);
-x_61 = lean_ctor_get(x_28, 0);
+lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+lean_dec(x_28);
+x_60 = lean_ctor_get(x_27, 0);
+lean_inc(x_60);
+x_61 = lean_ctor_get(x_27, 2);
 lean_inc(x_61);
-x_62 = lean_ctor_get(x_28, 2);
+x_62 = lean_ctor_get(x_27, 3);
 lean_inc(x_62);
-x_63 = lean_ctor_get(x_28, 3);
-lean_inc(x_63);
-x_7 = x_28;
+x_6 = x_27;
+x_7 = x_60;
 x_8 = x_61;
 x_9 = x_62;
-x_10 = x_63;
-goto block_23;
+goto block_22;
 }
 }
 else
 {
-lean_object* x_64; lean_object* x_65; lean_object* x_66; 
-lean_dec(x_27);
-lean_dec(x_1);
-x_64 = lean_ctor_get(x_26, 0);
+lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_26);
+x_63 = lean_ctor_get(x_25, 0);
+lean_inc(x_63);
+x_64 = lean_ctor_get(x_25, 2);
 lean_inc(x_64);
-x_65 = lean_ctor_get(x_26, 2);
+x_65 = lean_ctor_get(x_25, 3);
 lean_inc(x_65);
-x_66 = lean_ctor_get(x_26, 3);
-lean_inc(x_66);
-x_7 = x_26;
+x_6 = x_25;
+x_7 = x_63;
 x_8 = x_64;
 x_9 = x_65;
-x_10 = x_66;
-goto block_23;
+goto block_22;
 }
-block_23:
+block_22:
 {
+if (lean_obj_tag(x_9) == 0)
+{
+lean_object* x_10; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_4);
+x_10 = lean_ctor_get(x_6, 3);
+lean_inc(x_10);
 if (lean_obj_tag(x_10) == 0)
 {
-lean_object* x_11; 
-lean_dec(x_9);
-lean_dec(x_8);
-lean_dec(x_5);
-x_11 = lean_ctor_get(x_7, 3);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_12 = l_Lean_Parser_termParser___closed__2;
-x_13 = lean_unsigned_to_nat(0u);
-x_14 = l_Lean_Parser_categoryParserFn(x_12, x_13, x_2, x_7);
-x_15 = l_Lean_Parser_Term_letIdDecl___closed__2;
-x_16 = l_Lean_Parser_ParserState_mkNode(x_14, x_15, x_6);
-return x_16;
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_11 = l_Lean_Parser_termParser___closed__2;
+x_12 = lean_unsigned_to_nat(0u);
+x_13 = l_Lean_Parser_categoryParser___elambda__1(x_11, x_12, x_1, x_6);
+x_14 = l_Lean_Parser_Term_letIdDecl___closed__2;
+x_15 = l_Lean_Parser_ParserState_mkNode(x_13, x_14, x_5);
+return x_15;
 }
 else
 {
-lean_object* x_17; lean_object* x_18; 
-lean_dec(x_11);
-lean_dec(x_2);
-x_17 = l_Lean_Parser_Term_letIdDecl___closed__2;
-x_18 = l_Lean_Parser_ParserState_mkNode(x_7, x_17, x_6);
-return x_18;
+lean_object* x_16; lean_object* x_17; 
+lean_dec(x_10);
+lean_dec(x_1);
+x_16 = l_Lean_Parser_Term_letIdDecl___closed__2;
+x_17 = l_Lean_Parser_ParserState_mkNode(x_6, x_16, x_5);
+return x_17;
 }
 }
 else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-lean_dec(x_7);
-lean_dec(x_2);
-x_19 = l_Array_shrink___main___rarg(x_8, x_6);
-x_20 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_20, 0, x_19);
-lean_ctor_set(x_20, 1, x_5);
-lean_ctor_set(x_20, 2, x_9);
-lean_ctor_set(x_20, 3, x_10);
-x_21 = l_Lean_Parser_Term_letIdDecl___closed__2;
-x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_6);
-return x_22;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+lean_dec(x_6);
+lean_dec(x_1);
+x_18 = l_Array_shrink___main___rarg(x_7, x_5);
+x_19 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_19, 0, x_18);
+lean_ctor_set(x_19, 1, x_4);
+lean_ctor_set(x_19, 2, x_8);
+lean_ctor_set(x_19, 3, x_9);
+x_20 = l_Lean_Parser_Term_letIdDecl___closed__2;
+x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_5);
+return x_21;
 }
 }
 }
@@ -25785,7 +25340,7 @@ lean_object* _init_l_Lean_Parser_Term_letPatDecl___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_mkAntiquotAux___closed__21;
+x_1 = l_Lean_Parser_pushNone;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_letPatDecl___closed__1;
@@ -25797,7 +25352,7 @@ lean_object* _init_l_Lean_Parser_Term_letPatDecl___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_letPatDecl___closed__2;
@@ -25809,7 +25364,7 @@ lean_object* _init_l_Lean_Parser_Term_letPatDecl___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_letPatDecl___closed__3;
@@ -25831,7 +25386,7 @@ lean_object* _init_l_Lean_Parser_Term_letPatDecl___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_letPatDecl___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_letPatDecl___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -25864,40 +25419,38 @@ x_2 = l_Lean_Parser_Term_matchAlts(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_Term_letEqnsDecl___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_letEqnsDecl___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; 
-x_4 = l_Lean_Parser_Term_letEqnsDecl___elambda__1___closed__1;
-x_5 = lean_ctor_get(x_4, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_3 = l_Lean_Parser_Term_letEqnsDecl___elambda__1___closed__1;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
 lean_inc(x_1);
-x_8 = l_Lean_Parser_Term_letIdLhs___elambda__1(x_1, x_2, x_3);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
+x_7 = l_Lean_Parser_Term_letIdLhs___elambda__1(x_1, x_2);
+x_8 = lean_ctor_get(x_7, 3);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_10 = lean_apply_3(x_5, x_1, x_2, x_8);
-x_11 = l_Lean_Parser_Term_letIdDecl___closed__2;
-x_12 = l_Lean_Parser_ParserState_mkNode(x_10, x_11, x_7);
-return x_12;
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_9 = lean_apply_2(x_4, x_1, x_7);
+x_10 = l_Lean_Parser_Term_letIdDecl___closed__2;
+x_11 = l_Lean_Parser_ParserState_mkNode(x_9, x_10, x_6);
+return x_11;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_object* x_12; lean_object* x_13; 
+lean_dec(x_8);
+lean_dec(x_4);
 lean_dec(x_1);
-x_13 = l_Lean_Parser_Term_letIdDecl___closed__2;
-x_14 = l_Lean_Parser_ParserState_mkNode(x_8, x_13, x_7);
-return x_14;
+x_12 = l_Lean_Parser_Term_letIdDecl___closed__2;
+x_13 = l_Lean_Parser_ParserState_mkNode(x_7, x_12, x_6);
+return x_13;
 }
 }
 }
@@ -25929,7 +25482,7 @@ lean_object* _init_l_Lean_Parser_Term_letEqnsDecl___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_letEqnsDecl___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_letEqnsDecl___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -25953,108 +25506,102 @@ x_1 = l_Lean_Parser_Term_letEqnsDecl___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_letDecl___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_letDecl___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_letIdDecl;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_letIdDecl;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
 lean_inc(x_1);
-x_17 = l_Lean_Parser_Term_letPatDecl___elambda__1(x_1, x_2, x_14);
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = l_Lean_Parser_Term_letPatDecl___elambda__1(x_1, x_13);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_19; 
-lean_dec(x_16);
-lean_dec(x_2);
+lean_object* x_18; 
+lean_dec(x_15);
 lean_dec(x_1);
-x_19 = l_Lean_Parser_mergeOrElseErrors(x_17, x_11, x_8);
-lean_dec(x_8);
-return x_19;
+x_18 = l_Lean_Parser_mergeOrElseErrors(x_16, x_10, x_7);
+lean_dec(x_7);
+return x_18;
 }
 else
 {
-lean_object* x_20; lean_object* x_21; uint8_t x_22; 
-x_20 = lean_ctor_get(x_18, 0);
+lean_object* x_19; lean_object* x_20; uint8_t x_21; 
+x_19 = lean_ctor_get(x_17, 0);
+lean_inc(x_19);
+lean_dec(x_17);
+x_20 = lean_ctor_get(x_16, 1);
 lean_inc(x_20);
-lean_dec(x_18);
-x_21 = lean_ctor_get(x_17, 1);
-lean_inc(x_21);
-x_22 = lean_nat_dec_eq(x_21, x_8);
-lean_dec(x_21);
-if (x_22 == 0)
-{
-lean_object* x_23; 
+x_21 = lean_nat_dec_eq(x_20, x_7);
 lean_dec(x_20);
-lean_dec(x_16);
-lean_dec(x_2);
+if (x_21 == 0)
+{
+lean_object* x_22; 
+lean_dec(x_19);
+lean_dec(x_15);
 lean_dec(x_1);
-x_23 = l_Lean_Parser_mergeOrElseErrors(x_17, x_11, x_8);
-lean_dec(x_8);
-return x_23;
+x_22 = l_Lean_Parser_mergeOrElseErrors(x_16, x_10, x_7);
+lean_dec(x_7);
+return x_22;
 }
 else
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_inc(x_8);
-x_24 = l_Lean_Parser_ParserState_restore(x_17, x_16, x_8);
-lean_dec(x_16);
-x_25 = l_Lean_Parser_Term_letEqnsDecl___elambda__1(x_1, x_2, x_24);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_20, x_8);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_inc(x_7);
+x_23 = l_Lean_Parser_ParserState_restore(x_16, x_15, x_7);
+lean_dec(x_15);
+x_24 = l_Lean_Parser_Term_letEqnsDecl___elambda__1(x_1, x_23);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_19, x_7);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -26091,7 +25638,7 @@ lean_object* _init_l_Lean_Parser_Term_letDecl___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_letDecl___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_letDecl___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -26146,13 +25693,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_let___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_let___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_let___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_let___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_let___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_let___elambda__1___closed__5() {
@@ -26204,231 +25750,227 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_let___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_let___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_let___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_let___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_57; lean_object* x_58; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_57 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_58 = lean_ctor_get(x_57, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_56; lean_object* x_57; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_56 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_57 = lean_ctor_get(x_56, 3);
+lean_inc(x_57);
+if (lean_obj_tag(x_57) == 0)
+{
+lean_object* x_58; lean_object* x_59; 
+x_58 = lean_ctor_get(x_56, 0);
 lean_inc(x_58);
-if (lean_obj_tag(x_58) == 0)
-{
-lean_object* x_59; lean_object* x_60; 
-x_59 = lean_ctor_get(x_57, 0);
-lean_inc(x_59);
-x_60 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_59);
-lean_dec(x_59);
-if (lean_obj_tag(x_60) == 2)
-{
-lean_object* x_61; lean_object* x_62; uint8_t x_63; 
-x_61 = lean_ctor_get(x_60, 1);
-lean_inc(x_61);
-lean_dec(x_60);
-x_62 = l_Lean_Parser_Term_let___elambda__1___closed__6;
-x_63 = lean_string_dec_eq(x_61, x_62);
-lean_dec(x_61);
-if (x_63 == 0)
-{
-lean_object* x_64; lean_object* x_65; 
-x_64 = l_Lean_Parser_Term_let___elambda__1___closed__9;
-lean_inc(x_8);
-x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_64, x_8);
-x_17 = x_65;
-goto block_56;
-}
-else
-{
-x_17 = x_57;
-goto block_56;
-}
-}
-else
-{
-lean_object* x_66; lean_object* x_67; 
-lean_dec(x_60);
-x_66 = l_Lean_Parser_Term_let___elambda__1___closed__9;
-lean_inc(x_8);
-x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_66, x_8);
-x_17 = x_67;
-goto block_56;
-}
-}
-else
-{
-lean_object* x_68; lean_object* x_69; 
+x_59 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_58);
 lean_dec(x_58);
-x_68 = l_Lean_Parser_Term_let___elambda__1___closed__9;
-lean_inc(x_8);
-x_69 = l_Lean_Parser_ParserState_mkErrorsAt(x_57, x_68, x_8);
-x_17 = x_69;
-goto block_56;
+if (lean_obj_tag(x_59) == 2)
+{
+lean_object* x_60; lean_object* x_61; uint8_t x_62; 
+x_60 = lean_ctor_get(x_59, 1);
+lean_inc(x_60);
+lean_dec(x_59);
+x_61 = l_Lean_Parser_Term_let___elambda__1___closed__6;
+x_62 = lean_string_dec_eq(x_60, x_61);
+lean_dec(x_60);
+if (x_62 == 0)
+{
+lean_object* x_63; lean_object* x_64; 
+x_63 = l_Lean_Parser_Term_let___elambda__1___closed__9;
+lean_inc(x_7);
+x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_7);
+x_16 = x_64;
+goto block_55;
 }
-block_56:
+else
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_56;
+goto block_55;
+}
+}
+else
 {
-lean_object* x_19; lean_object* x_20; 
-lean_inc(x_2);
-x_19 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_2, x_17);
-x_20 = lean_ctor_get(x_19, 3);
+lean_object* x_65; lean_object* x_66; 
+lean_dec(x_59);
+x_65 = l_Lean_Parser_Term_let___elambda__1___closed__9;
+lean_inc(x_7);
+x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_7);
+x_16 = x_66;
+goto block_55;
+}
+}
+else
+{
+lean_object* x_67; lean_object* x_68; 
+lean_dec(x_57);
+x_67 = l_Lean_Parser_Term_let___elambda__1___closed__9;
+lean_inc(x_7);
+x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_7);
+x_16 = x_68;
+goto block_55;
+}
+block_55:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; 
+lean_inc(x_1);
+x_18 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_16);
+x_19 = lean_ctor_get(x_18, 3);
+lean_inc(x_19);
+if (lean_obj_tag(x_19) == 0)
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-if (lean_obj_tag(x_20) == 0)
+lean_inc(x_1);
+x_21 = l_Lean_Parser_tokenFn(x_1, x_18);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_21 = lean_ctor_get(x_19, 1);
-lean_inc(x_21);
-lean_inc(x_2);
-x_22 = l_Lean_Parser_tokenFn(x_2, x_19);
-x_23 = lean_ctor_get(x_22, 3);
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_21, 0);
 lean_inc(x_23);
-if (lean_obj_tag(x_23) == 0)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_22, 0);
-lean_inc(x_24);
-x_25 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_24);
-lean_dec(x_24);
-if (lean_obj_tag(x_25) == 2)
-{
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_25, 1);
-lean_inc(x_26);
-lean_dec(x_25);
-x_27 = l_Lean_Parser_Term_have___elambda__1___closed__7;
-x_28 = lean_string_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-lean_dec(x_2);
-x_29 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
-x_31 = l_Lean_Parser_Term_let___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_16);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_11, x_8);
-lean_dec(x_8);
-return x_33;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-lean_dec(x_21);
-x_34 = l_Lean_Parser_termParser___closed__2;
-x_35 = lean_unsigned_to_nat(0u);
-x_36 = l_Lean_Parser_categoryParserFn(x_34, x_35, x_2, x_22);
-x_37 = l_Lean_Parser_Term_let___elambda__1___closed__2;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_16);
-x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_11, x_8);
-lean_dec(x_8);
-return x_39;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-lean_dec(x_25);
-lean_dec(x_2);
-x_40 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_40, x_21);
-x_42 = l_Lean_Parser_Term_let___elambda__1___closed__2;
-x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_16);
-x_44 = l_Lean_Parser_mergeOrElseErrors(x_43, x_11, x_8);
-lean_dec(x_8);
-return x_44;
-}
-}
-else
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_24 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_23);
 lean_dec(x_23);
-lean_dec(x_2);
-x_45 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_45, x_21);
-x_47 = l_Lean_Parser_Term_let___elambda__1___closed__2;
-x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_16);
-x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_11, x_8);
-lean_dec(x_8);
-return x_49;
-}
-}
-else
+if (lean_obj_tag(x_24) == 2)
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_50 = l_Lean_Parser_Term_let___elambda__1___closed__2;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_19, x_50, x_16);
-x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_11, x_8);
-lean_dec(x_8);
-return x_52;
-}
-}
-else
+lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_25 = lean_ctor_get(x_24, 1);
+lean_inc(x_25);
+lean_dec(x_24);
+x_26 = l_Lean_Parser_Term_have___elambda__1___closed__7;
+x_27 = lean_string_dec_eq(x_25, x_26);
+lean_dec(x_25);
+if (x_27 == 0)
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
 lean_dec(x_1);
-x_53 = l_Lean_Parser_Term_let___elambda__1___closed__2;
-x_54 = l_Lean_Parser_ParserState_mkNode(x_17, x_53, x_16);
-x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_11, x_8);
-lean_dec(x_8);
-return x_55;
+x_28 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20);
+x_30 = l_Lean_Parser_Term_let___elambda__1___closed__2;
+x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_15);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_10, x_7);
+lean_dec(x_7);
+return x_32;
+}
+else
+{
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_20);
+x_33 = l_Lean_Parser_termParser___closed__2;
+x_34 = lean_unsigned_to_nat(0u);
+x_35 = l_Lean_Parser_categoryParser___elambda__1(x_33, x_34, x_1, x_21);
+x_36 = l_Lean_Parser_Term_let___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_24);
+lean_dec(x_1);
+x_39 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_39, x_20);
+x_41 = l_Lean_Parser_Term_let___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_15);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_10, x_7);
+lean_dec(x_7);
+return x_43;
+}
+}
+else
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_22);
+lean_dec(x_1);
+x_44 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_44, x_20);
+x_46 = l_Lean_Parser_Term_let___elambda__1___closed__2;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_15);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_10, x_7);
+lean_dec(x_7);
+return x_48;
+}
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_19);
+lean_dec(x_1);
+x_49 = l_Lean_Parser_Term_let___elambda__1___closed__2;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_18, x_49, x_15);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_10, x_7);
+lean_dec(x_7);
+return x_51;
+}
+}
+else
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_52 = l_Lean_Parser_Term_let___elambda__1___closed__2;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_16, x_52, x_15);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_10, x_7);
+lean_dec(x_7);
+return x_54;
 }
 }
 }
@@ -26449,7 +25991,7 @@ lean_object* _init_l_Lean_Parser_Term_let___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_have___closed__3;
@@ -26505,7 +26047,7 @@ lean_object* _init_l_Lean_Parser_Term_let___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_let___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_let___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -26532,16 +26074,16 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_let(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_let___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_let___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_let;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -26549,16 +26091,16 @@ x_1 = lean_mk_string(" ← ");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__1;
+x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__1;
 x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__3() {
+lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -26566,93 +26108,85 @@ x_1 = lean_mk_string(" <- ");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__4() {
+lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__3;
+x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__3;
 x_2 = l_String_trim(x_1);
 return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__5() {
+lean_object* _init_l_Lean_Parser_Term_leftArrow___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_leftArrow___elambda__1___rarg___closed__2;
+x_2 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__2;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__6() {
+lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__5;
-x_2 = l_Lean_Parser_unicodeSymbolFn___rarg___closed__1;
+x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__5;
+x_2 = l_Lean_Parser_unicodeSymbolFn___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__7() {
+lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__6;
-x_2 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__4;
+x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__6;
+x_2 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__4;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__8() {
+lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__7;
+x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__7;
 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_leftArrow___elambda__1___rarg___closed__9() {
+lean_object* _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__9() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__8;
+x_2 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__8;
 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* l_Lean_Parser_Term_leftArrow___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Term_leftArrow___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_3 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__2;
-x_4 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__4;
-x_5 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__9;
+x_3 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__2;
+x_4 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__4;
+x_5 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__9;
 x_6 = l_Lean_Parser_unicodeSymbolFnAux(x_3, x_4, x_5, x_1, x_2);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Term_leftArrow___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Term_leftArrow___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__2;
-x_3 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__4;
+x_2 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__2;
+x_3 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__4;
 x_4 = l_Lean_Parser_unicodeSymbolInfo(x_2, x_3, x_1);
 return x_4;
 }
@@ -26661,7 +26195,7 @@ lean_object* _init_l_Lean_Parser_Term_leftArrow___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_leftArrow___elambda__1___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_leftArrow___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -26685,15 +26219,6 @@ x_1 = l_Lean_Parser_Term_leftArrow___closed__3;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_leftArrow___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Term_leftArrow___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Term_doLet___elambda__1___closed__1() {
 _start:
 {
@@ -26725,152 +26250,147 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_doLet___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_doLet___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_doLet___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_doLet___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_doLet___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_doLet___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_doLet___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_doLet___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_doLet___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_27; lean_object* x_28; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_27 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_28 = lean_ctor_get(x_27, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_26; lean_object* x_27; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_26 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_27 = lean_ctor_get(x_26, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
+{
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_26, 0);
 lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; lean_object* x_30; 
-x_29 = lean_ctor_get(x_27, 0);
-lean_inc(x_29);
-x_30 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_29);
-lean_dec(x_29);
-if (lean_obj_tag(x_30) == 2)
-{
-lean_object* x_31; lean_object* x_32; uint8_t x_33; 
-x_31 = lean_ctor_get(x_30, 1);
-lean_inc(x_31);
-lean_dec(x_30);
-x_32 = l_Lean_Parser_Term_let___elambda__1___closed__6;
-x_33 = lean_string_dec_eq(x_31, x_32);
-lean_dec(x_31);
-if (x_33 == 0)
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = l_Lean_Parser_Term_let___elambda__1___closed__9;
-lean_inc(x_8);
-x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_8);
-x_17 = x_35;
-goto block_26;
-}
-else
-{
-x_17 = x_27;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-lean_dec(x_30);
-x_36 = l_Lean_Parser_Term_let___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_36, x_8);
-x_17 = x_37;
-goto block_26;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
+x_29 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_28);
 lean_dec(x_28);
-x_38 = l_Lean_Parser_Term_let___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_38, x_8);
-x_17 = x_39;
-goto block_26;
-}
-block_26:
+if (lean_obj_tag(x_29) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 1);
+lean_inc(x_30);
+lean_dec(x_29);
+x_31 = l_Lean_Parser_Term_let___elambda__1___closed__6;
+x_32 = lean_string_dec_eq(x_30, x_31);
+lean_dec(x_30);
+if (x_32 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_2, x_17);
-x_20 = l_Lean_Parser_Term_doLet___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Lean_Parser_Term_let___elambda__1___closed__9;
+lean_inc(x_7);
+x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_33, x_7);
+x_16 = x_34;
+goto block_25;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-lean_dec(x_18);
-lean_dec(x_2);
+x_16 = x_26;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_29);
+x_35 = l_Lean_Parser_Term_let___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_35, x_7);
+x_16 = x_36;
+goto block_25;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_27);
+x_37 = l_Lean_Parser_Term_let___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_26, x_37, x_7);
+x_16 = x_38;
+goto block_25;
+}
+block_25:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_16);
+x_19 = l_Lean_Parser_Term_doLet___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
+lean_dec(x_7);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_17);
 lean_dec(x_1);
-x_23 = l_Lean_Parser_Term_doLet___elambda__1___closed__2;
-x_24 = l_Lean_Parser_ParserState_mkNode(x_17, x_23, x_16);
-x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_11, x_8);
-lean_dec(x_8);
-return x_25;
+x_22 = l_Lean_Parser_Term_doLet___elambda__1___closed__2;
+x_23 = l_Lean_Parser_ParserState_mkNode(x_16, x_22, x_15);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_10, x_7);
+lean_dec(x_7);
+return x_24;
 }
 }
 }
@@ -26915,7 +26435,7 @@ lean_object* _init_l_Lean_Parser_Term_doLet___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doLet___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doLet___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -26970,206 +26490,195 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_doId___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_doId___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_doId___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_doId___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_doId___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_doId___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_doId___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_doId___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_doId___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_8);
-lean_dec(x_8);
-lean_inc(x_3);
+x_6 = lean_ctor_get(x_2, 1);
+lean_inc(x_6);
+x_7 = lean_array_get_size(x_5);
+lean_dec(x_5);
 lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-if (lean_is_exclusive(x_3)) {
- lean_ctor_release(x_3, 0);
- lean_ctor_release(x_3, 1);
- lean_ctor_release(x_3, 2);
- lean_ctor_release(x_3, 3);
- x_12 = x_3;
+x_8 = lean_apply_2(x_4, x_1, x_2);
+if (lean_is_exclusive(x_2)) {
+ lean_ctor_release(x_2, 0);
+ lean_ctor_release(x_2, 1);
+ lean_ctor_release(x_2, 2);
+ lean_ctor_release(x_2, 3);
+ x_9 = x_2;
 } else {
- lean_dec_ref(x_3);
- x_12 = lean_box(0);
+ lean_dec_ref(x_2);
+ x_9 = lean_box(0);
 }
-x_13 = lean_ctor_get(x_11, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+x_10 = lean_ctor_get(x_8, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
 {
-lean_dec(x_12);
-lean_dec(x_10);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_11, 1);
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_8, 1);
+lean_inc(x_12);
+x_13 = lean_nat_dec_eq(x_12, x_6);
+lean_dec(x_12);
+if (x_13 == 0)
+{
+lean_dec(x_11);
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+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_37; lean_object* x_38; 
+lean_inc(x_6);
+x_14 = l_Lean_Parser_ParserState_restore(x_8, x_7, x_6);
+lean_dec(x_7);
+x_15 = lean_ctor_get(x_14, 0);
 lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_15, x_9);
+x_16 = lean_array_get_size(x_15);
 lean_dec(x_15);
-if (x_16 == 0)
+lean_inc(x_1);
+x_37 = l_Lean_Parser_ident___elambda__1(x_1, x_14);
+x_38 = lean_ctor_get(x_37, 3);
+lean_inc(x_38);
+if (lean_obj_tag(x_38) == 0)
 {
-lean_dec(x_14);
-lean_dec(x_12);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
+lean_object* x_39; lean_object* x_40; 
+lean_inc(x_1);
+x_39 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_37);
+x_40 = lean_ctor_get(x_39, 3);
+lean_inc(x_40);
+if (lean_obj_tag(x_40) == 0)
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+lean_inc(x_1);
+x_41 = l_Lean_Parser_Term_leftArrow___elambda__1(x_1, x_39);
+x_42 = lean_ctor_get(x_41, 0);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_41, 2);
+lean_inc(x_43);
+x_44 = lean_ctor_get(x_41, 3);
+lean_inc(x_44);
+x_17 = x_41;
+x_18 = x_42;
+x_19 = x_43;
+x_20 = x_44;
+goto block_36;
 }
 else
 {
-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_40; lean_object* x_41; 
-lean_inc(x_9);
-x_17 = l_Lean_Parser_ParserState_restore(x_11, x_10, x_9);
-lean_dec(x_10);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_array_get_size(x_18);
-lean_dec(x_18);
-lean_inc(x_2);
-lean_inc(x_1);
-x_40 = lean_apply_3(x_5, x_1, x_2, x_17);
-x_41 = lean_ctor_get(x_40, 3);
-lean_inc(x_41);
-if (lean_obj_tag(x_41) == 0)
-{
-lean_object* x_42; lean_object* x_43; 
-lean_inc(x_2);
-x_42 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_2, x_40);
-x_43 = lean_ctor_get(x_42, 3);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_inc(x_2);
-x_44 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg(x_2, x_42);
-x_45 = lean_ctor_get(x_44, 0);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_40);
+x_45 = lean_ctor_get(x_39, 0);
 lean_inc(x_45);
-x_46 = lean_ctor_get(x_44, 2);
+x_46 = lean_ctor_get(x_39, 2);
 lean_inc(x_46);
-x_47 = lean_ctor_get(x_44, 3);
+x_47 = lean_ctor_get(x_39, 3);
 lean_inc(x_47);
-x_20 = x_44;
-x_21 = x_45;
-x_22 = x_46;
-x_23 = x_47;
-goto block_39;
+x_17 = x_39;
+x_18 = x_45;
+x_19 = x_46;
+x_20 = x_47;
+goto block_36;
+}
 }
 else
 {
 lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-lean_dec(x_43);
-x_48 = lean_ctor_get(x_42, 0);
+lean_dec(x_38);
+x_48 = lean_ctor_get(x_37, 0);
 lean_inc(x_48);
-x_49 = lean_ctor_get(x_42, 2);
+x_49 = lean_ctor_get(x_37, 2);
 lean_inc(x_49);
-x_50 = lean_ctor_get(x_42, 3);
+x_50 = lean_ctor_get(x_37, 3);
 lean_inc(x_50);
-x_20 = x_42;
-x_21 = x_48;
-x_22 = x_49;
-x_23 = x_50;
-goto block_39;
+x_17 = x_37;
+x_18 = x_48;
+x_19 = x_49;
+x_20 = x_50;
+goto block_36;
 }
+block_36:
+{
+if (lean_obj_tag(x_20) == 0)
+{
+lean_object* x_21; 
+lean_dec(x_19);
+lean_dec(x_18);
+lean_dec(x_9);
+x_21 = lean_ctor_get(x_17, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+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 = l_Lean_Parser_termParser___closed__2;
+x_23 = lean_unsigned_to_nat(0u);
+x_24 = l_Lean_Parser_categoryParser___elambda__1(x_22, x_23, x_1, x_17);
+x_25 = l_Lean_Parser_Term_doId___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_16);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_6);
+lean_dec(x_6);
+return x_27;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_dec(x_41);
-lean_dec(x_1);
-x_51 = lean_ctor_get(x_40, 0);
-lean_inc(x_51);
-x_52 = lean_ctor_get(x_40, 2);
-lean_inc(x_52);
-x_53 = lean_ctor_get(x_40, 3);
-lean_inc(x_53);
-x_20 = x_40;
-x_21 = x_51;
-x_22 = x_52;
-x_23 = x_53;
-goto block_39;
-}
-block_39:
-{
-if (lean_obj_tag(x_23) == 0)
-{
-lean_object* x_24; 
-lean_dec(x_22);
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
 lean_dec(x_21);
-lean_dec(x_12);
-x_24 = lean_ctor_get(x_20, 3);
-lean_inc(x_24);
-if (lean_obj_tag(x_24) == 0)
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-x_25 = l_Lean_Parser_termParser___closed__2;
-x_26 = lean_unsigned_to_nat(0u);
-x_27 = l_Lean_Parser_categoryParserFn(x_25, x_26, x_2, x_20);
+lean_dec(x_1);
 x_28 = l_Lean_Parser_Term_doId___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_19);
-x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_14, x_9);
-lean_dec(x_9);
+x_29 = l_Lean_Parser_ParserState_mkNode(x_17, x_28, x_16);
+x_30 = l_Lean_Parser_mergeOrElseErrors(x_29, x_11, x_6);
+lean_dec(x_6);
 return x_30;
 }
-else
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-lean_dec(x_24);
-lean_dec(x_2);
-x_31 = l_Lean_Parser_Term_doId___elambda__1___closed__2;
-x_32 = l_Lean_Parser_ParserState_mkNode(x_20, x_31, x_19);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_14, x_9);
-lean_dec(x_9);
-return x_33;
-}
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_20);
-lean_dec(x_2);
-x_34 = l_Array_shrink___main___rarg(x_21, x_19);
-lean_inc(x_9);
-if (lean_is_scalar(x_12)) {
- x_35 = lean_alloc_ctor(0, 4, 0);
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_31 = l_Array_shrink___main___rarg(x_18, x_16);
+lean_inc(x_6);
+if (lean_is_scalar(x_9)) {
+ x_32 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_35 = x_12;
+ x_32 = x_9;
 }
-lean_ctor_set(x_35, 0, x_34);
-lean_ctor_set(x_35, 1, x_9);
-lean_ctor_set(x_35, 2, x_22);
-lean_ctor_set(x_35, 3, x_23);
-x_36 = l_Lean_Parser_Term_doId___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_19);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_14, x_9);
-lean_dec(x_9);
-return x_38;
+lean_ctor_set(x_32, 0, x_31);
+lean_ctor_set(x_32, 1, x_6);
+lean_ctor_set(x_32, 2, x_19);
+lean_ctor_set(x_32, 3, x_20);
+x_33 = l_Lean_Parser_Term_doId___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_6);
+lean_dec(x_6);
+return x_35;
 }
 }
 }
@@ -27194,7 +26703,7 @@ lean_object* _init_l_Lean_Parser_Term_doId___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_doId___closed__1;
@@ -27206,7 +26715,7 @@ lean_object* _init_l_Lean_Parser_Term_doId___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_doId___closed__2;
@@ -27240,7 +26749,7 @@ lean_object* _init_l_Lean_Parser_Term_doId___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doId___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doId___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -27295,13 +26804,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_doPat___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_doPat___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_doPat___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_doPat___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_doPat___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_doPat___elambda__1___closed__5() {
@@ -27353,359 +26861,359 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_doPat___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_doPat___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_doPat___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_doPat___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
+x_6 = lean_ctor_get(x_2, 1);
 lean_inc(x_6);
-x_7 = lean_ctor_get(x_3, 1);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_6);
+x_7 = lean_array_get_size(x_5);
+lean_dec(x_5);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_7);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_6);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-lean_inc(x_7);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_8, x_7);
-lean_dec(x_8);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_82 = l_Lean_Parser_termParser___closed__2;
-x_83 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_84 = l_Lean_Parser_categoryParserFn(x_82, x_83, x_2, x_14);
-x_85 = lean_ctor_get(x_84, 3);
-lean_inc(x_85);
-if (lean_obj_tag(x_85) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; 
+lean_inc(x_6);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_7, x_6);
+lean_dec(x_7);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_81 = l_Lean_Parser_termParser___closed__2;
+x_82 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_83 = l_Lean_Parser_categoryParser___elambda__1(x_81, x_82, x_1, x_13);
+x_84 = lean_ctor_get(x_83, 3);
+lean_inc(x_84);
+if (lean_obj_tag(x_84) == 0)
 {
-lean_object* x_86; lean_object* x_87; 
-lean_inc(x_2);
-x_86 = l_Lean_Parser_Term_leftArrow___elambda__1___rarg(x_2, x_84);
-x_87 = lean_ctor_get(x_86, 3);
-lean_inc(x_87);
-if (lean_obj_tag(x_87) == 0)
+lean_object* x_85; lean_object* x_86; 
+lean_inc(x_1);
+x_85 = l_Lean_Parser_Term_leftArrow___elambda__1(x_1, x_83);
+x_86 = lean_ctor_get(x_85, 3);
+lean_inc(x_86);
+if (lean_obj_tag(x_86) == 0)
 {
-x_17 = x_86;
-goto block_81;
+x_16 = x_85;
+goto block_80;
 }
 else
 {
-uint8_t x_88; 
-x_88 = !lean_is_exclusive(x_86);
-if (x_88 == 0)
+uint8_t x_87; 
+x_87 = !lean_is_exclusive(x_85);
+if (x_87 == 0)
 {
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-x_89 = lean_ctor_get(x_86, 0);
-x_90 = lean_ctor_get(x_86, 3);
+lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
+x_88 = lean_ctor_get(x_85, 0);
+x_89 = lean_ctor_get(x_85, 3);
+lean_dec(x_89);
+x_90 = lean_ctor_get(x_85, 1);
 lean_dec(x_90);
-x_91 = lean_ctor_get(x_86, 1);
-lean_dec(x_91);
-x_92 = l_Array_shrink___main___rarg(x_89, x_16);
-lean_inc(x_7);
-lean_ctor_set(x_86, 1, x_7);
-lean_ctor_set(x_86, 0, x_92);
-x_17 = x_86;
-goto block_81;
+x_91 = l_Array_shrink___main___rarg(x_88, x_15);
+lean_inc(x_6);
+lean_ctor_set(x_85, 1, x_6);
+lean_ctor_set(x_85, 0, x_91);
+x_16 = x_85;
+goto block_80;
 }
 else
 {
-lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; 
-x_93 = lean_ctor_get(x_86, 0);
-x_94 = lean_ctor_get(x_86, 2);
-lean_inc(x_94);
+lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+x_92 = lean_ctor_get(x_85, 0);
+x_93 = lean_ctor_get(x_85, 2);
 lean_inc(x_93);
-lean_dec(x_86);
-x_95 = l_Array_shrink___main___rarg(x_93, x_16);
-lean_inc(x_7);
-x_96 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_96, 0, x_95);
-lean_ctor_set(x_96, 1, x_7);
-lean_ctor_set(x_96, 2, x_94);
-lean_ctor_set(x_96, 3, x_87);
-x_17 = x_96;
-goto block_81;
-}
-}
-}
-else
-{
-lean_object* x_97; 
+lean_inc(x_92);
 lean_dec(x_85);
-x_97 = lean_ctor_get(x_84, 3);
-lean_inc(x_97);
-if (lean_obj_tag(x_97) == 0)
-{
-x_17 = x_84;
-goto block_81;
+x_94 = l_Array_shrink___main___rarg(x_92, x_15);
+lean_inc(x_6);
+x_95 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_95, 0, x_94);
+lean_ctor_set(x_95, 1, x_6);
+lean_ctor_set(x_95, 2, x_93);
+lean_ctor_set(x_95, 3, x_86);
+x_16 = x_95;
+goto block_80;
+}
+}
 }
 else
 {
-uint8_t x_98; 
-x_98 = !lean_is_exclusive(x_84);
-if (x_98 == 0)
-{
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; 
-x_99 = lean_ctor_get(x_84, 0);
-x_100 = lean_ctor_get(x_84, 3);
-lean_dec(x_100);
-x_101 = lean_ctor_get(x_84, 1);
-lean_dec(x_101);
-x_102 = l_Array_shrink___main___rarg(x_99, x_16);
-lean_inc(x_7);
-lean_ctor_set(x_84, 1, x_7);
-lean_ctor_set(x_84, 0, x_102);
-x_17 = x_84;
-goto block_81;
-}
-else
-{
-lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; 
-x_103 = lean_ctor_get(x_84, 0);
-x_104 = lean_ctor_get(x_84, 2);
-lean_inc(x_104);
-lean_inc(x_103);
+lean_object* x_96; 
 lean_dec(x_84);
-x_105 = l_Array_shrink___main___rarg(x_103, x_16);
-lean_inc(x_7);
-x_106 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_106, 0, x_105);
-lean_ctor_set(x_106, 1, x_7);
-lean_ctor_set(x_106, 2, x_104);
-lean_ctor_set(x_106, 3, x_97);
-x_17 = x_106;
-goto block_81;
-}
-}
-}
-block_81:
+x_96 = lean_ctor_get(x_83, 3);
+lean_inc(x_96);
+if (lean_obj_tag(x_96) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+x_16 = x_83;
+goto block_80;
+}
+else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = lean_ctor_get(x_21, 3);
+uint8_t x_97; 
+x_97 = !lean_is_exclusive(x_83);
+if (x_97 == 0)
+{
+lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; 
+x_98 = lean_ctor_get(x_83, 0);
+x_99 = lean_ctor_get(x_83, 3);
+lean_dec(x_99);
+x_100 = lean_ctor_get(x_83, 1);
+lean_dec(x_100);
+x_101 = l_Array_shrink___main___rarg(x_98, x_15);
+lean_inc(x_6);
+lean_ctor_set(x_83, 1, x_6);
+lean_ctor_set(x_83, 0, x_101);
+x_16 = x_83;
+goto block_80;
+}
+else
+{
+lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; 
+x_102 = lean_ctor_get(x_83, 0);
+x_103 = lean_ctor_get(x_83, 2);
+lean_inc(x_103);
+lean_inc(x_102);
+lean_dec(x_83);
+x_104 = l_Array_shrink___main___rarg(x_102, x_15);
+lean_inc(x_6);
+x_105 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_105, 0, x_104);
+lean_ctor_set(x_105, 1, x_6);
+lean_ctor_set(x_105, 2, x_103);
+lean_ctor_set(x_105, 3, x_96);
+x_16 = x_105;
+goto block_80;
+}
+}
+}
+block_80:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = lean_ctor_get(x_20, 3);
+lean_inc(x_21);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_61; lean_object* x_62; 
+x_22 = lean_ctor_get(x_20, 0);
 lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_62; lean_object* x_63; 
-x_23 = lean_ctor_get(x_21, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
-lean_dec(x_23);
-x_25 = lean_ctor_get(x_21, 1);
-lean_inc(x_25);
-lean_inc(x_2);
-x_62 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_63 = lean_ctor_get(x_62, 3);
-lean_inc(x_63);
-if (lean_obj_tag(x_63) == 0)
-{
-lean_object* x_64; lean_object* x_65; 
-x_64 = lean_ctor_get(x_62, 0);
-lean_inc(x_64);
-x_65 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_64);
-lean_dec(x_64);
-if (lean_obj_tag(x_65) == 2)
-{
-lean_object* x_66; lean_object* x_67; uint8_t x_68; 
-x_66 = lean_ctor_get(x_65, 1);
-lean_inc(x_66);
-lean_dec(x_65);
-x_67 = l_Lean_Parser_Term_doPat___elambda__1___closed__6;
-x_68 = lean_string_dec_eq(x_66, x_67);
-lean_dec(x_66);
-if (x_68 == 0)
-{
-lean_object* x_69; lean_object* x_70; 
-x_69 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
-lean_inc(x_25);
-x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_69, x_25);
-x_26 = x_70;
-goto block_61;
-}
-else
-{
-x_26 = x_62;
-goto block_61;
-}
-}
-else
-{
-lean_object* x_71; lean_object* x_72; 
-lean_dec(x_65);
-x_71 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
-lean_inc(x_25);
-x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_71, x_25);
-x_26 = x_72;
-goto block_61;
-}
-}
-else
-{
-lean_object* x_73; lean_object* x_74; 
-lean_dec(x_63);
-x_73 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
-lean_inc(x_25);
-x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_62, x_73, x_25);
-x_26 = x_74;
-goto block_61;
-}
-block_61:
-{
-lean_object* x_27; 
-x_27 = lean_ctor_get(x_26, 3);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_26);
-x_29 = lean_ctor_get(x_28, 3);
-lean_inc(x_29);
-if (lean_obj_tag(x_29) == 0)
-{
-lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-lean_dec(x_25);
-x_30 = l_Lean_nullKind;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_28, x_30, x_24);
-x_32 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
-x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_16);
-x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_11, x_7);
-lean_dec(x_7);
-return x_34;
-}
-else
-{
-lean_object* x_35; uint8_t x_36; 
-lean_dec(x_29);
-x_35 = lean_ctor_get(x_28, 1);
-lean_inc(x_35);
-x_36 = lean_nat_dec_eq(x_35, x_25);
-lean_dec(x_35);
-if (x_36 == 0)
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_25);
-x_37 = l_Lean_nullKind;
-x_38 = l_Lean_Parser_ParserState_mkNode(x_28, x_37, x_24);
-x_39 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_16);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_11, x_7);
-lean_dec(x_7);
-return x_41;
-}
-else
-{
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-x_42 = l_Lean_Parser_ParserState_restore(x_28, x_24, x_25);
-x_43 = l_Lean_nullKind;
-x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_24);
-x_45 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
-x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_16);
-x_47 = l_Lean_Parser_mergeOrElseErrors(x_46, x_11, x_7);
-lean_dec(x_7);
-return x_47;
-}
-}
-}
-else
-{
-lean_object* x_48; uint8_t x_49; 
-lean_dec(x_27);
-lean_dec(x_2);
-x_48 = lean_ctor_get(x_26, 1);
-lean_inc(x_48);
-x_49 = lean_nat_dec_eq(x_48, x_25);
-lean_dec(x_48);
-if (x_49 == 0)
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_25);
-x_50 = l_Lean_nullKind;
-x_51 = l_Lean_Parser_ParserState_mkNode(x_26, x_50, x_24);
-x_52 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_51, x_52, x_16);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_7);
-lean_dec(x_7);
-return x_54;
-}
-else
-{
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_55 = l_Lean_Parser_ParserState_restore(x_26, x_24, x_25);
-x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_24);
-x_58 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
-x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_16);
-x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_11, x_7);
-lean_dec(x_7);
-return x_60;
-}
-}
-}
-}
-else
-{
-lean_object* x_75; lean_object* x_76; lean_object* x_77; 
+x_23 = lean_array_get_size(x_22);
 lean_dec(x_22);
-lean_dec(x_2);
-x_75 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
-x_76 = l_Lean_Parser_ParserState_mkNode(x_21, x_75, x_16);
-x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_11, x_7);
-lean_dec(x_7);
-return x_77;
+x_24 = lean_ctor_get(x_20, 1);
+lean_inc(x_24);
+lean_inc(x_1);
+x_61 = l_Lean_Parser_tokenFn(x_1, x_20);
+x_62 = lean_ctor_get(x_61, 3);
+lean_inc(x_62);
+if (lean_obj_tag(x_62) == 0)
+{
+lean_object* x_63; lean_object* x_64; 
+x_63 = lean_ctor_get(x_61, 0);
+lean_inc(x_63);
+x_64 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_63);
+lean_dec(x_63);
+if (lean_obj_tag(x_64) == 2)
+{
+lean_object* x_65; lean_object* x_66; uint8_t x_67; 
+x_65 = lean_ctor_get(x_64, 1);
+lean_inc(x_65);
+lean_dec(x_64);
+x_66 = l_Lean_Parser_Term_doPat___elambda__1___closed__6;
+x_67 = lean_string_dec_eq(x_65, x_66);
+lean_dec(x_65);
+if (x_67 == 0)
+{
+lean_object* x_68; lean_object* x_69; 
+x_68 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
+lean_inc(x_24);
+x_69 = l_Lean_Parser_ParserState_mkErrorsAt(x_61, x_68, x_24);
+x_25 = x_69;
+goto block_60;
+}
+else
+{
+x_25 = x_61;
+goto block_60;
 }
 }
 else
 {
-lean_object* x_78; lean_object* x_79; lean_object* x_80; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_78 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
-x_79 = l_Lean_Parser_ParserState_mkNode(x_17, x_78, x_16);
-x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_11, x_7);
-lean_dec(x_7);
-return x_80;
+lean_object* x_70; lean_object* x_71; 
+lean_dec(x_64);
+x_70 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
+lean_inc(x_24);
+x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_61, x_70, x_24);
+x_25 = x_71;
+goto block_60;
+}
+}
+else
+{
+lean_object* x_72; lean_object* x_73; 
+lean_dec(x_62);
+x_72 = l_Lean_Parser_Term_doPat___elambda__1___closed__9;
+lean_inc(x_24);
+x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_61, x_72, x_24);
+x_25 = x_73;
+goto block_60;
+}
+block_60:
+{
+lean_object* x_26; 
+x_26 = lean_ctor_get(x_25, 3);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
+{
+lean_object* x_27; lean_object* x_28; 
+x_27 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_25);
+x_28 = lean_ctor_get(x_27, 3);
+lean_inc(x_28);
+if (lean_obj_tag(x_28) == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_dec(x_24);
+x_29 = l_Lean_nullKind;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_27, x_29, x_23);
+x_31 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_6);
+lean_dec(x_6);
+return x_33;
+}
+else
+{
+lean_object* x_34; uint8_t x_35; 
+lean_dec(x_28);
+x_34 = lean_ctor_get(x_27, 1);
+lean_inc(x_34);
+x_35 = lean_nat_dec_eq(x_34, x_24);
+lean_dec(x_34);
+if (x_35 == 0)
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_24);
+x_36 = l_Lean_nullKind;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_27, x_36, x_23);
+x_38 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
+x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_15);
+x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_10, x_6);
+lean_dec(x_6);
+return x_40;
+}
+else
+{
+lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_41 = l_Lean_Parser_ParserState_restore(x_27, x_23, x_24);
+x_42 = l_Lean_nullKind;
+x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_23);
+x_44 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_6);
+lean_dec(x_6);
+return x_46;
+}
+}
+}
+else
+{
+lean_object* x_47; uint8_t x_48; 
+lean_dec(x_26);
+lean_dec(x_1);
+x_47 = lean_ctor_get(x_25, 1);
+lean_inc(x_47);
+x_48 = lean_nat_dec_eq(x_47, x_24);
+lean_dec(x_47);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+lean_dec(x_24);
+x_49 = l_Lean_nullKind;
+x_50 = l_Lean_Parser_ParserState_mkNode(x_25, x_49, x_23);
+x_51 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
+x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_15);
+x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_10, x_6);
+lean_dec(x_6);
+return x_53;
+}
+else
+{
+lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_54 = l_Lean_Parser_ParserState_restore(x_25, x_23, x_24);
+x_55 = l_Lean_nullKind;
+x_56 = l_Lean_Parser_ParserState_mkNode(x_54, x_55, x_23);
+x_57 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
+x_58 = l_Lean_Parser_ParserState_mkNode(x_56, x_57, x_15);
+x_59 = l_Lean_Parser_mergeOrElseErrors(x_58, x_10, x_6);
+lean_dec(x_6);
+return x_59;
+}
+}
+}
+}
+else
+{
+lean_object* x_74; lean_object* x_75; lean_object* x_76; 
+lean_dec(x_21);
+lean_dec(x_1);
+x_74 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
+x_75 = l_Lean_Parser_ParserState_mkNode(x_20, x_74, x_15);
+x_76 = l_Lean_Parser_mergeOrElseErrors(x_75, x_10, x_6);
+lean_dec(x_6);
+return x_76;
+}
+}
+else
+{
+lean_object* x_77; lean_object* x_78; lean_object* x_79; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_77 = l_Lean_Parser_Term_doPat___elambda__1___closed__2;
+x_78 = l_Lean_Parser_ParserState_mkNode(x_16, x_77, x_15);
+x_79 = l_Lean_Parser_mergeOrElseErrors(x_78, x_10, x_6);
+lean_dec(x_6);
+return x_79;
 }
 }
 }
@@ -27716,7 +27224,7 @@ lean_object* _init_l_Lean_Parser_Term_doPat___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_leftArrow;
@@ -27740,7 +27248,7 @@ lean_object* _init_l_Lean_Parser_Term_doPat___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_doPat___closed__2;
@@ -27761,7 +27269,7 @@ lean_object* _init_l_Lean_Parser_Term_doPat___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_doPat___closed__4;
@@ -27805,7 +27313,7 @@ lean_object* _init_l_Lean_Parser_Term_doPat___closed__9() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doPat___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doPat___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -27860,75 +27368,74 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_doExpr___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_doExpr___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_doExpr___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_doExpr___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_doExpr___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_doExpr___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_doExpr___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_doExpr___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_doExpr___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-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_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
+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_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+x_16 = l_Lean_Parser_termParser___closed__2;
+x_17 = lean_unsigned_to_nat(0u);
+x_18 = l_Lean_Parser_categoryParser___elambda__1(x_16, x_17, x_1, x_13);
+x_19 = l_Lean_Parser_Term_doExpr___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_15);
+x_21 = l_Lean_Parser_mergeOrElseErrors(x_20, x_10, x_7);
 lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = l_Lean_Parser_termParser___closed__2;
-x_18 = lean_unsigned_to_nat(0u);
-x_19 = l_Lean_Parser_categoryParserFn(x_17, x_18, x_2, x_14);
-x_20 = l_Lean_Parser_Term_doExpr___elambda__1___closed__2;
-x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_16);
-x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_11, x_8);
-lean_dec(x_8);
-return x_22;
+return x_21;
 }
 }
 }
@@ -27937,7 +27444,7 @@ lean_object* _init_l_Lean_Parser_Term_doExpr___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_typeAscription___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_doExpr___elambda__1___closed__2;
@@ -27961,7 +27468,7 @@ lean_object* _init_l_Lean_Parser_Term_doExpr___closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doExpr___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doExpr___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -27985,154 +27492,145 @@ x_1 = l_Lean_Parser_Term_doExpr___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_doElem___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_doElem___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Term_doLet___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_dec(x_5);
 lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-lean_inc(x_2);
-lean_inc(x_1);
-x_7 = l_Lean_Parser_Term_doLet___elambda__1(x_1, x_2, x_3);
-x_8 = lean_ctor_get(x_7, 3);
+lean_dec(x_1);
+return x_6;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_7;
-}
-else
-{
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-lean_dec(x_8);
-x_10 = lean_ctor_get(x_7, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_10, x_6);
-lean_dec(x_10);
-if (x_11 == 0)
-{
+x_10 = lean_nat_dec_eq(x_9, x_5);
 lean_dec(x_9);
-lean_dec(x_6);
+if (x_10 == 0)
+{
+lean_dec(x_8);
 lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_4);
 lean_dec(x_1);
-return x_7;
+return x_6;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-lean_inc(x_6);
-x_12 = l_Lean_Parser_ParserState_restore(x_7, x_5, x_6);
-lean_dec(x_5);
-x_13 = lean_ctor_get(x_12, 0);
-lean_inc(x_13);
-x_14 = lean_array_get_size(x_13);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_inc(x_5);
+x_11 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+lean_dec(x_4);
+x_12 = lean_ctor_get(x_11, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+lean_inc(x_1);
+x_14 = l_Lean_Parser_Term_doId___elambda__1(x_1, x_11);
+x_15 = lean_ctor_get(x_14, 3);
+lean_inc(x_15);
+if (lean_obj_tag(x_15) == 0)
+{
+lean_object* x_16; 
 lean_dec(x_13);
-lean_inc(x_2);
-lean_inc(x_1);
-x_15 = l_Lean_Parser_Term_doId___elambda__1(x_1, x_2, x_12);
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; 
-lean_dec(x_14);
-lean_dec(x_2);
 lean_dec(x_1);
-x_17 = l_Lean_Parser_mergeOrElseErrors(x_15, x_9, x_6);
-lean_dec(x_6);
-return x_17;
+x_16 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_5);
+lean_dec(x_5);
+return x_16;
 }
 else
 {
-lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_18 = lean_ctor_get(x_16, 0);
+lean_object* x_17; lean_object* x_18; uint8_t x_19; 
+x_17 = lean_ctor_get(x_15, 0);
+lean_inc(x_17);
+lean_dec(x_15);
+x_18 = lean_ctor_get(x_14, 1);
 lean_inc(x_18);
-lean_dec(x_16);
-x_19 = lean_ctor_get(x_15, 1);
-lean_inc(x_19);
-x_20 = lean_nat_dec_eq(x_19, x_6);
-lean_dec(x_19);
-if (x_20 == 0)
-{
-lean_object* x_21; 
+x_19 = lean_nat_dec_eq(x_18, x_5);
 lean_dec(x_18);
-lean_dec(x_14);
-lean_dec(x_2);
+if (x_19 == 0)
+{
+lean_object* x_20; 
+lean_dec(x_17);
+lean_dec(x_13);
 lean_dec(x_1);
-x_21 = l_Lean_Parser_mergeOrElseErrors(x_15, x_9, x_6);
-lean_dec(x_6);
-return x_21;
+x_20 = l_Lean_Parser_mergeOrElseErrors(x_14, x_8, x_5);
+lean_dec(x_5);
+return x_20;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-lean_inc(x_6);
-x_22 = l_Lean_Parser_ParserState_restore(x_15, x_14, x_6);
-lean_dec(x_14);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-x_24 = lean_array_get_size(x_23);
-lean_dec(x_23);
-lean_inc(x_2);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_inc(x_5);
+x_21 = l_Lean_Parser_ParserState_restore(x_14, x_13, x_5);
+lean_dec(x_13);
+x_22 = lean_ctor_get(x_21, 0);
+lean_inc(x_22);
+x_23 = lean_array_get_size(x_22);
+lean_dec(x_22);
 lean_inc(x_1);
-x_25 = l_Lean_Parser_Term_doPat___elambda__1(x_1, x_2, x_22);
-x_26 = lean_ctor_get(x_25, 3);
-lean_inc(x_26);
-if (lean_obj_tag(x_26) == 0)
+x_24 = l_Lean_Parser_Term_doPat___elambda__1(x_1, x_21);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
 {
-lean_object* x_27; lean_object* x_28; 
-lean_dec(x_24);
-lean_dec(x_2);
+lean_object* x_26; lean_object* x_27; 
+lean_dec(x_23);
 lean_dec(x_1);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_25, x_18, x_6);
-x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_9, x_6);
-lean_dec(x_6);
-return x_28;
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_24, x_17, x_5);
+x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_8, x_5);
+lean_dec(x_5);
+return x_27;
 }
 else
 {
-lean_object* x_29; lean_object* x_30; uint8_t x_31; 
-x_29 = lean_ctor_get(x_26, 0);
+lean_object* x_28; lean_object* x_29; uint8_t x_30; 
+x_28 = lean_ctor_get(x_25, 0);
+lean_inc(x_28);
+lean_dec(x_25);
+x_29 = lean_ctor_get(x_24, 1);
 lean_inc(x_29);
-lean_dec(x_26);
-x_30 = lean_ctor_get(x_25, 1);
-lean_inc(x_30);
-x_31 = lean_nat_dec_eq(x_30, x_6);
-lean_dec(x_30);
-if (x_31 == 0)
-{
-lean_object* x_32; lean_object* x_33; 
+x_30 = lean_nat_dec_eq(x_29, x_5);
 lean_dec(x_29);
-lean_dec(x_24);
-lean_dec(x_2);
+if (x_30 == 0)
+{
+lean_object* x_31; lean_object* x_32; 
+lean_dec(x_28);
+lean_dec(x_23);
 lean_dec(x_1);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_25, x_18, x_6);
-x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_9, x_6);
-lean_dec(x_6);
-return x_33;
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_24, x_17, x_5);
+x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_8, x_5);
+lean_dec(x_5);
+return x_32;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_inc(x_6);
-x_34 = l_Lean_Parser_ParserState_restore(x_25, x_24, x_6);
-lean_dec(x_24);
-x_35 = l_Lean_Parser_Term_doExpr___elambda__1(x_1, x_2, x_34);
-x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_29, x_6);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_18, x_6);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_9, x_6);
-lean_dec(x_6);
-return x_38;
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+lean_inc(x_5);
+x_33 = l_Lean_Parser_ParserState_restore(x_24, x_23, x_5);
+lean_dec(x_23);
+x_34 = l_Lean_Parser_Term_doExpr___elambda__1(x_1, x_33);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_28, x_5);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_17, x_5);
+x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_8, x_5);
+lean_dec(x_5);
+return x_37;
 }
 }
 }
@@ -28183,7 +27681,7 @@ lean_object* _init_l_Lean_Parser_Term_doElem___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doElem___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doElem___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -28207,226 +27705,222 @@ x_1 = l_Lean_Parser_Term_doElem___closed__5;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
-lean_dec(x_9);
-x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_5);
+x_10 = l_Lean_Parser_Term_doElem___elambda__1(x_5, x_6);
+x_11 = lean_ctor_get(x_10, 3);
 lean_inc(x_11);
-lean_inc(x_7);
-lean_inc(x_6);
-x_12 = l_Lean_Parser_Term_doElem___elambda__1(x_6, x_7, x_8);
-x_13 = lean_ctor_get(x_12, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+if (lean_obj_tag(x_11) == 0)
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_14 = lean_ctor_get(x_12, 0);
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_12 = lean_ctor_get(x_10, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+x_14 = lean_ctor_get(x_10, 1);
 lean_inc(x_14);
-x_15 = lean_array_get_size(x_14);
-lean_dec(x_14);
-x_16 = lean_ctor_get(x_12, 1);
-lean_inc(x_16);
-lean_inc(x_7);
-x_31 = l_Lean_Parser_tokenFn(x_7, x_12);
-x_32 = lean_ctor_get(x_31, 3);
-lean_inc(x_32);
-if (lean_obj_tag(x_32) == 0)
+lean_inc(x_5);
+x_29 = l_Lean_Parser_tokenFn(x_5, x_10);
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_31, 0);
+lean_object* x_31; lean_object* x_32; 
+x_31 = lean_ctor_get(x_29, 0);
+lean_inc(x_31);
+x_32 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_31);
+lean_dec(x_31);
+if (lean_obj_tag(x_32) == 2)
+{
+lean_object* x_33; lean_object* x_34; uint8_t x_35; 
+x_33 = lean_ctor_get(x_32, 1);
 lean_inc(x_33);
-x_34 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_33);
+lean_dec(x_32);
+x_34 = l_Lean_Parser_Term_have___elambda__1___closed__7;
+x_35 = lean_string_dec_eq(x_33, x_34);
 lean_dec(x_33);
-if (lean_obj_tag(x_34) == 2)
+if (x_35 == 0)
 {
-lean_object* x_35; lean_object* x_36; uint8_t x_37; 
-x_35 = lean_ctor_get(x_34, 1);
-lean_inc(x_35);
-lean_dec(x_34);
-x_36 = l_Lean_Parser_Term_have___elambda__1___closed__7;
-x_37 = lean_string_dec_eq(x_35, x_36);
-lean_dec(x_35);
-if (x_37 == 0)
-{
-lean_object* x_38; lean_object* x_39; 
-x_38 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-lean_inc(x_16);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_38, x_16);
-x_17 = x_39;
-goto block_30;
+lean_object* x_36; lean_object* x_37; 
+x_36 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+lean_inc(x_14);
+x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_14);
+x_15 = x_37;
+goto block_28;
 }
 else
 {
-x_17 = x_31;
-goto block_30;
+x_15 = x_29;
+goto block_28;
+}
+}
+else
+{
+lean_object* x_38; lean_object* x_39; 
+lean_dec(x_32);
+x_38 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+lean_inc(x_14);
+x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_14);
+x_15 = x_39;
+goto block_28;
 }
 }
 else
 {
 lean_object* x_40; lean_object* x_41; 
-lean_dec(x_34);
+lean_dec(x_30);
 x_40 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+lean_inc(x_14);
+x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_14);
+x_15 = x_41;
+goto block_28;
+}
+block_28:
+{
+lean_object* x_16; 
+x_16 = lean_ctor_get(x_15, 3);
 lean_inc(x_16);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_40, x_16);
-x_17 = x_41;
-goto block_30;
-}
-}
-else
+if (lean_obj_tag(x_16) == 0)
 {
-lean_object* x_42; lean_object* x_43; 
-lean_dec(x_32);
-x_42 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-lean_inc(x_16);
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_31, x_42, x_16);
-x_17 = x_43;
-goto block_30;
-}
-block_30:
+lean_dec(x_14);
+lean_dec(x_13);
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_dec(x_16);
-lean_dec(x_15);
-{
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_17;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_15;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-lean_dec(x_18);
-lean_dec(x_7);
-lean_dec(x_6);
-x_20 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16);
-lean_dec(x_15);
-x_21 = lean_ctor_get(x_20, 0);
-lean_inc(x_21);
-x_22 = lean_array_get_size(x_21);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+lean_dec(x_16);
+lean_dec(x_5);
+x_18 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
+lean_dec(x_13);
+x_19 = lean_ctor_get(x_18, 0);
+lean_inc(x_19);
+x_20 = lean_array_get_size(x_19);
+lean_dec(x_19);
+x_21 = lean_nat_sub(x_20, x_2);
+lean_dec(x_20);
+x_22 = lean_unsigned_to_nat(1u);
+x_23 = lean_nat_dec_eq(x_21, x_22);
 lean_dec(x_21);
-x_23 = lean_nat_sub(x_22, x_3);
-lean_dec(x_22);
-x_24 = lean_unsigned_to_nat(1u);
-x_25 = lean_nat_dec_eq(x_23, x_24);
-lean_dec(x_23);
-if (x_25 == 0)
+if (x_23 == 0)
+{
+lean_object* x_24; lean_object* x_25; 
+x_24 = l_Lean_nullKind;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_18, x_24, x_2);
+return x_25;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_26; lean_object* x_27; 
 x_26 = l_Lean_nullKind;
-x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_26, x_3);
+x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_2);
 return x_27;
 }
 else
 {
+lean_dec(x_2);
+return x_18;
+}
+}
+}
+}
+}
+else
+{
+lean_dec(x_11);
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Lean_nullKind;
-x_29 = l_Lean_Parser_ParserState_mkNode(x_20, x_28, x_3);
-return x_29;
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_42 = lean_box(0);
+x_43 = l_Lean_Parser_ParserState_pushSyntax(x_10, x_42);
+x_44 = l_Lean_nullKind;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_2);
+return x_45;
 }
 else
 {
-lean_dec(x_3);
-return x_20;
-}
-}
-}
-}
-}
-else
-{
-lean_dec(x_13);
-lean_dec(x_7);
-lean_dec(x_6);
-if (x_5 == 0)
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_44 = lean_box(0);
-x_45 = l_Lean_Parser_ParserState_pushSyntax(x_12, x_44);
-x_46 = l_Lean_nullKind;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_3);
-return x_47;
-}
-else
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
-x_48 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_11);
-lean_dec(x_10);
-x_49 = lean_ctor_get(x_48, 0);
-lean_inc(x_49);
-x_50 = lean_array_get_size(x_49);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; 
+x_46 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_47 = lean_ctor_get(x_46, 0);
+lean_inc(x_47);
+x_48 = lean_array_get_size(x_47);
+lean_dec(x_47);
+x_49 = lean_nat_sub(x_48, x_2);
+lean_dec(x_48);
+x_50 = lean_unsigned_to_nat(2u);
+x_51 = lean_nat_dec_eq(x_49, x_50);
 lean_dec(x_49);
-x_51 = lean_nat_sub(x_50, x_3);
-lean_dec(x_50);
-x_52 = lean_unsigned_to_nat(2u);
-x_53 = lean_nat_dec_eq(x_51, x_52);
-lean_dec(x_51);
-if (x_53 == 0)
+if (x_51 == 0)
+{
+lean_object* x_52; lean_object* x_53; 
+x_52 = l_Lean_nullKind;
+x_53 = l_Lean_Parser_ParserState_mkNode(x_46, x_52, x_2);
+return x_53;
+}
+else
+{
+if (x_3 == 0)
 {
 lean_object* x_54; lean_object* x_55; 
 x_54 = l_Lean_nullKind;
-x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_3);
+x_55 = l_Lean_Parser_ParserState_mkNode(x_46, x_54, x_2);
 return x_55;
 }
 else
 {
-if (x_4 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l_Lean_nullKind;
-x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_3);
-return x_57;
-}
-else
-{
-lean_object* x_58; 
-lean_dec(x_3);
-x_58 = l_Lean_Parser_ParserState_popSyntax(x_48);
-return x_58;
+lean_object* x_56; 
+lean_dec(x_2);
+x_56 = l_Lean_Parser_ParserState_popSyntax(x_46);
+return x_56;
 }
 }
 }
 }
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = 0;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2(x_1, x_2, x_8, x_3, x_9, x_4, x_5, x_6);
-return x_10;
+lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = 0;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2(x_1, x_6, x_2, x_7, x_3, x_4);
+return x_8;
 }
 }
-lean_object* l_Lean_Parser_Term_doSeq___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_doSeq___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_4; uint8_t x_5; lean_object* x_6; 
-x_4 = 0;
-x_5 = 0;
-x_6 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_4, x_5, x_5, x_1, x_2, x_3);
-return x_6;
+uint8_t x_3; lean_object* x_4; 
+x_3 = 0;
+x_4 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_3, x_3, x_1, x_2);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_doSeq___closed__1() {
@@ -28445,7 +27939,7 @@ lean_object* _init_l_Lean_Parser_Term_doSeq___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doSeq___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_doSeq___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -28469,36 +27963,32 @@ x_1 = l_Lean_Parser_Term_doSeq___closed__3;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
-lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-return x_13;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
 x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_8 = lean_unbox(x_2);
-lean_dec(x_2);
-x_9 = lean_unbox(x_3);
+x_8 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_7, x_8, x_9, x_4, x_5, x_6);
+x_9 = lean_unbox(x_4);
+lean_dec(x_4);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_doSeq___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
 return x_10;
 }
 }
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox(x_1);
+lean_dec(x_1);
+x_6 = lean_unbox(x_2);
+lean_dec(x_2);
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_5, x_6, x_3, x_4);
+return x_7;
+}
+}
 lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__1() {
 _start:
 {
@@ -28530,235 +28020,229 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_bracketedDoSeq___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_bracketedDoSeq___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_bracketedDoSeq___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_56; lean_object* x_57; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_56 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_57 = lean_ctor_get(x_56, 3);
-lean_inc(x_57);
-if (lean_obj_tag(x_57) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_54; lean_object* x_55; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_54 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_55 = lean_ctor_get(x_54, 3);
+lean_inc(x_55);
+if (lean_obj_tag(x_55) == 0)
 {
-lean_object* x_58; lean_object* x_59; 
-x_58 = lean_ctor_get(x_56, 0);
+lean_object* x_56; lean_object* x_57; 
+x_56 = lean_ctor_get(x_54, 0);
+lean_inc(x_56);
+x_57 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_56);
+lean_dec(x_56);
+if (lean_obj_tag(x_57) == 2)
+{
+lean_object* x_58; lean_object* x_59; uint8_t x_60; 
+x_58 = lean_ctor_get(x_57, 1);
 lean_inc(x_58);
-x_59 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_58);
+lean_dec(x_57);
+x_59 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
+x_60 = lean_string_dec_eq(x_58, x_59);
 lean_dec(x_58);
-if (lean_obj_tag(x_59) == 2)
+if (x_60 == 0)
 {
-lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_60 = lean_ctor_get(x_59, 1);
-lean_inc(x_60);
-lean_dec(x_59);
-x_61 = l_Lean_Parser_Term_structInst___elambda__1___closed__5;
-x_62 = lean_string_dec_eq(x_60, x_61);
-lean_dec(x_60);
-if (x_62 == 0)
+lean_object* x_61; lean_object* x_62; 
+x_61 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
+lean_inc(x_7);
+x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_61, x_7);
+x_16 = x_62;
+goto block_53;
+}
+else
+{
+x_16 = x_54;
+goto block_53;
+}
+}
+else
 {
 lean_object* x_63; lean_object* x_64; 
+lean_dec(x_57);
 x_63 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_8);
-x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_8);
-x_17 = x_64;
-goto block_55;
-}
-else
-{
-x_17 = x_56;
-goto block_55;
+lean_inc(x_7);
+x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_63, x_7);
+x_16 = x_64;
+goto block_53;
 }
 }
 else
 {
 lean_object* x_65; lean_object* x_66; 
-lean_dec(x_59);
+lean_dec(x_55);
 x_65 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_8);
-x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_8);
-x_17 = x_66;
-goto block_55;
+lean_inc(x_7);
+x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_54, x_65, x_7);
+x_16 = x_66;
+goto block_53;
 }
-}
-else
+block_53:
 {
-lean_object* x_67; lean_object* x_68; 
-lean_dec(x_57);
-x_67 = l_Lean_Parser_Term_structInst___elambda__1___closed__13;
-lean_inc(x_8);
-x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_8);
-x_17 = x_68;
-goto block_55;
-}
-block_55:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+uint8_t x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = 0;
+lean_inc(x_1);
+x_19 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_18, x_18, x_1, x_16);
+x_20 = lean_ctor_get(x_19, 3);
+lean_inc(x_20);
+if (lean_obj_tag(x_20) == 0)
 {
-uint8_t x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = 0;
-x_20 = 0;
-lean_inc(x_2);
-x_21 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_19, x_20, x_20, x_1, x_2, x_17);
-x_22 = lean_ctor_get(x_21, 3);
-lean_inc(x_22);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_23 = lean_ctor_get(x_21, 1);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_19, 1);
+lean_inc(x_21);
+x_22 = l_Lean_Parser_tokenFn(x_1, x_19);
+x_23 = lean_ctor_get(x_22, 3);
 lean_inc(x_23);
-x_24 = l_Lean_Parser_tokenFn(x_2, x_21);
-x_25 = lean_ctor_get(x_24, 3);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
+if (lean_obj_tag(x_23) == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
+lean_object* x_24; lean_object* x_25; 
+x_24 = lean_ctor_get(x_22, 0);
+lean_inc(x_24);
+x_25 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_24);
+lean_dec(x_24);
+if (lean_obj_tag(x_25) == 2)
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_25, 1);
 lean_inc(x_26);
-x_27 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_26);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 2)
-{
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_27, 1);
-lean_inc(x_28);
-lean_dec(x_27);
-x_29 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
-x_30 = lean_string_dec_eq(x_28, x_29);
-lean_dec(x_28);
-if (x_30 == 0)
-{
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_31 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
-x_33 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
-x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
-x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_8);
-lean_dec(x_8);
-return x_35;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_23);
-x_36 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_16);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_8);
-lean_dec(x_8);
-return x_38;
-}
-}
-else
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-lean_dec(x_27);
-x_39 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
-x_41 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
-}
-}
-else
-{
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
 lean_dec(x_25);
-x_44 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
-x_46 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
-x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
-x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_8);
-lean_dec(x_8);
-return x_48;
+x_27 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7;
+x_28 = lean_string_dec_eq(x_26, x_27);
+lean_dec(x_26);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_29 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21);
+x_31 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
+x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_15);
+x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_10, x_7);
+lean_dec(x_7);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+lean_dec(x_21);
+x_34 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
+x_35 = l_Lean_Parser_ParserState_mkNode(x_22, x_34, x_15);
+x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_10, x_7);
+lean_dec(x_7);
+return x_36;
 }
 }
 else
 {
-lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_22);
-lean_dec(x_2);
-x_49 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_16);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_11, x_8);
-lean_dec(x_8);
-return x_51;
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_25);
+x_37 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_37, x_21);
+x_39 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_18);
-lean_dec(x_2);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_23);
+x_42 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11;
+x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_42, x_21);
+x_44 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
+x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_15);
+x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_10, x_7);
+lean_dec(x_7);
+return x_46;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_20);
 lean_dec(x_1);
-x_52 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_17, x_52, x_16);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_8);
-lean_dec(x_8);
-return x_54;
+x_47 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
+x_48 = l_Lean_Parser_ParserState_mkNode(x_19, x_47, x_15);
+x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_10, x_7);
+lean_dec(x_7);
+return x_49;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_50 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2;
+x_51 = l_Lean_Parser_ParserState_mkNode(x_16, x_50, x_15);
+x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_10, x_7);
+lean_dec(x_7);
+return x_52;
 }
 }
 }
@@ -28813,7 +28297,7 @@ lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bracketedDoSeq___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bracketedDoSeq___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -28868,13 +28352,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_do___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_do___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_do___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_do___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_do___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_do___elambda__1___closed__5() {
@@ -28926,203 +28409,195 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_do___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_do___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_do___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_do___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
-lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
 lean_inc(x_1);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_9;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_45; lean_object* x_46; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_45 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_46 = lean_ctor_get(x_45, 3);
-lean_inc(x_46);
-if (lean_obj_tag(x_46) == 0)
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_43; lean_object* x_44; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_43 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_44 = lean_ctor_get(x_43, 3);
+lean_inc(x_44);
+if (lean_obj_tag(x_44) == 0)
 {
-lean_object* x_47; lean_object* x_48; 
-x_47 = lean_ctor_get(x_45, 0);
+lean_object* x_45; lean_object* x_46; 
+x_45 = lean_ctor_get(x_43, 0);
+lean_inc(x_45);
+x_46 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_45);
+lean_dec(x_45);
+if (lean_obj_tag(x_46) == 2)
+{
+lean_object* x_47; lean_object* x_48; uint8_t x_49; 
+x_47 = lean_ctor_get(x_46, 1);
 lean_inc(x_47);
-x_48 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_47);
+lean_dec(x_46);
+x_48 = l_Lean_Parser_Term_do___elambda__1___closed__6;
+x_49 = lean_string_dec_eq(x_47, x_48);
 lean_dec(x_47);
-if (lean_obj_tag(x_48) == 2)
+if (x_49 == 0)
 {
-lean_object* x_49; lean_object* x_50; uint8_t x_51; 
-x_49 = lean_ctor_get(x_48, 1);
-lean_inc(x_49);
-lean_dec(x_48);
-x_50 = l_Lean_Parser_Term_do___elambda__1___closed__6;
-x_51 = lean_string_dec_eq(x_49, x_50);
-lean_dec(x_49);
-if (x_51 == 0)
+lean_object* x_50; lean_object* x_51; 
+x_50 = l_Lean_Parser_Term_do___elambda__1___closed__9;
+lean_inc(x_7);
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_50, x_7);
+x_16 = x_51;
+goto block_42;
+}
+else
+{
+x_16 = x_43;
+goto block_42;
+}
+}
+else
 {
 lean_object* x_52; lean_object* x_53; 
+lean_dec(x_46);
 x_52 = l_Lean_Parser_Term_do___elambda__1___closed__9;
-lean_inc(x_8);
-x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_8);
-x_17 = x_53;
-goto block_44;
-}
-else
-{
-x_17 = x_45;
-goto block_44;
+lean_inc(x_7);
+x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_52, x_7);
+x_16 = x_53;
+goto block_42;
 }
 }
 else
 {
 lean_object* x_54; lean_object* x_55; 
-lean_dec(x_48);
+lean_dec(x_44);
 x_54 = l_Lean_Parser_Term_do___elambda__1___closed__9;
-lean_inc(x_8);
-x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_8);
-x_17 = x_55;
-goto block_44;
+lean_inc(x_7);
+x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_54, x_7);
+x_16 = x_55;
+goto block_42;
 }
-}
-else
+block_42:
 {
-lean_object* x_56; lean_object* x_57; 
-lean_dec(x_46);
-x_56 = l_Lean_Parser_Term_do___elambda__1___closed__9;
-lean_inc(x_8);
-x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_8);
-x_17 = x_57;
-goto block_44;
-}
-block_44:
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-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);
-lean_inc(x_2);
-lean_inc(x_1);
-x_22 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1(x_1, x_2, x_17);
-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);
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_24 = l_Lean_Parser_Term_do___elambda__1___closed__2;
-x_25 = l_Lean_Parser_ParserState_mkNode(x_22, x_24, x_16);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_11, x_8);
-lean_dec(x_8);
-return x_26;
-}
-else
-{
-lean_object* x_27; lean_object* x_28; uint8_t x_29; 
-x_27 = lean_ctor_get(x_23, 0);
-lean_inc(x_27);
-lean_dec(x_23);
-x_28 = lean_ctor_get(x_22, 1);
-lean_inc(x_28);
-x_29 = lean_nat_dec_eq(x_28, x_21);
-lean_dec(x_28);
-if (x_29 == 0)
-{
-lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-lean_dec(x_27);
-lean_dec(x_21);
-lean_dec(x_20);
-lean_dec(x_2);
-lean_dec(x_1);
-x_30 = l_Lean_Parser_Term_do___elambda__1___closed__2;
-x_31 = l_Lean_Parser_ParserState_mkNode(x_22, x_30, x_16);
-x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_11, x_8);
-lean_dec(x_8);
-return x_32;
-}
-else
-{
-lean_object* x_33; uint8_t x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-lean_inc(x_21);
-x_33 = l_Lean_Parser_ParserState_restore(x_22, x_20, x_21);
-lean_dec(x_20);
-x_34 = 0;
-x_35 = 0;
-x_36 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_34, x_35, x_35, x_1, x_2, x_33);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_27, x_21);
-lean_dec(x_21);
-x_38 = l_Lean_Parser_Term_do___elambda__1___closed__2;
-x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_16);
-x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_11, x_8);
-lean_dec(x_8);
-return x_40;
-}
-}
-}
-else
-{
-lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_19 = lean_array_get_size(x_18);
 lean_dec(x_18);
-lean_dec(x_2);
+x_20 = lean_ctor_get(x_16, 1);
+lean_inc(x_20);
+lean_inc(x_1);
+x_21 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1(x_1, x_16);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_20);
+lean_dec(x_19);
 lean_dec(x_1);
-x_41 = l_Lean_Parser_Term_do___elambda__1___closed__2;
-x_42 = l_Lean_Parser_ParserState_mkNode(x_17, x_41, x_16);
-x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_8);
-lean_dec(x_8);
-return x_43;
+x_23 = l_Lean_Parser_Term_do___elambda__1___closed__2;
+x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_15);
+x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_10, x_7);
+lean_dec(x_7);
+return x_25;
+}
+else
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_22, 0);
+lean_inc(x_26);
+lean_dec(x_22);
+x_27 = lean_ctor_get(x_21, 1);
+lean_inc(x_27);
+x_28 = lean_nat_dec_eq(x_27, x_20);
+lean_dec(x_27);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_26);
+lean_dec(x_20);
+lean_dec(x_19);
+lean_dec(x_1);
+x_29 = l_Lean_Parser_Term_do___elambda__1___closed__2;
+x_30 = l_Lean_Parser_ParserState_mkNode(x_21, x_29, x_15);
+x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_10, x_7);
+lean_dec(x_7);
+return x_31;
+}
+else
+{
+lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_inc(x_20);
+x_32 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20);
+lean_dec(x_19);
+x_33 = 0;
+x_34 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_33, x_33, x_1, x_32);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_26, x_20);
+lean_dec(x_20);
+x_36 = l_Lean_Parser_Term_do___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_15);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_10, x_7);
+lean_dec(x_7);
+return x_38;
+}
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_39 = l_Lean_Parser_Term_do___elambda__1___closed__2;
+x_40 = l_Lean_Parser_ParserState_mkNode(x_16, x_39, x_15);
+x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_10, x_7);
+lean_dec(x_7);
+return x_41;
 }
 }
 }
@@ -29189,7 +28664,7 @@ lean_object* _init_l_Lean_Parser_Term_do___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_do___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_do___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -29216,10 +28691,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_do(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_do___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_do___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_do;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -29256,13 +28731,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_not___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_not___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_not___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_not___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_not___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_not___elambda__1___closed__5() {
@@ -29314,141 +28788,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_not___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_not___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_not___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_not___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_not___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_not___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_not___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_not___elambda__1___closed__9;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_not___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(40u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_not___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_not___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_not___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_not___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_not___elambda__1___closed__9;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(40u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_not___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_not___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -29478,12 +28952,11 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Term_not___closed__3() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_termParser___closed__2;
-x_3 = lean_unsigned_to_nat(40u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_termParser___closed__2;
+x_2 = lean_unsigned_to_nat(40u);
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_not___closed__4() {
@@ -29524,7 +28997,7 @@ lean_object* _init_l_Lean_Parser_Term_not___closed__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_not___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_not___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -29551,10 +29024,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_not(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_not___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_not___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_not;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -29591,13 +29064,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_bnot___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_bnot___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_bnot___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_bnot___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_bnot___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_bnot___elambda__1___closed__5() {
@@ -29649,141 +29121,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_bnot___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_bnot___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_bnot___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_bnot___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_bnot___elambda__1___closed__6;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_bnot___elambda__1___closed__9;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_bnot___elambda__1___closed__9;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_bnot___elambda__1___closed__9;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_bnot___elambda__1___closed__6;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(40u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_bnot___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_bnot___elambda__1___closed__9;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_bnot___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_bnot___elambda__1___closed__9;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_bnot___elambda__1___closed__9;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(40u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_bnot___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_bnot___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -29838,7 +29310,7 @@ lean_object* _init_l_Lean_Parser_Term_bnot___closed__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bnot___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bnot___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -29865,10 +29337,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_bnot(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_bnot___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_bnot___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_bnot;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -29905,13 +29377,12 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_uminus___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_uminus___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_uminus___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_uminus___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_uminus___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_uminus___elambda__1___closed__5() {
@@ -29955,141 +29426,141 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_uminus___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_uminus___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_uminus___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_uminus___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_inc(x_1);
+x_8 = lean_apply_2(x_4, x_1, x_2);
+x_9 = lean_ctor_get(x_8, 3);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_dec(x_7);
 lean_dec(x_6);
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-lean_inc(x_2);
-x_9 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_10 = lean_ctor_get(x_9, 3);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_11 = lean_ctor_get(x_10, 0);
+lean_dec(x_9);
+x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
-lean_dec(x_10);
-x_12 = lean_ctor_get(x_9, 1);
-lean_inc(x_12);
-x_13 = lean_nat_dec_eq(x_12, x_8);
-lean_dec(x_12);
-if (x_13 == 0)
-{
+x_12 = lean_nat_dec_eq(x_11, x_7);
 lean_dec(x_11);
-lean_dec(x_8);
+if (x_12 == 0)
+{
+lean_dec(x_10);
 lean_dec(x_7);
-lean_dec(x_2);
-return x_9;
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_29; lean_object* x_30; 
-lean_inc(x_8);
-x_14 = l_Lean_Parser_ParserState_restore(x_9, x_7, x_8);
-lean_dec(x_7);
-x_15 = lean_ctor_get(x_14, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-lean_inc(x_2);
-x_29 = l_Lean_Parser_tokenFn(x_2, x_14);
-x_30 = lean_ctor_get(x_29, 3);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_28; lean_object* x_29; 
+lean_inc(x_7);
+x_13 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_array_get_size(x_14);
+lean_dec(x_14);
+lean_inc(x_1);
+x_28 = l_Lean_Parser_tokenFn(x_1, x_13);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+lean_object* x_30; lean_object* x_31; 
+x_30 = lean_ctor_get(x_28, 0);
 lean_inc(x_30);
-if (lean_obj_tag(x_30) == 0)
-{
-lean_object* x_31; lean_object* x_32; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_inc(x_31);
-x_32 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_31);
-lean_dec(x_31);
-if (lean_obj_tag(x_32) == 2)
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 1);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = l_Lean_Parser_Term_uminus___elambda__1___closed__5;
-x_35 = lean_string_dec_eq(x_33, x_34);
-lean_dec(x_33);
-if (x_35 == 0)
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Lean_Parser_Term_uminus___elambda__1___closed__8;
-lean_inc(x_8);
-x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_36, x_8);
-x_17 = x_37;
-goto block_28;
-}
-else
-{
-x_17 = x_29;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_32);
-x_38 = l_Lean_Parser_Term_uminus___elambda__1___closed__8;
-lean_inc(x_8);
-x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_38, x_8);
-x_17 = x_39;
-goto block_28;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; 
+x_31 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_30);
 lean_dec(x_30);
-x_40 = l_Lean_Parser_Term_uminus___elambda__1___closed__8;
-lean_inc(x_8);
-x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_29, x_40, x_8);
-x_17 = x_41;
-goto block_28;
-}
-block_28:
+if (lean_obj_tag(x_31) == 2)
 {
-lean_object* x_18; 
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+lean_object* x_32; lean_object* x_33; uint8_t x_34; 
+x_32 = lean_ctor_get(x_31, 1);
+lean_inc(x_32);
+lean_dec(x_31);
+x_33 = l_Lean_Parser_Term_uminus___elambda__1___closed__5;
+x_34 = lean_string_dec_eq(x_32, x_33);
+lean_dec(x_32);
+if (x_34 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_19 = l_Lean_Parser_termParser___closed__2;
-x_20 = lean_unsigned_to_nat(100u);
-x_21 = l_Lean_Parser_categoryParserFn(x_19, x_20, x_2, x_17);
-x_22 = l_Lean_Parser_Term_uminus___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_16);
-x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_11, x_8);
-lean_dec(x_8);
-return x_24;
+lean_object* x_35; lean_object* x_36; 
+x_35 = l_Lean_Parser_Term_uminus___elambda__1___closed__8;
+lean_inc(x_7);
+x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_35, x_7);
+x_16 = x_36;
+goto block_27;
 }
 else
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-lean_dec(x_18);
-lean_dec(x_2);
-x_25 = l_Lean_Parser_Term_uminus___elambda__1___closed__2;
-x_26 = l_Lean_Parser_ParserState_mkNode(x_17, x_25, x_16);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_11, x_8);
-lean_dec(x_8);
-return x_27;
+x_16 = x_28;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_37; lean_object* x_38; 
+lean_dec(x_31);
+x_37 = l_Lean_Parser_Term_uminus___elambda__1___closed__8;
+lean_inc(x_7);
+x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_37, x_7);
+x_16 = x_38;
+goto block_27;
+}
+}
+else
+{
+lean_object* x_39; lean_object* x_40; 
+lean_dec(x_29);
+x_39 = l_Lean_Parser_Term_uminus___elambda__1___closed__8;
+lean_inc(x_7);
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_28, x_39, x_7);
+x_16 = x_40;
+goto block_27;
+}
+block_27:
+{
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_18 = l_Lean_Parser_termParser___closed__2;
+x_19 = lean_unsigned_to_nat(100u);
+x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_16);
+x_21 = l_Lean_Parser_Term_uminus___elambda__1___closed__2;
+x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_15);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_10, x_7);
+lean_dec(x_7);
+return x_23;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_17);
+lean_dec(x_1);
+x_24 = l_Lean_Parser_Term_uminus___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkNode(x_16, x_24, x_15);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_10, x_7);
+lean_dec(x_7);
+return x_26;
 }
 }
 }
@@ -30109,12 +29580,11 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Term_uminus___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 0;
-x_2 = l_Lean_Parser_termParser___closed__2;
-x_3 = lean_unsigned_to_nat(100u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_termParser___closed__2;
+x_2 = lean_unsigned_to_nat(100u);
+x_3 = l_Lean_Parser_categoryParser(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_uminus___closed__3() {
@@ -30155,7 +29625,7 @@ lean_object* _init_l_Lean_Parser_Term_uminus___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_uminus___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_uminus___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -30182,10 +29652,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_uminus(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 0;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_uminus___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_uminus___elambda__1___closed__2;
+x_4 = 1;
 x_5 = l_Lean_Parser_Term_uminus;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -30222,426 +29692,415 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_namedArgument___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 0;
-x_2 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__1;
-x_3 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__3;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; 
+x_1 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__1;
+x_2 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__3;
+x_3 = 1;
+x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3);
+return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_namedArgument___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_namedArgument___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_4 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__4;
-x_7 = lean_ctor_get(x_6, 1);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_8);
-lean_dec(x_8);
-lean_inc(x_3);
+x_6 = lean_ctor_get(x_2, 1);
+lean_inc(x_6);
+x_7 = lean_array_get_size(x_5);
+lean_dec(x_5);
 lean_inc(x_2);
 lean_inc(x_1);
-x_11 = lean_apply_3(x_7, x_1, x_2, x_3);
-if (lean_is_exclusive(x_3)) {
- lean_ctor_release(x_3, 0);
- lean_ctor_release(x_3, 1);
- lean_ctor_release(x_3, 2);
- lean_ctor_release(x_3, 3);
- x_12 = x_3;
+x_8 = lean_apply_2(x_4, x_1, x_2);
+if (lean_is_exclusive(x_2)) {
+ lean_ctor_release(x_2, 0);
+ lean_ctor_release(x_2, 1);
+ lean_ctor_release(x_2, 2);
+ lean_ctor_release(x_2, 3);
+ x_9 = x_2;
 } else {
- lean_dec_ref(x_3);
- x_12 = lean_box(0);
+ lean_dec_ref(x_2);
+ x_9 = lean_box(0);
 }
-x_13 = lean_ctor_get(x_11, 3);
-lean_inc(x_13);
-if (lean_obj_tag(x_13) == 0)
+x_10 = lean_ctor_get(x_8, 3);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
 {
-lean_dec(x_12);
-lean_dec(x_10);
 lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
+lean_dec(x_7);
+lean_dec(x_6);
 lean_dec(x_1);
-return x_11;
+return x_8;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; uint8_t x_16; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_11, 1);
+lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_11 = lean_ctor_get(x_10, 0);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = lean_ctor_get(x_8, 1);
+lean_inc(x_12);
+x_13 = lean_nat_dec_eq(x_12, x_6);
+lean_dec(x_12);
+if (x_13 == 0)
+{
+lean_dec(x_11);
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_1);
+return x_8;
+}
+else
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_63; lean_object* x_100; lean_object* x_101; 
+lean_inc(x_6);
+x_14 = l_Lean_Parser_ParserState_restore(x_8, x_7, x_6);
+lean_dec(x_7);
+x_15 = lean_ctor_get(x_14, 0);
 lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_15, x_9);
+x_16 = lean_array_get_size(x_15);
 lean_dec(x_15);
-if (x_16 == 0)
+lean_inc(x_1);
+x_100 = l_Lean_Parser_tokenFn(x_1, x_14);
+x_101 = lean_ctor_get(x_100, 3);
+lean_inc(x_101);
+if (lean_obj_tag(x_101) == 0)
 {
-lean_dec(x_14);
-lean_dec(x_12);
-lean_dec(x_10);
-lean_dec(x_9);
-lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_11;
-}
-else
+lean_object* x_102; lean_object* x_103; 
+x_102 = lean_ctor_get(x_100, 0);
+lean_inc(x_102);
+x_103 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_102);
+lean_dec(x_102);
+if (lean_obj_tag(x_103) == 2)
 {
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_66; lean_object* x_103; lean_object* x_104; 
-lean_inc(x_9);
-x_17 = l_Lean_Parser_ParserState_restore(x_11, x_10, x_9);
-lean_dec(x_10);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_array_get_size(x_18);
-lean_dec(x_18);
-lean_inc(x_2);
-x_103 = l_Lean_Parser_tokenFn(x_2, x_17);
-x_104 = lean_ctor_get(x_103, 3);
+lean_object* x_104; lean_object* x_105; uint8_t x_106; 
+x_104 = lean_ctor_get(x_103, 1);
 lean_inc(x_104);
-if (lean_obj_tag(x_104) == 0)
-{
-lean_object* x_105; lean_object* x_106; 
-x_105 = lean_ctor_get(x_103, 0);
-lean_inc(x_105);
-x_106 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_105);
-lean_dec(x_105);
-if (lean_obj_tag(x_106) == 2)
-{
-lean_object* x_107; lean_object* x_108; uint8_t x_109; 
-x_107 = lean_ctor_get(x_106, 1);
-lean_inc(x_107);
-lean_dec(x_106);
-x_108 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
-x_109 = lean_string_dec_eq(x_107, x_108);
-lean_dec(x_107);
-if (x_109 == 0)
-{
-lean_object* x_110; lean_object* x_111; 
-x_110 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_9);
-x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_110, x_9);
-x_66 = x_111;
-goto block_102;
-}
-else
-{
-x_66 = x_103;
-goto block_102;
-}
-}
-else
-{
-lean_object* x_112; lean_object* x_113; 
-lean_dec(x_106);
-x_112 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_9);
-x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_112, x_9);
-x_66 = x_113;
-goto block_102;
-}
-}
-else
-{
-lean_object* x_114; lean_object* x_115; 
+lean_dec(x_103);
+x_105 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__3;
+x_106 = lean_string_dec_eq(x_104, x_105);
 lean_dec(x_104);
-x_114 = l_Lean_Parser_Level_paren___elambda__1___closed__11;
-lean_inc(x_9);
-x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_114, x_9);
-x_66 = x_115;
-goto block_102;
+if (x_106 == 0)
+{
+lean_object* x_107; lean_object* x_108; 
+x_107 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_6);
+x_108 = l_Lean_Parser_ParserState_mkErrorsAt(x_100, x_107, x_6);
+x_63 = x_108;
+goto block_99;
 }
-block_58:
+else
 {
-lean_object* x_21; 
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
+x_63 = x_100;
+goto block_99;
+}
+}
+else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_22 = l_Lean_Parser_termParser___closed__2;
-x_23 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_24 = l_Lean_Parser_categoryParserFn(x_22, x_23, x_2, x_20);
+lean_object* x_109; lean_object* x_110; 
+lean_dec(x_103);
+x_109 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_6);
+x_110 = l_Lean_Parser_ParserState_mkErrorsAt(x_100, x_109, x_6);
+x_63 = x_110;
+goto block_99;
+}
+}
+else
+{
+lean_object* x_111; lean_object* x_112; 
+lean_dec(x_101);
+x_111 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__10;
+lean_inc(x_6);
+x_112 = l_Lean_Parser_ParserState_mkErrorsAt(x_100, x_111, x_6);
+x_63 = x_112;
+goto block_99;
+}
+block_55:
+{
+lean_object* x_18; 
+x_18 = lean_ctor_get(x_17, 3);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
+{
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_19 = l_Lean_Parser_termParser___closed__2;
+x_20 = lean_unsigned_to_nat(0u);
+lean_inc(x_1);
+x_21 = l_Lean_Parser_categoryParser___elambda__1(x_19, x_20, x_1, x_17);
+x_22 = lean_ctor_get(x_21, 3);
+lean_inc(x_22);
+if (lean_obj_tag(x_22) == 0)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_23 = lean_ctor_get(x_21, 1);
+lean_inc(x_23);
+x_24 = l_Lean_Parser_tokenFn(x_1, x_21);
 x_25 = lean_ctor_get(x_24, 3);
 lean_inc(x_25);
 if (lean_obj_tag(x_25) == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_26 = lean_ctor_get(x_24, 1);
+lean_object* x_26; lean_object* x_27; 
+x_26 = lean_ctor_get(x_24, 0);
 lean_inc(x_26);
-x_27 = l_Lean_Parser_tokenFn(x_2, x_24);
-x_28 = lean_ctor_get(x_27, 3);
+x_27 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_26);
+lean_dec(x_26);
+if (lean_obj_tag(x_27) == 2)
+{
+lean_object* x_28; lean_object* x_29; uint8_t x_30; 
+x_28 = lean_ctor_get(x_27, 1);
 lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
+lean_dec(x_27);
+x_29 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__4;
+x_30 = lean_string_dec_eq(x_28, x_29);
+lean_dec(x_28);
+if (x_30 == 0)
 {
-lean_object* x_29; lean_object* x_30; 
-x_29 = lean_ctor_get(x_27, 0);
-lean_inc(x_29);
-x_30 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_29);
-lean_dec(x_29);
-if (lean_obj_tag(x_30) == 2)
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_31 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_31, x_23);
+x_33 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
+x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_16);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_11, x_6);
+lean_dec(x_6);
+return x_35;
+}
+else
 {
-lean_object* x_31; lean_object* x_32; uint8_t x_33; 
-x_31 = lean_ctor_get(x_30, 1);
-lean_inc(x_31);
-lean_dec(x_30);
-x_32 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__5;
-x_33 = lean_string_dec_eq(x_31, x_32);
-lean_dec(x_31);
-if (x_33 == 0)
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_34 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_26);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_23);
 x_36 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
-x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_19);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_14, x_9);
-lean_dec(x_9);
+x_37 = l_Lean_Parser_ParserState_mkNode(x_24, x_36, x_16);
+x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_11, x_6);
+lean_dec(x_6);
 return x_38;
 }
+}
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-lean_dec(x_26);
-x_39 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkNode(x_27, x_39, x_19);
-x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_14, x_9);
-lean_dec(x_9);
-return x_41;
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_27);
+x_39 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_39, x_23);
+x_41 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
+x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_16);
+x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_11, x_6);
+lean_dec(x_6);
+return x_43;
 }
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-lean_dec(x_30);
-x_42 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_42, x_26);
-x_44 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
-x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_19);
-x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_14, x_9);
-lean_dec(x_9);
-return x_46;
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_25);
+x_44 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__7;
+x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_24, x_44, x_23);
+x_46 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
+x_47 = l_Lean_Parser_ParserState_mkNode(x_45, x_46, x_16);
+x_48 = l_Lean_Parser_mergeOrElseErrors(x_47, x_11, x_6);
+lean_dec(x_6);
+return x_48;
 }
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
-lean_dec(x_28);
-x_47 = l_Lean_Parser_Level_paren___elambda__1___closed__8;
-x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_47, x_26);
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+lean_dec(x_22);
+lean_dec(x_1);
 x_49 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
-x_50 = l_Lean_Parser_ParserState_mkNode(x_48, x_49, x_19);
-x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_14, x_9);
-lean_dec(x_9);
+x_50 = l_Lean_Parser_ParserState_mkNode(x_21, x_49, x_16);
+x_51 = l_Lean_Parser_mergeOrElseErrors(x_50, x_11, x_6);
+lean_dec(x_6);
 return x_51;
 }
 }
 else
 {
 lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-lean_dec(x_25);
-lean_dec(x_2);
+lean_dec(x_18);
+lean_dec(x_1);
 x_52 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
-x_53 = l_Lean_Parser_ParserState_mkNode(x_24, x_52, x_19);
-x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_14, x_9);
-lean_dec(x_9);
+x_53 = l_Lean_Parser_ParserState_mkNode(x_17, x_52, x_16);
+x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_11, x_6);
+lean_dec(x_6);
 return x_54;
 }
 }
-else
+block_62:
 {
-lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-lean_dec(x_21);
-lean_dec(x_2);
-x_55 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2;
-x_56 = l_Lean_Parser_ParserState_mkNode(x_20, x_55, x_19);
-x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_14, x_9);
+if (lean_obj_tag(x_59) == 0)
+{
+lean_dec(x_58);
+lean_dec(x_57);
 lean_dec(x_9);
-return x_57;
-}
-}
-block_65:
-{
-if (lean_obj_tag(x_62) == 0)
-{
-lean_dec(x_61);
-lean_dec(x_60);
-lean_dec(x_12);
-x_20 = x_59;
-goto block_58;
+x_17 = x_56;
+goto block_55;
 }
 else
 {
-lean_object* x_63; lean_object* x_64; 
-lean_dec(x_59);
-x_63 = l_Array_shrink___main___rarg(x_60, x_19);
-lean_inc(x_9);
-if (lean_is_scalar(x_12)) {
- x_64 = lean_alloc_ctor(0, 4, 0);
+lean_object* x_60; lean_object* x_61; 
+lean_dec(x_56);
+x_60 = l_Array_shrink___main___rarg(x_57, x_16);
+lean_inc(x_6);
+if (lean_is_scalar(x_9)) {
+ x_61 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_64 = x_12;
+ x_61 = x_9;
 }
-lean_ctor_set(x_64, 0, x_63);
-lean_ctor_set(x_64, 1, x_9);
-lean_ctor_set(x_64, 2, x_61);
-lean_ctor_set(x_64, 3, x_62);
-x_20 = x_64;
-goto block_58;
+lean_ctor_set(x_61, 0, x_60);
+lean_ctor_set(x_61, 1, x_6);
+lean_ctor_set(x_61, 2, x_58);
+lean_ctor_set(x_61, 3, x_59);
+x_17 = x_61;
+goto block_55;
 }
 }
-block_102:
+block_99:
 {
-lean_object* x_67; 
-x_67 = lean_ctor_get(x_66, 3);
+lean_object* x_64; 
+x_64 = lean_ctor_get(x_63, 3);
+lean_inc(x_64);
+if (lean_obj_tag(x_64) == 0)
+{
+lean_object* x_65; lean_object* x_66; 
+lean_inc(x_1);
+x_65 = l_Lean_Parser_ident___elambda__1(x_1, x_63);
+x_66 = lean_ctor_get(x_65, 3);
+lean_inc(x_66);
+if (lean_obj_tag(x_66) == 0)
+{
+lean_object* x_67; lean_object* x_68; lean_object* x_69; 
+x_67 = lean_ctor_get(x_65, 1);
 lean_inc(x_67);
-if (lean_obj_tag(x_67) == 0)
-{
-lean_object* x_68; lean_object* x_69; 
-lean_inc(x_2);
-x_68 = lean_apply_3(x_5, x_1, x_2, x_66);
+lean_inc(x_1);
+x_68 = l_Lean_Parser_tokenFn(x_1, x_65);
 x_69 = lean_ctor_get(x_68, 3);
 lean_inc(x_69);
 if (lean_obj_tag(x_69) == 0)
 {
-lean_object* x_70; lean_object* x_71; lean_object* x_72; 
-x_70 = lean_ctor_get(x_68, 1);
+lean_object* x_70; lean_object* x_71; 
+x_70 = lean_ctor_get(x_68, 0);
 lean_inc(x_70);
-lean_inc(x_2);
-x_71 = l_Lean_Parser_tokenFn(x_2, x_68);
-x_72 = lean_ctor_get(x_71, 3);
-lean_inc(x_72);
-if (lean_obj_tag(x_72) == 0)
-{
-lean_object* x_73; lean_object* x_74; 
-x_73 = lean_ctor_get(x_71, 0);
-lean_inc(x_73);
-x_74 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_73);
-lean_dec(x_73);
-if (lean_obj_tag(x_74) == 2)
-{
-lean_object* x_75; lean_object* x_76; uint8_t x_77; 
-x_75 = lean_ctor_get(x_74, 1);
-lean_inc(x_75);
-lean_dec(x_74);
-x_76 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
-x_77 = lean_string_dec_eq(x_75, x_76);
-lean_dec(x_75);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; 
-x_78 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_78, x_70);
-x_80 = lean_ctor_get(x_79, 0);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_79, 2);
-lean_inc(x_81);
-x_82 = lean_ctor_get(x_79, 3);
-lean_inc(x_82);
-x_59 = x_79;
-x_60 = x_80;
-x_61 = x_81;
-x_62 = x_82;
-goto block_65;
-}
-else
-{
-lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+x_71 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_70);
 lean_dec(x_70);
-x_83 = lean_ctor_get(x_71, 0);
-lean_inc(x_83);
-x_84 = lean_ctor_get(x_71, 2);
-lean_inc(x_84);
-x_85 = lean_ctor_get(x_71, 3);
-lean_inc(x_85);
-x_59 = x_71;
-x_60 = x_83;
-x_61 = x_84;
-x_62 = x_85;
-goto block_65;
-}
-}
-else
+if (lean_obj_tag(x_71) == 2)
 {
-lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
-lean_dec(x_74);
-x_86 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_86, x_70);
-x_88 = lean_ctor_get(x_87, 0);
-lean_inc(x_88);
-x_89 = lean_ctor_get(x_87, 2);
-lean_inc(x_89);
-x_90 = lean_ctor_get(x_87, 3);
-lean_inc(x_90);
-x_59 = x_87;
-x_60 = x_88;
-x_61 = x_89;
-x_62 = x_90;
-goto block_65;
-}
-}
-else
-{
-lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+lean_object* x_72; lean_object* x_73; uint8_t x_74; 
+x_72 = lean_ctor_get(x_71, 1);
+lean_inc(x_72);
+lean_dec(x_71);
+x_73 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__5;
+x_74 = lean_string_dec_eq(x_72, x_73);
 lean_dec(x_72);
-x_91 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
-x_92 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_91, x_70);
-x_93 = lean_ctor_get(x_92, 0);
-lean_inc(x_93);
-x_94 = lean_ctor_get(x_92, 2);
-lean_inc(x_94);
-x_95 = lean_ctor_get(x_92, 3);
-lean_inc(x_95);
+if (x_74 == 0)
+{
+lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
+x_75 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_75, x_67);
+x_77 = lean_ctor_get(x_76, 0);
+lean_inc(x_77);
+x_78 = lean_ctor_get(x_76, 2);
+lean_inc(x_78);
+x_79 = lean_ctor_get(x_76, 3);
+lean_inc(x_79);
+x_56 = x_76;
+x_57 = x_77;
+x_58 = x_78;
+x_59 = x_79;
+goto block_62;
+}
+else
+{
+lean_object* x_80; lean_object* x_81; lean_object* x_82; 
+lean_dec(x_67);
+x_80 = lean_ctor_get(x_68, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_68, 2);
+lean_inc(x_81);
+x_82 = lean_ctor_get(x_68, 3);
+lean_inc(x_82);
+x_56 = x_68;
+x_57 = x_80;
+x_58 = x_81;
+x_59 = x_82;
+goto block_62;
+}
+}
+else
+{
+lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; 
+lean_dec(x_71);
+x_83 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_84 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_83, x_67);
+x_85 = lean_ctor_get(x_84, 0);
+lean_inc(x_85);
+x_86 = lean_ctor_get(x_84, 2);
+lean_inc(x_86);
+x_87 = lean_ctor_get(x_84, 3);
+lean_inc(x_87);
+x_56 = x_84;
+x_57 = x_85;
+x_58 = x_86;
+x_59 = x_87;
+goto block_62;
+}
+}
+else
+{
+lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
+lean_dec(x_69);
+x_88 = l_Lean_Parser_Term_haveAssign___elambda__1___closed__8;
+x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_68, x_88, x_67);
+x_90 = lean_ctor_get(x_89, 0);
+lean_inc(x_90);
+x_91 = lean_ctor_get(x_89, 2);
+lean_inc(x_91);
+x_92 = lean_ctor_get(x_89, 3);
+lean_inc(x_92);
+x_56 = x_89;
+x_57 = x_90;
+x_58 = x_91;
 x_59 = x_92;
-x_60 = x_93;
-x_61 = x_94;
-x_62 = x_95;
-goto block_65;
+goto block_62;
+}
+}
+else
+{
+lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+lean_dec(x_66);
+x_93 = lean_ctor_get(x_65, 0);
+lean_inc(x_93);
+x_94 = lean_ctor_get(x_65, 2);
+lean_inc(x_94);
+x_95 = lean_ctor_get(x_65, 3);
+lean_inc(x_95);
+x_56 = x_65;
+x_57 = x_93;
+x_58 = x_94;
+x_59 = x_95;
+goto block_62;
 }
 }
 else
 {
 lean_object* x_96; lean_object* x_97; lean_object* x_98; 
-lean_dec(x_69);
-x_96 = lean_ctor_get(x_68, 0);
+lean_dec(x_64);
+x_96 = lean_ctor_get(x_63, 0);
 lean_inc(x_96);
-x_97 = lean_ctor_get(x_68, 2);
+x_97 = lean_ctor_get(x_63, 2);
 lean_inc(x_97);
-x_98 = lean_ctor_get(x_68, 3);
+x_98 = lean_ctor_get(x_63, 3);
 lean_inc(x_98);
-x_59 = x_68;
-x_60 = x_96;
-x_61 = x_97;
-x_62 = x_98;
-goto block_65;
-}
-}
-else
-{
-lean_object* x_99; lean_object* x_100; lean_object* x_101; 
-lean_dec(x_67);
-lean_dec(x_5);
-lean_dec(x_1);
-x_99 = lean_ctor_get(x_66, 0);
-lean_inc(x_99);
-x_100 = lean_ctor_get(x_66, 2);
-lean_inc(x_100);
-x_101 = lean_ctor_get(x_66, 3);
-lean_inc(x_101);
-x_59 = x_66;
-x_60 = x_99;
-x_61 = x_100;
-x_62 = x_101;
-goto block_65;
+x_56 = x_63;
+x_57 = x_96;
+x_58 = x_97;
+x_59 = x_98;
+goto block_62;
 }
 }
 }
@@ -30652,7 +30111,7 @@ lean_object* _init_l_Lean_Parser_Term_namedArgument___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Level_ident___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_Term_haveAssign___closed__1;
@@ -30664,7 +30123,7 @@ lean_object* _init_l_Lean_Parser_Term_namedArgument___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__1;
 x_2 = l_Lean_Parser_Term_namedArgument___closed__1;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
@@ -30706,7 +30165,7 @@ lean_object* _init_l_Lean_Parser_Term_namedArgument___closed__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_namedArgument___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_namedArgument___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -30730,202 +30189,198 @@ x_1 = l_Lean_Parser_Term_namedArgument___closed__7;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_5 = lean_ctor_get(x_4, 0);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_17; lean_object* x_18; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_6 = lean_array_get_size(x_5);
+lean_inc(x_1);
+x_17 = l_Lean_Parser_Term_namedArgument___elambda__1(x_1, x_2);
+x_18 = lean_ctor_get(x_17, 3);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
+{
+x_6 = x_17;
+goto block_16;
+}
+else
+{
+lean_object* x_19; lean_object* x_20; uint8_t x_21; 
+x_19 = lean_ctor_get(x_18, 0);
+lean_inc(x_19);
+lean_dec(x_18);
+x_20 = lean_ctor_get(x_17, 1);
+lean_inc(x_20);
+x_21 = lean_nat_dec_eq(x_20, x_5);
+lean_dec(x_20);
+if (x_21 == 0)
+{
+lean_dec(x_19);
+x_6 = x_17;
+goto block_16;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_inc(x_5);
+x_22 = l_Lean_Parser_ParserState_restore(x_17, x_4, x_5);
+x_23 = l_Lean_Parser_termParser___closed__2;
+x_24 = l_Lean_Parser_appPrec;
+lean_inc(x_1);
+x_25 = l_Lean_Parser_categoryParser___elambda__1(x_23, x_24, x_1, x_22);
+x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_19, x_5);
+x_6 = x_26;
+goto block_16;
+}
+}
+block_16:
+{
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; uint8_t x_9; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+x_9 = lean_nat_dec_eq(x_5, x_8);
+lean_dec(x_8);
 lean_dec(x_5);
-x_7 = lean_ctor_get(x_4, 1);
-lean_inc(x_7);
-x_19 = lean_unsigned_to_nat(0u);
-lean_inc(x_3);
-x_20 = l_Lean_Parser_Term_namedArgument___elambda__1(x_19, x_3, x_4);
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
+if (x_9 == 0)
 {
-x_8 = x_20;
-goto block_18;
-}
-else
-{
-lean_object* x_22; lean_object* x_23; uint8_t x_24; 
-x_22 = lean_ctor_get(x_21, 0);
-lean_inc(x_22);
-lean_dec(x_21);
-x_23 = lean_ctor_get(x_20, 1);
-lean_inc(x_23);
-x_24 = lean_nat_dec_eq(x_23, x_7);
-lean_dec(x_23);
-if (x_24 == 0)
-{
-lean_dec(x_22);
-x_8 = x_20;
-goto block_18;
-}
-else
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_inc(x_7);
-x_25 = l_Lean_Parser_ParserState_restore(x_20, x_6, x_7);
-x_26 = l_Lean_Parser_termParser___closed__2;
-x_27 = l_Lean_Parser_appPrec;
-lean_inc(x_3);
-x_28 = l_Lean_Parser_categoryParserFn(x_26, x_27, x_3, x_25);
-x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_22, x_7);
-x_8 = x_29;
-goto block_18;
-}
-}
-block_18:
-{
-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; uint8_t x_11; 
-lean_dec(x_6);
-x_10 = lean_ctor_get(x_8, 1);
-lean_inc(x_10);
-x_11 = lean_nat_dec_eq(x_7, x_10);
-lean_dec(x_10);
-lean_dec(x_7);
-if (x_11 == 0)
-{
-x_4 = x_8;
+x_2 = x_6;
 goto _start;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_3);
-x_13 = l_Lean_Parser_manyAux___main___closed__1;
-x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_8, x_13);
-return x_14;
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_11 = l_Lean_Parser_manyAux___main___closed__1;
+x_12 = l_Lean_Parser_ParserState_mkUnexpectedError(x_6, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_15; uint8_t x_16; 
-lean_dec(x_9);
-lean_dec(x_3);
-x_15 = lean_ctor_get(x_8, 1);
-lean_inc(x_15);
-x_16 = lean_nat_dec_eq(x_7, x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
+lean_object* x_13; uint8_t x_14; 
 lean_dec(x_7);
-lean_dec(x_6);
-return x_8;
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_6, 1);
+lean_inc(x_13);
+x_14 = lean_nat_dec_eq(x_5, x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+return x_6;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Lean_Parser_ParserState_restore(x_8, x_6, x_7);
-lean_dec(x_6);
-return x_17;
-}
-}
-}
-}
-}
-lean_object* l_Lean_Parser_Term_app___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; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
+lean_object* x_15; 
+x_15 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
 lean_dec(x_4);
-x_6 = lean_ctor_get(x_3, 1);
-lean_inc(x_6);
-x_7 = lean_unsigned_to_nat(0u);
-lean_inc(x_2);
-x_8 = l_Lean_Parser_Term_namedArgument___elambda__1(x_7, x_2, x_3);
-x_9 = lean_ctor_get(x_8, 3);
-lean_inc(x_9);
-if (lean_obj_tag(x_9) == 0)
-{
-uint8_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
-lean_dec(x_6);
-x_10 = 1;
-x_11 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(x_10, x_1, x_2, x_8);
-x_12 = l_Lean_nullKind;
-lean_inc(x_5);
-x_13 = l_Lean_Parser_ParserState_mkNode(x_11, x_12, x_5);
-x_14 = l_Lean_mkAppStx___closed__8;
-x_15 = l_Lean_Parser_ParserState_mkTrailingNode(x_13, x_14, x_5);
-lean_dec(x_5);
 return x_15;
 }
-else
+}
+}
+}
+}
+lean_object* l_Lean_Parser_Term_app___elambda__1(lean_object* x_1, lean_object* x_2) {
+_start:
 {
-lean_object* x_16; lean_object* x_17; uint8_t x_18; 
-x_16 = lean_ctor_get(x_9, 0);
-lean_inc(x_16);
-lean_dec(x_9);
-x_17 = lean_ctor_get(x_8, 1);
-lean_inc(x_17);
-x_18 = lean_nat_dec_eq(x_17, x_6);
-lean_dec(x_17);
-if (x_18 == 0)
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-lean_dec(x_16);
-lean_dec(x_6);
-lean_dec(x_2);
-x_19 = l_Lean_nullKind;
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+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_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
-x_20 = l_Lean_Parser_ParserState_mkNode(x_8, x_19, x_5);
-x_21 = l_Lean_mkAppStx___closed__8;
-x_22 = l_Lean_Parser_ParserState_mkTrailingNode(x_20, x_21, x_5);
+lean_inc(x_1);
+x_6 = l_Lean_Parser_Term_namedArgument___elambda__1(x_1, x_2);
+x_7 = lean_ctor_get(x_6, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 lean_dec(x_5);
-return x_22;
+x_8 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(x_1, x_6);
+x_9 = l_Lean_nullKind;
+lean_inc(x_4);
+x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_4);
+x_11 = l_Lean_mkAppStx___closed__8;
+x_12 = l_Lean_Parser_ParserState_mkTrailingNode(x_10, x_11, x_4);
+lean_dec(x_4);
+return x_12;
 }
 else
 {
-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_inc(x_6);
-x_23 = l_Lean_Parser_ParserState_restore(x_8, x_5, x_6);
-x_24 = l_Lean_Parser_termParser___closed__2;
-x_25 = l_Lean_Parser_appPrec;
-lean_inc(x_2);
-x_26 = l_Lean_Parser_categoryParserFn(x_24, x_25, x_2, x_23);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_16, x_6);
-lean_dec(x_6);
-x_28 = lean_ctor_get(x_27, 3);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
+lean_object* x_13; lean_object* x_14; uint8_t x_15; 
+x_13 = lean_ctor_get(x_7, 0);
+lean_inc(x_13);
+lean_dec(x_7);
+x_14 = lean_ctor_get(x_6, 1);
+lean_inc(x_14);
+x_15 = lean_nat_dec_eq(x_14, x_5);
+lean_dec(x_14);
+if (x_15 == 0)
 {
-uint8_t x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_29 = 1;
-x_30 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(x_29, x_1, x_2, x_27);
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_13);
+lean_dec(x_5);
+lean_dec(x_1);
+x_16 = l_Lean_nullKind;
+lean_inc(x_4);
+x_17 = l_Lean_Parser_ParserState_mkNode(x_6, x_16, x_4);
+x_18 = l_Lean_mkAppStx___closed__8;
+x_19 = l_Lean_Parser_ParserState_mkTrailingNode(x_17, x_18, x_4);
+lean_dec(x_4);
+return x_19;
+}
+else
+{
+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_inc(x_5);
+x_20 = l_Lean_Parser_ParserState_restore(x_6, x_4, x_5);
+x_21 = l_Lean_Parser_termParser___closed__2;
+x_22 = l_Lean_Parser_appPrec;
+lean_inc(x_1);
+x_23 = l_Lean_Parser_categoryParser___elambda__1(x_21, x_22, x_1, x_20);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_13, x_5);
+lean_dec(x_5);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+if (lean_obj_tag(x_25) == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_26 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(x_1, x_24);
+x_27 = l_Lean_nullKind;
+lean_inc(x_4);
+x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_4);
+x_29 = l_Lean_mkAppStx___closed__8;
+x_30 = l_Lean_Parser_ParserState_mkTrailingNode(x_28, x_29, x_4);
+lean_dec(x_4);
+return x_30;
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_25);
+lean_dec(x_1);
 x_31 = l_Lean_nullKind;
-lean_inc(x_5);
-x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_5);
+lean_inc(x_4);
+x_32 = l_Lean_Parser_ParserState_mkNode(x_24, x_31, x_4);
 x_33 = l_Lean_mkAppStx___closed__8;
-x_34 = l_Lean_Parser_ParserState_mkTrailingNode(x_32, x_33, x_5);
-lean_dec(x_5);
+x_34 = l_Lean_Parser_ParserState_mkTrailingNode(x_32, x_33, x_4);
+lean_dec(x_4);
 return x_34;
 }
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_28);
-lean_dec(x_2);
-x_35 = l_Lean_nullKind;
-lean_inc(x_5);
-x_36 = l_Lean_Parser_ParserState_mkNode(x_27, x_35, x_5);
-x_37 = l_Lean_mkAppStx___closed__8;
-x_38 = l_Lean_Parser_ParserState_mkTrailingNode(x_36, x_37, x_5);
-lean_dec(x_5);
-return x_38;
-}
 }
 }
 }
@@ -30933,52 +30388,41 @@ return x_38;
 lean_object* _init_l_Lean_Parser_Term_app___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 1;
-x_2 = l_Lean_Parser_termParser___closed__2;
-x_3 = l_Lean_Parser_appPrec;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_app___closed__2() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_1 = l_Lean_Parser_Term_namedArgument;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_Term_app___closed__1;
+x_3 = l_Lean_Parser_Term_namedPattern___closed__2;
 x_4 = lean_ctor_get(x_3, 0);
 lean_inc(x_4);
 x_5 = l_Lean_Parser_orelseInfo(x_2, x_4);
 return x_5;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_app___closed__3() {
+lean_object* _init_l_Lean_Parser_Term_app___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_mkAppStx___closed__8;
-x_2 = l_Lean_Parser_Term_app___closed__2;
+x_2 = l_Lean_Parser_Term_app___closed__1;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
 }
 }
+lean_object* _init_l_Lean_Parser_Term_app___closed__3() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_app___elambda__1), 2, 0);
+return x_1;
+}
+}
 lean_object* _init_l_Lean_Parser_Term_app___closed__4() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_app___elambda__1___boxed), 3, 0);
-return x_1;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_app___closed__5() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_app___closed__3;
-x_2 = l_Lean_Parser_Term_app___closed__4;
+x_1 = l_Lean_Parser_Term_app___closed__2;
+x_2 = l_Lean_Parser_Term_app___closed__3;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -30989,37 +30433,17 @@ lean_object* _init_l_Lean_Parser_Term_app() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Term_app___closed__5;
+x_1 = l_Lean_Parser_Term_app___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; 
-x_5 = lean_unbox(x_1);
-lean_dec(x_1);
-x_6 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(x_5, x_2, x_3, x_4);
-lean_dec(x_2);
-return x_6;
-}
-}
-lean_object* l_Lean_Parser_Term_app___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Lean_Parser_Term_app___elambda__1(x_1, x_2, x_3);
-lean_dec(x_1);
-return x_4;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Term_app(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_mkAppStx___closed__8;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_mkAppStx___closed__8;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_app;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -31031,7 +30455,7 @@ _start:
 lean_object* x_2; lean_object* x_3; lean_object* x_4; uint8_t x_5; 
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_2);
+x_3 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_2);
 lean_dec(x_2);
 x_4 = l_Lean_Parser_Term_type___elambda__1___closed__2;
 lean_inc(x_3);
@@ -31044,7 +30468,7 @@ x_7 = l_Lean_Syntax_isOfKind(x_3, x_6);
 if (x_7 == 0)
 {
 lean_object* x_8; lean_object* x_9; 
-x_8 = l_Lean_Parser_checkLeadingFn___closed__1;
+x_8 = l_Lean_Parser_checkStackTopFn___closed__1;
 x_9 = l_Lean_Parser_ParserState_mkUnexpectedError(x_1, x_8);
 return x_9;
 }
@@ -31060,19 +30484,19 @@ return x_1;
 }
 }
 }
-lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1(lean_object* x_1) {
 _start:
 {
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Term_checkIsSort___elambda__1___rarg), 1, 0);
-return x_3;
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Term_checkIsSort___elambda__1___rarg), 1, 0);
+return x_2;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_checkIsSort___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_checkIsSort___elambda__1___boxed), 2, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_checkIsSort___elambda__1___boxed), 1, 0);
 return x_1;
 }
 }
@@ -31096,17 +30520,16 @@ x_1 = l_Lean_Parser_Term_checkIsSort___closed__2;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1___boxed(lean_object* x_1) {
 _start:
 {
-lean_object* x_3; 
-x_3 = l_Lean_Parser_Term_checkIsSort___elambda__1(x_1, x_2);
-lean_dec(x_2);
+lean_object* x_2; 
+x_2 = l_Lean_Parser_Term_checkIsSort___elambda__1(x_1);
 lean_dec(x_1);
-return x_3;
+return x_2;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Term_sortApp___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -31114,17 +30537,17 @@ x_1 = lean_mk_string("sortApp");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_Term_sortApp___elambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_mkAppStx___closed__6;
-x_2 = l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Term_sortApp___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_sortApp___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Term_sortApp___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
@@ -31140,8 +30563,8 @@ if (lean_obj_tag(x_6) == 0)
 lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_7 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
 x_8 = l_Lean_Parser_appPrec;
-x_9 = l_Lean_Parser_categoryParserFn(x_7, x_8, x_1, x_5);
-x_10 = l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2;
+x_9 = l_Lean_Parser_categoryParser___elambda__1(x_7, x_8, x_1, x_5);
+x_10 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2;
 x_11 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_10, x_4);
 lean_dec(x_4);
 return x_11;
@@ -31151,37 +30574,18 @@ else
 lean_object* x_12; lean_object* x_13; 
 lean_dec(x_6);
 lean_dec(x_1);
-x_12 = l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2;
+x_12 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2;
 x_13 = l_Lean_Parser_ParserState_mkTrailingNode(x_5, x_12, x_4);
 lean_dec(x_4);
 return x_13;
 }
 }
 }
-lean_object* l_Lean_Parser_Term_sortApp___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sortApp___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Term_sortApp___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 1;
-x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4;
-x_3 = l_Lean_Parser_appPrec;
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_sortApp___closed__2() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_sortApp___closed__1;
+x_1 = l_Lean_Parser_Level_max___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_epsilonInfo;
@@ -31189,30 +30593,30 @@ x_4 = l_Lean_Parser_andthenInfo(x_3, x_2);
 return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_sortApp___closed__3() {
+lean_object* _init_l_Lean_Parser_Term_sortApp___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2;
-x_2 = l_Lean_Parser_Term_sortApp___closed__2;
+x_1 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2;
+x_2 = l_Lean_Parser_Term_sortApp___closed__1;
 x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
 }
 }
+lean_object* _init_l_Lean_Parser_Term_sortApp___closed__3() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sortApp___elambda__1), 2, 0);
+return x_1;
+}
+}
 lean_object* _init_l_Lean_Parser_Term_sortApp___closed__4() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sortApp___elambda__1___boxed), 1, 0);
-return x_1;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_sortApp___closed__5() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_sortApp___closed__3;
-x_2 = l_Lean_Parser_Term_sortApp___closed__4;
+x_1 = l_Lean_Parser_Term_sortApp___closed__2;
+x_2 = l_Lean_Parser_Term_sortApp___closed__3;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -31223,26 +30627,17 @@ lean_object* _init_l_Lean_Parser_Term_sortApp() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Term_sortApp___closed__5;
+x_1 = l_Lean_Parser_Term_sortApp___closed__4;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_sortApp___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Term_sortApp___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Term_sortApp(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_sortApp;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -31278,27 +30673,6 @@ return x_2;
 lean_object* _init_l_Lean_Parser_Term_proj___elambda__1___closed__4() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; 
-x_1 = 1;
-x_2 = l_Lean_fieldIdxKind___closed__1;
-x_3 = l_Lean_Parser_fieldIdx___closed__1;
-x_4 = 1;
-x_5 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_proj___elambda__1___closed__5() {
-_start:
-{
-uint8_t x_1; lean_object* x_2; 
-x_1 = 1;
-x_2 = l_Lean_Parser_ident(x_1);
-return x_2;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_proj___elambda__1___closed__6() {
-_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_proj___elambda__1___closed__3;
@@ -31306,17 +30680,17 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_proj___elambda__1___closed__7() {
+lean_object* _init_l_Lean_Parser_Term_proj___elambda__1___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_proj___elambda__1___closed__6;
+x_1 = l_Lean_Parser_Term_proj___elambda__1___closed__4;
 x_2 = l_Lean_Parser_symbolNoWsFn___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_proj___elambda__1___closed__8() {
+lean_object* _init_l_Lean_Parser_Term_proj___elambda__1___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -31325,208 +30699,198 @@ x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_Term_proj___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_proj___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_11; lean_object* x_42; uint8_t x_43; 
-x_4 = l_Lean_Parser_Term_proj___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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_39; uint8_t x_40; 
+x_3 = l_Lean_Parser_fieldIdx___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_proj___elambda__1___closed__5;
-x_7 = lean_ctor_get(x_6, 1);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-x_10 = lean_array_get_size(x_8);
-x_42 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_8);
-lean_dec(x_8);
-x_43 = l_Lean_Parser_checkTailNoWs(x_42);
-lean_dec(x_42);
-if (x_43 == 0)
-{
-lean_object* x_44; lean_object* x_45; 
-lean_dec(x_9);
-x_44 = l_Lean_Parser_Term_proj___elambda__1___closed__7;
-x_45 = l_Lean_Parser_ParserState_mkError(x_3, x_44);
-x_11 = x_45;
-goto block_41;
-}
-else
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_46 = lean_ctor_get(x_2, 0);
-lean_inc(x_46);
-x_47 = lean_ctor_get(x_46, 0);
-lean_inc(x_47);
-lean_dec(x_46);
-x_48 = l_Lean_Parser_Term_proj___elambda__1___closed__3;
-x_49 = l_Lean_Parser_Term_proj___elambda__1___closed__7;
-x_50 = lean_unsigned_to_nat(0u);
-x_51 = l_Lean_Parser_strAux___main(x_48, x_49, x_50, x_2, x_3);
-x_52 = lean_ctor_get(x_51, 3);
-lean_inc(x_52);
-if (lean_obj_tag(x_52) == 0)
-{
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-lean_inc_n(x_9, 2);
-lean_inc(x_47);
-x_53 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_53, 0, x_47);
-lean_ctor_set(x_53, 1, x_9);
-lean_ctor_set(x_53, 2, x_9);
-x_54 = l_Lean_Parser_Term_proj___elambda__1___closed__8;
-x_55 = lean_nat_add(x_9, x_54);
-lean_inc(x_55);
-x_56 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_56, 0, x_47);
-lean_ctor_set(x_56, 1, x_55);
-lean_ctor_set(x_56, 2, x_55);
-x_57 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_57, 0, x_53);
-lean_ctor_set(x_57, 1, x_9);
-lean_ctor_set(x_57, 2, x_56);
-x_58 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_58, 0, x_57);
-x_59 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_59, 0, x_58);
-lean_ctor_set(x_59, 1, x_48);
-x_60 = l_Lean_Parser_ParserState_pushSyntax(x_51, x_59);
-x_11 = x_60;
-goto block_41;
-}
-else
-{
-lean_dec(x_52);
-lean_dec(x_47);
-lean_dec(x_9);
-x_11 = x_51;
-goto block_41;
-}
-}
-block_41:
-{
-lean_object* x_12; 
-x_12 = lean_ctor_get(x_11, 3);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_31; lean_object* x_32; 
-x_13 = lean_ctor_get(x_11, 0);
-lean_inc(x_13);
-x_14 = lean_array_get_size(x_13);
-lean_dec(x_13);
-x_15 = lean_ctor_get(x_11, 1);
-lean_inc(x_15);
-lean_inc(x_2);
-lean_inc(x_1);
-x_31 = lean_apply_3(x_5, x_1, x_2, x_11);
-x_32 = lean_ctor_get(x_31, 3);
-lean_inc(x_32);
-if (lean_obj_tag(x_32) == 0)
-{
-x_16 = x_31;
-goto block_30;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; uint8_t x_35; 
-x_33 = lean_ctor_get(x_32, 0);
-lean_inc(x_33);
-lean_dec(x_32);
-x_34 = lean_ctor_get(x_31, 1);
-lean_inc(x_34);
-x_35 = lean_nat_dec_eq(x_34, x_15);
-lean_dec(x_34);
-if (x_35 == 0)
-{
-lean_dec(x_33);
-x_16 = x_31;
-goto block_30;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_inc(x_15);
-x_36 = l_Lean_Parser_ParserState_restore(x_31, x_14, x_15);
-x_37 = l_Lean_Parser_fieldIdxFn(x_2, x_36);
-x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_33, x_15);
-x_16 = x_38;
-goto block_30;
-}
-}
-block_30:
-{
-lean_object* x_17; 
-x_17 = lean_ctor_get(x_16, 3);
-lean_inc(x_17);
-if (lean_obj_tag(x_17) == 0)
-{
-lean_object* x_18; lean_object* x_19; 
-lean_dec(x_15);
-lean_dec(x_14);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-x_18 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
-x_19 = l_Lean_Parser_ParserState_mkTrailingNode(x_16, x_18, x_10);
-lean_dec(x_10);
-return x_19;
-}
-else
-{
-lean_object* x_20; lean_object* x_21; uint8_t x_22; 
-x_20 = lean_ctor_get(x_17, 0);
-lean_inc(x_20);
-lean_dec(x_17);
-x_21 = lean_ctor_get(x_16, 1);
-lean_inc(x_21);
-x_22 = lean_nat_dec_eq(x_21, x_15);
-lean_dec(x_21);
-if (x_22 == 0)
-{
-lean_object* x_23; lean_object* x_24; 
-lean_dec(x_20);
-lean_dec(x_15);
-lean_dec(x_14);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-x_23 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
-x_24 = l_Lean_Parser_ParserState_mkTrailingNode(x_16, x_23, x_10);
-lean_dec(x_10);
-return x_24;
-}
-else
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-lean_inc(x_15);
-x_25 = l_Lean_Parser_ParserState_restore(x_16, x_14, x_15);
-lean_dec(x_14);
-x_26 = lean_apply_3(x_7, x_1, x_2, x_25);
-x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_20, x_15);
-lean_dec(x_15);
-x_28 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
-x_29 = l_Lean_Parser_ParserState_mkTrailingNode(x_27, x_28, x_10);
-lean_dec(x_10);
-return x_29;
-}
-}
-}
-}
-else
-{
-lean_object* x_39; lean_object* x_40; 
-lean_dec(x_12);
-lean_dec(x_7);
+x_6 = lean_ctor_get(x_2, 1);
+lean_inc(x_6);
+x_7 = lean_array_get_size(x_5);
+x_39 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_5);
 lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_39 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
-x_40 = l_Lean_Parser_ParserState_mkTrailingNode(x_11, x_39, x_10);
+x_40 = l_Lean_Parser_checkTailNoWs(x_39);
+lean_dec(x_39);
+if (x_40 == 0)
+{
+lean_object* x_41; lean_object* x_42; 
+lean_dec(x_6);
+x_41 = l_Lean_Parser_Term_proj___elambda__1___closed__5;
+x_42 = l_Lean_Parser_ParserState_mkError(x_2, x_41);
+x_8 = x_42;
+goto block_38;
+}
+else
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_43 = lean_ctor_get(x_1, 0);
+lean_inc(x_43);
+x_44 = lean_ctor_get(x_43, 0);
+lean_inc(x_44);
+lean_dec(x_43);
+x_45 = l_Lean_Parser_Term_proj___elambda__1___closed__3;
+x_46 = l_Lean_Parser_Term_proj___elambda__1___closed__5;
+x_47 = lean_unsigned_to_nat(0u);
+x_48 = l_Lean_Parser_strAux___main(x_45, x_46, x_47, x_1, x_2);
+x_49 = lean_ctor_get(x_48, 3);
+lean_inc(x_49);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_inc_n(x_6, 2);
+lean_inc(x_44);
+x_50 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_50, 0, x_44);
+lean_ctor_set(x_50, 1, x_6);
+lean_ctor_set(x_50, 2, x_6);
+x_51 = l_Lean_Parser_Term_proj___elambda__1___closed__6;
+x_52 = lean_nat_add(x_6, x_51);
+lean_inc(x_52);
+x_53 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_53, 0, x_44);
+lean_ctor_set(x_53, 1, x_52);
+lean_ctor_set(x_53, 2, x_52);
+x_54 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_54, 0, x_50);
+lean_ctor_set(x_54, 1, x_6);
+lean_ctor_set(x_54, 2, x_53);
+x_55 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_55, 0, x_54);
+x_56 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_56, 0, x_55);
+lean_ctor_set(x_56, 1, x_45);
+x_57 = l_Lean_Parser_ParserState_pushSyntax(x_48, x_56);
+x_8 = x_57;
+goto block_38;
+}
+else
+{
+lean_dec(x_49);
+lean_dec(x_44);
+lean_dec(x_6);
+x_8 = x_48;
+goto block_38;
+}
+}
+block_38:
+{
+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_28; lean_object* x_29; 
+x_10 = lean_ctor_get(x_8, 0);
+lean_inc(x_10);
+x_11 = lean_array_get_size(x_10);
 lean_dec(x_10);
-return x_40;
+x_12 = lean_ctor_get(x_8, 1);
+lean_inc(x_12);
+lean_inc(x_1);
+x_28 = lean_apply_2(x_4, x_1, x_8);
+x_29 = lean_ctor_get(x_28, 3);
+lean_inc(x_29);
+if (lean_obj_tag(x_29) == 0)
+{
+x_13 = x_28;
+goto block_27;
+}
+else
+{
+lean_object* x_30; lean_object* x_31; uint8_t x_32; 
+x_30 = lean_ctor_get(x_29, 0);
+lean_inc(x_30);
+lean_dec(x_29);
+x_31 = lean_ctor_get(x_28, 1);
+lean_inc(x_31);
+x_32 = lean_nat_dec_eq(x_31, x_12);
+lean_dec(x_31);
+if (x_32 == 0)
+{
+lean_dec(x_30);
+x_13 = x_28;
+goto block_27;
+}
+else
+{
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_inc(x_12);
+x_33 = l_Lean_Parser_ParserState_restore(x_28, x_11, x_12);
+x_34 = l_Lean_Parser_fieldIdxFn(x_1, x_33);
+x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_30, x_12);
+x_13 = x_35;
+goto block_27;
+}
+}
+block_27:
+{
+lean_object* x_14; 
+x_14 = lean_ctor_get(x_13, 3);
+lean_inc(x_14);
+if (lean_obj_tag(x_14) == 0)
+{
+lean_object* x_15; lean_object* x_16; 
+lean_dec(x_12);
+lean_dec(x_11);
+lean_dec(x_1);
+x_15 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
+x_16 = l_Lean_Parser_ParserState_mkTrailingNode(x_13, x_15, x_7);
+lean_dec(x_7);
+return x_16;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; uint8_t x_19; 
+x_17 = lean_ctor_get(x_14, 0);
+lean_inc(x_17);
+lean_dec(x_14);
+x_18 = lean_ctor_get(x_13, 1);
+lean_inc(x_18);
+x_19 = lean_nat_dec_eq(x_18, x_12);
+lean_dec(x_18);
+if (x_19 == 0)
+{
+lean_object* x_20; lean_object* x_21; 
+lean_dec(x_17);
+lean_dec(x_12);
+lean_dec(x_11);
+lean_dec(x_1);
+x_20 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
+x_21 = l_Lean_Parser_ParserState_mkTrailingNode(x_13, x_20, x_7);
+lean_dec(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_inc(x_12);
+x_22 = l_Lean_Parser_ParserState_restore(x_13, x_11, x_12);
+lean_dec(x_11);
+x_23 = l_Lean_Parser_ident___elambda__1(x_1, x_22);
+x_24 = l_Lean_Parser_mergeOrElseErrors(x_23, x_17, x_12);
+lean_dec(x_12);
+x_25 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
+x_26 = l_Lean_Parser_ParserState_mkTrailingNode(x_24, x_25, x_7);
+lean_dec(x_7);
+return x_26;
+}
+}
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; 
+lean_dec(x_9);
+lean_dec(x_4);
+lean_dec(x_1);
+x_36 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
+x_37 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_36, x_7);
+lean_dec(x_7);
+return x_37;
 }
 }
 }
@@ -31565,60 +30929,48 @@ lean_object* _init_l_Lean_Parser_Term_proj___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_proj___elambda__1___closed__4;
+x_1 = l_Lean_Parser_ident;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_fieldIdx___closed__2;
-x_4 = l_Lean_Parser_orelseInfo(x_2, x_3);
+x_3 = l_Lean_Parser_fieldIdx___closed__4;
+x_4 = l_Lean_Parser_orelseInfo(x_3, x_2);
 return x_4;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_proj___closed__5() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_proj___elambda__1___closed__5;
-x_2 = lean_ctor_get(x_1, 0);
-lean_inc(x_2);
-x_3 = l_Lean_Parser_Term_proj___closed__4;
-x_4 = l_Lean_Parser_orelseInfo(x_3, x_2);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_proj___closed__3;
+x_2 = l_Lean_Parser_Term_proj___closed__4;
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_proj___closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_proj___closed__3;
+x_1 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
 x_2 = l_Lean_Parser_Term_proj___closed__5;
-x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
 return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_proj___closed__7() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
-x_2 = l_Lean_Parser_Term_proj___closed__6;
-x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
-return x_3;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_proj___elambda__1), 2, 0);
+return x_1;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_proj___closed__8() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_proj___elambda__1), 3, 0);
-return x_1;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_proj___closed__9() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_proj___closed__7;
-x_2 = l_Lean_Parser_Term_proj___closed__8;
+x_1 = l_Lean_Parser_Term_proj___closed__6;
+x_2 = l_Lean_Parser_Term_proj___closed__7;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -31629,17 +30981,17 @@ lean_object* _init_l_Lean_Parser_Term_proj() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Term_proj___closed__9;
+x_1 = l_Lean_Parser_Term_proj___closed__8;
 return x_1;
 }
 }
 lean_object* l___regBuiltinParser_Lean_Parser_Term_proj(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_proj___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_proj;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -31674,22 +31026,22 @@ x_4 = l_Lean_Parser_Term_unicodeInfixR(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_arrow___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_arrow___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_arrow___elambda__1___closed__3;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_arrow___elambda__1___closed__3;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_arrow___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_arrow___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_arrow___closed__1() {
@@ -31708,7 +31060,7 @@ lean_object* _init_l_Lean_Parser_Term_arrow___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_arrow___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_arrow___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -31735,16 +31087,16 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_arrow(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_arrow___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_arrow___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_arrow;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Term_arrayRef___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -31752,17 +31104,17 @@ x_1 = lean_mk_string("arrayRef");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_Term_arrayRef___elambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_mkAppStx___closed__6;
-x_2 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__3() {
+lean_object* _init_l_Lean_Parser_Term_arrayRef___elambda__1___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -31772,7 +31124,7 @@ x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__4() {
+lean_object* _init_l_Lean_Parser_Term_arrayRef___elambda__1___closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -31781,7 +31133,7 @@ x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Term_arrayRef___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_39; uint8_t x_40; 
@@ -31790,7 +31142,7 @@ lean_inc(x_3);
 x_4 = lean_ctor_get(x_2, 1);
 lean_inc(x_4);
 x_5 = lean_array_get_size(x_3);
-x_39 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_3);
+x_39 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_3);
 lean_dec(x_3);
 x_40 = l_Lean_Parser_checkTailNoWs(x_39);
 lean_dec(x_39);
@@ -31798,7 +31150,7 @@ if (x_40 == 0)
 {
 lean_object* x_41; lean_object* x_42; 
 lean_dec(x_4);
-x_41 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__3;
+x_41 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__3;
 x_42 = l_Lean_Parser_ParserState_mkError(x_2, x_41);
 x_6 = x_42;
 goto block_38;
@@ -31812,7 +31164,7 @@ x_44 = lean_ctor_get(x_43, 0);
 lean_inc(x_44);
 lean_dec(x_43);
 x_45 = l_Lean_Parser_Term_listLit___elambda__1___closed__5;
-x_46 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__3;
+x_46 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__3;
 x_47 = lean_unsigned_to_nat(0u);
 x_48 = l_Lean_Parser_strAux___main(x_45, x_46, x_47, x_1, x_2);
 x_49 = lean_ctor_get(x_48, 3);
@@ -31826,7 +31178,7 @@ x_50 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_50, 0, x_44);
 lean_ctor_set(x_50, 1, x_4);
 lean_ctor_set(x_50, 2, x_4);
-x_51 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__4;
+x_51 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__4;
 x_52 = lean_nat_add(x_4, x_51);
 lean_inc(x_52);
 x_53 = lean_alloc_ctor(0, 3, 0);
@@ -31866,7 +31218,7 @@ lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11;
 x_8 = l_Lean_Parser_termParser___closed__2;
 x_9 = lean_unsigned_to_nat(0u);
 lean_inc(x_1);
-x_10 = l_Lean_Parser_categoryParserFn(x_8, x_9, x_1, x_6);
+x_10 = l_Lean_Parser_categoryParser___elambda__1(x_8, x_9, x_1, x_6);
 x_11 = lean_ctor_get(x_10, 3);
 lean_inc(x_11);
 if (lean_obj_tag(x_11) == 0)
@@ -31882,7 +31234,7 @@ if (lean_obj_tag(x_14) == 0)
 lean_object* x_15; lean_object* x_16; 
 x_15 = lean_ctor_get(x_13, 0);
 lean_inc(x_15);
-x_16 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_15);
+x_16 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_15);
 lean_dec(x_15);
 if (lean_obj_tag(x_16) == 2)
 {
@@ -31898,7 +31250,7 @@ if (x_19 == 0)
 lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
 x_20 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
 x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12);
-x_22 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+x_22 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 x_23 = l_Lean_Parser_ParserState_mkTrailingNode(x_21, x_22, x_5);
 lean_dec(x_5);
 return x_23;
@@ -31907,7 +31259,7 @@ else
 {
 lean_object* x_24; lean_object* x_25; 
 lean_dec(x_12);
-x_24 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+x_24 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 x_25 = l_Lean_Parser_ParserState_mkTrailingNode(x_13, x_24, x_5);
 lean_dec(x_5);
 return x_25;
@@ -31919,7 +31271,7 @@ lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29;
 lean_dec(x_16);
 x_26 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
 x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12);
-x_28 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+x_28 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 x_29 = l_Lean_Parser_ParserState_mkTrailingNode(x_27, x_28, x_5);
 lean_dec(x_5);
 return x_29;
@@ -31931,7 +31283,7 @@ lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33;
 lean_dec(x_14);
 x_30 = l_Lean_Parser_Term_listLit___elambda__1___closed__9;
 x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12);
-x_32 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+x_32 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 x_33 = l_Lean_Parser_ParserState_mkTrailingNode(x_31, x_32, x_5);
 lean_dec(x_5);
 return x_33;
@@ -31942,7 +31294,7 @@ else
 lean_object* x_34; lean_object* x_35; 
 lean_dec(x_11);
 lean_dec(x_1);
-x_34 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+x_34 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 x_35 = l_Lean_Parser_ParserState_mkTrailingNode(x_10, x_34, x_5);
 lean_dec(x_5);
 return x_35;
@@ -31953,7 +31305,7 @@ else
 lean_object* x_36; lean_object* x_37; 
 lean_dec(x_7);
 lean_dec(x_1);
-x_36 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+x_36 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
 x_37 = l_Lean_Parser_ParserState_mkTrailingNode(x_6, x_36, x_5);
 lean_dec(x_5);
 return x_37;
@@ -31961,14 +31313,6 @@ return x_37;
 }
 }
 }
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Term_arrayRef___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__1() {
 _start:
 {
@@ -31982,60 +31326,37 @@ return x_3;
 lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__2() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = 1;
-x_2 = l_Lean_Parser_termParser___closed__2;
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = l_Lean_Parser_categoryParser(x_1, x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_arrayRef___closed__1;
+x_2 = l_Lean_Parser_Term_instBinder___closed__2;
+x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__3() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_arrayRef___closed__2;
-x_2 = lean_ctor_get(x_1, 0);
-lean_inc(x_2);
-x_3 = l_Lean_Parser_Term_listLit___closed__4;
-x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
-return x_4;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
+x_2 = l_Lean_Parser_Term_arrayRef___closed__2;
+x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__4() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_arrayRef___closed__1;
-x_2 = l_Lean_Parser_Term_arrayRef___closed__3;
-x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
-return x_3;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_arrayRef___elambda__1), 2, 0);
+return x_1;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+x_1 = l_Lean_Parser_Term_arrayRef___closed__3;
 x_2 = l_Lean_Parser_Term_arrayRef___closed__4;
-x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
-return x_3;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__6() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_arrayRef___elambda__1___boxed), 1, 0);
-return x_1;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__7() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_arrayRef___closed__5;
-x_2 = l_Lean_Parser_Term_arrayRef___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);
@@ -32046,32 +31367,23 @@ lean_object* _init_l_Lean_Parser_Term_arrayRef() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Term_arrayRef___closed__7;
+x_1 = l_Lean_Parser_Term_arrayRef___closed__5;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Term_arrayRef___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Term_arrayRef(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_arrayRef;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__1() {
+lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -32079,17 +31391,17 @@ x_1 = lean_mk_string("dollar");
 return x_1;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2() {
+lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_mkAppStx___closed__6;
-x_2 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__1;
+x_2 = l_Lean_Parser_Term_dollar___elambda__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__3() {
+lean_object* _init_l_Lean_Parser_Term_dollar___elambda__1___closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -32097,7 +31409,7 @@ x_1 = lean_mk_string("space expected");
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_dollar___elambda__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Parser_Term_dollar___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
@@ -32108,13 +31420,13 @@ lean_inc(x_4);
 x_5 = lean_array_get_size(x_3);
 lean_dec(x_3);
 lean_inc(x_1);
-x_6 = l_Lean_Parser_dollarSymbol___elambda__1___rarg(x_1, x_2);
+x_6 = l_Lean_Parser_dollarSymbol___elambda__1(x_1, x_2);
 x_7 = lean_ctor_get(x_6, 3);
 lean_inc(x_7);
 if (lean_obj_tag(x_7) == 0)
 {
 lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_8 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__3;
+x_8 = l_Lean_Parser_Term_dollar___elambda__1___closed__3;
 x_9 = l_Lean_Parser_checkWsBeforeFn(x_8, x_1, x_6);
 x_10 = lean_ctor_get(x_9, 3);
 lean_inc(x_10);
@@ -32124,8 +31436,8 @@ lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean
 lean_dec(x_4);
 x_11 = l_Lean_Parser_termParser___closed__2;
 x_12 = lean_unsigned_to_nat(0u);
-x_13 = l_Lean_Parser_categoryParserFn(x_11, x_12, x_1, x_9);
-x_14 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+x_13 = l_Lean_Parser_categoryParser___elambda__1(x_11, x_12, x_1, x_9);
+x_14 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
 x_15 = l_Lean_Parser_ParserState_mkTrailingNode(x_13, x_14, x_5);
 lean_dec(x_5);
 return x_15;
@@ -32146,7 +31458,7 @@ lean_dec(x_19);
 x_20 = l_Array_shrink___main___rarg(x_17, x_5);
 lean_ctor_set(x_9, 1, x_4);
 lean_ctor_set(x_9, 0, x_20);
-x_21 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+x_21 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
 x_22 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_21, x_5);
 lean_dec(x_5);
 return x_22;
@@ -32165,7 +31477,7 @@ lean_ctor_set(x_26, 0, x_25);
 lean_ctor_set(x_26, 1, x_4);
 lean_ctor_set(x_26, 2, x_24);
 lean_ctor_set(x_26, 3, x_10);
-x_27 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+x_27 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
 x_28 = l_Lean_Parser_ParserState_mkTrailingNode(x_26, x_27, x_5);
 lean_dec(x_5);
 return x_28;
@@ -32184,8 +31496,8 @@ lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean
 lean_dec(x_4);
 x_30 = l_Lean_Parser_termParser___closed__2;
 x_31 = lean_unsigned_to_nat(0u);
-x_32 = l_Lean_Parser_categoryParserFn(x_30, x_31, x_1, x_6);
-x_33 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+x_32 = l_Lean_Parser_categoryParser___elambda__1(x_30, x_31, x_1, x_6);
+x_33 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
 x_34 = l_Lean_Parser_ParserState_mkTrailingNode(x_32, x_33, x_5);
 lean_dec(x_5);
 return x_34;
@@ -32206,7 +31518,7 @@ lean_dec(x_38);
 x_39 = l_Array_shrink___main___rarg(x_36, x_5);
 lean_ctor_set(x_6, 1, x_4);
 lean_ctor_set(x_6, 0, x_39);
-x_40 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+x_40 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
 x_41 = l_Lean_Parser_ParserState_mkTrailingNode(x_6, x_40, x_5);
 lean_dec(x_5);
 return x_41;
@@ -32225,7 +31537,7 @@ lean_ctor_set(x_45, 0, x_44);
 lean_ctor_set(x_45, 1, x_4);
 lean_ctor_set(x_45, 2, x_43);
 lean_ctor_set(x_45, 3, x_29);
-x_46 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+x_46 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
 x_47 = l_Lean_Parser_ParserState_mkTrailingNode(x_45, x_46, x_5);
 lean_dec(x_5);
 return x_47;
@@ -32234,28 +31546,11 @@ return x_47;
 }
 }
 }
-lean_object* l_Lean_Parser_Term_dollar___elambda__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Term_dollar___elambda__1___rarg), 2, 0);
-return x_2;
-}
-}
 lean_object* _init_l_Lean_Parser_Term_dollar___closed__1() {
 _start:
 {
-uint8_t x_1; lean_object* x_2; 
-x_1 = 1;
-x_2 = l_Lean_Parser_dollarSymbol(x_1);
-return x_2;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_dollar___closed__2() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_dollar___closed__1;
+x_1 = l_Lean_Parser_dollarSymbol;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
 x_3 = l_Lean_Parser_epsilonInfo;
@@ -32263,42 +31558,42 @@ x_4 = l_Lean_Parser_andthenInfo(x_2, x_3);
 return x_4;
 }
 }
-lean_object* _init_l_Lean_Parser_Term_dollar___closed__3() {
+lean_object* _init_l_Lean_Parser_Term_dollar___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Parser_Term_arrayRef___closed__2;
+x_1 = l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___closed__2;
 x_2 = lean_ctor_get(x_1, 0);
 lean_inc(x_2);
-x_3 = l_Lean_Parser_Term_dollar___closed__2;
+x_3 = l_Lean_Parser_Term_dollar___closed__1;
 x_4 = l_Lean_Parser_andthenInfo(x_3, x_2);
 return x_4;
 }
 }
+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_Term_dollar___elambda__1___closed__2;
+x_2 = l_Lean_Parser_Term_dollar___closed__2;
+x_3 = l_Lean_Parser_nodeInfo(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___elambda__1___rarg___closed__2;
-x_2 = l_Lean_Parser_Term_dollar___closed__3;
-x_3 = l_Lean_Parser_nodeInfo(x_1, x_2);
-return x_3;
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_dollar___elambda__1), 2, 0);
+return x_1;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_dollar___closed__5() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_dollar___elambda__1___boxed), 1, 0);
-return x_1;
-}
-}
-lean_object* _init_l_Lean_Parser_Term_dollar___closed__6() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Parser_Term_dollar___closed__4;
-x_2 = l_Lean_Parser_Term_dollar___closed__5;
+x_1 = l_Lean_Parser_Term_dollar___closed__3;
+x_2 = l_Lean_Parser_Term_dollar___closed__4;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -32309,26 +31604,17 @@ lean_object* _init_l_Lean_Parser_Term_dollar() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Term_dollar___closed__6;
+x_1 = l_Lean_Parser_Term_dollar___closed__5;
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Term_dollar___elambda__1___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Parser_Term_dollar___elambda__1(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
 lean_object* l___regBuiltinParser_Lean_Parser_Term_dollar(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_dollar___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_dollar;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -32401,198 +31687,188 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_dollarProj___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_dollarProj___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_4 = l_Lean_Parser_Term_proj___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_3 = l_Lean_Parser_fieldIdx___closed__2;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = l_Lean_Parser_Term_proj___elambda__1___closed__5;
-x_7 = lean_ctor_get(x_6, 1);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_array_get_size(x_8);
-lean_dec(x_8);
-x_41 = lean_ctor_get(x_3, 1);
-lean_inc(x_41);
-lean_inc(x_2);
-x_42 = l_Lean_Parser_tokenFn(x_2, x_3);
-x_43 = lean_ctor_get(x_42, 3);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; lean_object* x_45; 
-x_44 = lean_ctor_get(x_42, 0);
-lean_inc(x_44);
-x_45 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_44);
-lean_dec(x_44);
-if (lean_obj_tag(x_45) == 2)
-{
-lean_object* x_46; lean_object* x_47; uint8_t x_48; 
-x_46 = lean_ctor_get(x_45, 1);
-lean_inc(x_46);
-lean_dec(x_45);
-x_47 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__4;
-x_48 = lean_string_dec_eq(x_46, x_47);
-lean_dec(x_46);
-if (x_48 == 0)
-{
-lean_object* x_49; lean_object* x_50; 
-x_49 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7;
-x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_49, x_41);
-x_10 = x_50;
-goto block_40;
-}
-else
-{
-lean_dec(x_41);
-x_10 = x_42;
-goto block_40;
-}
-}
-else
-{
-lean_object* x_51; lean_object* x_52; 
-lean_dec(x_45);
-x_51 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7;
-x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_51, x_41);
-x_10 = x_52;
-goto block_40;
-}
-}
-else
-{
-lean_object* x_53; lean_object* x_54; 
-lean_dec(x_43);
-x_53 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7;
-x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_53, x_41);
-x_10 = x_54;
-goto block_40;
-}
-block_40:
-{
-lean_object* x_11; 
-x_11 = lean_ctor_get(x_10, 3);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_30; lean_object* x_31; 
-x_12 = lean_ctor_get(x_10, 0);
-lean_inc(x_12);
-x_13 = lean_array_get_size(x_12);
-lean_dec(x_12);
-x_14 = lean_ctor_get(x_10, 1);
-lean_inc(x_14);
-lean_inc(x_2);
-lean_inc(x_1);
-x_30 = lean_apply_3(x_5, x_1, x_2, x_10);
-x_31 = lean_ctor_get(x_30, 3);
-lean_inc(x_31);
-if (lean_obj_tag(x_31) == 0)
-{
-x_15 = x_30;
-goto block_29;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; uint8_t x_34; 
-x_32 = lean_ctor_get(x_31, 0);
-lean_inc(x_32);
-lean_dec(x_31);
-x_33 = lean_ctor_get(x_30, 1);
-lean_inc(x_33);
-x_34 = lean_nat_dec_eq(x_33, x_14);
-lean_dec(x_33);
-if (x_34 == 0)
-{
-lean_dec(x_32);
-x_15 = x_30;
-goto block_29;
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-lean_inc(x_14);
-x_35 = l_Lean_Parser_ParserState_restore(x_30, x_13, x_14);
-x_36 = l_Lean_Parser_fieldIdxFn(x_2, x_35);
-x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_32, x_14);
-x_15 = x_37;
-goto block_29;
-}
-}
-block_29:
-{
-lean_object* x_16; 
-x_16 = lean_ctor_get(x_15, 3);
-lean_inc(x_16);
-if (lean_obj_tag(x_16) == 0)
-{
-lean_object* x_17; lean_object* x_18; 
-lean_dec(x_14);
-lean_dec(x_13);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-x_17 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
-x_18 = l_Lean_Parser_ParserState_mkTrailingNode(x_15, x_17, x_9);
-lean_dec(x_9);
-return x_18;
-}
-else
-{
-lean_object* x_19; lean_object* x_20; uint8_t x_21; 
-x_19 = lean_ctor_get(x_16, 0);
-lean_inc(x_19);
-lean_dec(x_16);
-x_20 = lean_ctor_get(x_15, 1);
-lean_inc(x_20);
-x_21 = lean_nat_dec_eq(x_20, x_14);
-lean_dec(x_20);
-if (x_21 == 0)
-{
-lean_object* x_22; lean_object* x_23; 
-lean_dec(x_19);
-lean_dec(x_14);
-lean_dec(x_13);
-lean_dec(x_7);
-lean_dec(x_2);
-lean_dec(x_1);
-x_22 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
-x_23 = l_Lean_Parser_ParserState_mkTrailingNode(x_15, x_22, x_9);
-lean_dec(x_9);
-return x_23;
-}
-else
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-lean_inc(x_14);
-x_24 = l_Lean_Parser_ParserState_restore(x_15, x_13, x_14);
-lean_dec(x_13);
-x_25 = lean_apply_3(x_7, x_1, x_2, x_24);
-x_26 = l_Lean_Parser_mergeOrElseErrors(x_25, x_19, x_14);
-lean_dec(x_14);
-x_27 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
-x_28 = l_Lean_Parser_ParserState_mkTrailingNode(x_26, x_27, x_9);
-lean_dec(x_9);
-return x_28;
-}
-}
-}
-}
-else
-{
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_11);
-lean_dec(x_7);
+x_6 = lean_array_get_size(x_5);
 lean_dec(x_5);
-lean_dec(x_2);
-lean_dec(x_1);
-x_38 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
-x_39 = l_Lean_Parser_ParserState_mkTrailingNode(x_10, x_38, x_9);
+x_38 = lean_ctor_get(x_2, 1);
+lean_inc(x_38);
+lean_inc(x_1);
+x_39 = l_Lean_Parser_tokenFn(x_1, x_2);
+x_40 = lean_ctor_get(x_39, 3);
+lean_inc(x_40);
+if (lean_obj_tag(x_40) == 0)
+{
+lean_object* x_41; lean_object* x_42; 
+x_41 = lean_ctor_get(x_39, 0);
+lean_inc(x_41);
+x_42 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_41);
+lean_dec(x_41);
+if (lean_obj_tag(x_42) == 2)
+{
+lean_object* x_43; lean_object* x_44; uint8_t x_45; 
+x_43 = lean_ctor_get(x_42, 1);
+lean_inc(x_43);
+lean_dec(x_42);
+x_44 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__4;
+x_45 = lean_string_dec_eq(x_43, x_44);
+lean_dec(x_43);
+if (x_45 == 0)
+{
+lean_object* x_46; lean_object* x_47; 
+x_46 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7;
+x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_46, x_38);
+x_7 = x_47;
+goto block_37;
+}
+else
+{
+lean_dec(x_38);
+x_7 = x_39;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_48; lean_object* x_49; 
+lean_dec(x_42);
+x_48 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7;
+x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_48, x_38);
+x_7 = x_49;
+goto block_37;
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; 
+lean_dec(x_40);
+x_50 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7;
+x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_50, x_38);
+x_7 = x_51;
+goto block_37;
+}
+block_37:
+{
+lean_object* x_8; 
+x_8 = lean_ctor_get(x_7, 3);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_27; lean_object* x_28; 
+x_9 = lean_ctor_get(x_7, 0);
+lean_inc(x_9);
+x_10 = lean_array_get_size(x_9);
 lean_dec(x_9);
-return x_39;
+x_11 = lean_ctor_get(x_7, 1);
+lean_inc(x_11);
+lean_inc(x_1);
+x_27 = lean_apply_2(x_4, x_1, x_7);
+x_28 = lean_ctor_get(x_27, 3);
+lean_inc(x_28);
+if (lean_obj_tag(x_28) == 0)
+{
+x_12 = x_27;
+goto block_26;
+}
+else
+{
+lean_object* x_29; lean_object* x_30; uint8_t x_31; 
+x_29 = lean_ctor_get(x_28, 0);
+lean_inc(x_29);
+lean_dec(x_28);
+x_30 = lean_ctor_get(x_27, 1);
+lean_inc(x_30);
+x_31 = lean_nat_dec_eq(x_30, x_11);
+lean_dec(x_30);
+if (x_31 == 0)
+{
+lean_dec(x_29);
+x_12 = x_27;
+goto block_26;
+}
+else
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_inc(x_11);
+x_32 = l_Lean_Parser_ParserState_restore(x_27, x_10, x_11);
+x_33 = l_Lean_Parser_fieldIdxFn(x_1, x_32);
+x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_29, x_11);
+x_12 = x_34;
+goto block_26;
+}
+}
+block_26:
+{
+lean_object* x_13; 
+x_13 = lean_ctor_get(x_12, 3);
+lean_inc(x_13);
+if (lean_obj_tag(x_13) == 0)
+{
+lean_object* x_14; lean_object* x_15; 
+lean_dec(x_11);
+lean_dec(x_10);
+lean_dec(x_1);
+x_14 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
+x_15 = l_Lean_Parser_ParserState_mkTrailingNode(x_12, x_14, x_6);
+lean_dec(x_6);
+return x_15;
+}
+else
+{
+lean_object* x_16; lean_object* x_17; uint8_t x_18; 
+x_16 = lean_ctor_get(x_13, 0);
+lean_inc(x_16);
+lean_dec(x_13);
+x_17 = lean_ctor_get(x_12, 1);
+lean_inc(x_17);
+x_18 = lean_nat_dec_eq(x_17, x_11);
+lean_dec(x_17);
+if (x_18 == 0)
+{
+lean_object* x_19; lean_object* x_20; 
+lean_dec(x_16);
+lean_dec(x_11);
+lean_dec(x_10);
+lean_dec(x_1);
+x_19 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
+x_20 = l_Lean_Parser_ParserState_mkTrailingNode(x_12, x_19, x_6);
+lean_dec(x_6);
+return x_20;
+}
+else
+{
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_inc(x_11);
+x_21 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_11);
+lean_dec(x_10);
+x_22 = l_Lean_Parser_ident___elambda__1(x_1, x_21);
+x_23 = l_Lean_Parser_mergeOrElseErrors(x_22, x_16, x_11);
+lean_dec(x_11);
+x_24 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
+x_25 = l_Lean_Parser_ParserState_mkTrailingNode(x_23, x_24, x_6);
+lean_dec(x_6);
+return x_25;
+}
+}
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_8);
+lean_dec(x_4);
+lean_dec(x_1);
+x_35 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
+x_36 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_35, x_6);
+lean_dec(x_6);
+return x_36;
 }
 }
 }
@@ -32612,7 +31888,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Parser_Term_dollarProj___closed__1;
-x_2 = l_Lean_Parser_Term_proj___closed__5;
+x_2 = l_Lean_Parser_Term_proj___closed__4;
 x_3 = l_Lean_Parser_andthenInfo(x_1, x_2);
 return x_3;
 }
@@ -32631,7 +31907,7 @@ lean_object* _init_l_Lean_Parser_Term_dollarProj___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_dollarProj___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_dollarProj___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -32658,10 +31934,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_dollarProj(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_dollarProj;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -32716,286 +31992,286 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2(uint8_t x_1, uint8_t x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2(uint8_t x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-x_9 = lean_ctor_get(x_8, 0);
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_array_get_size(x_7);
+lean_dec(x_7);
+x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
-x_10 = lean_array_get_size(x_9);
-lean_dec(x_9);
-x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_5);
+x_10 = l_Lean_Parser_Term_letDecl___elambda__1(x_5, x_6);
+x_11 = lean_ctor_get(x_10, 3);
 lean_inc(x_11);
-x_12 = lean_unsigned_to_nat(0u);
-lean_inc(x_7);
-x_13 = l_Lean_Parser_Term_letDecl___elambda__1(x_12, x_7, x_8);
-x_14 = lean_ctor_get(x_13, 3);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_29; lean_object* x_46; lean_object* x_47; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_12 = lean_ctor_get(x_10, 0);
+lean_inc(x_12);
+x_13 = lean_array_get_size(x_12);
+lean_dec(x_12);
+x_14 = lean_ctor_get(x_10, 1);
 lean_inc(x_14);
-if (lean_obj_tag(x_14) == 0)
+lean_inc(x_5);
+x_46 = l_Lean_Parser_tokenFn(x_5, x_10);
+x_47 = lean_ctor_get(x_46, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_32; lean_object* x_49; lean_object* x_50; 
-lean_dec(x_11);
-lean_dec(x_10);
-x_15 = lean_ctor_get(x_13, 0);
-lean_inc(x_15);
-x_16 = lean_array_get_size(x_15);
-lean_dec(x_15);
-x_17 = lean_ctor_get(x_13, 1);
-lean_inc(x_17);
-lean_inc(x_7);
-x_49 = l_Lean_Parser_tokenFn(x_7, x_13);
-x_50 = lean_ctor_get(x_49, 3);
+lean_object* x_48; lean_object* x_49; 
+x_48 = lean_ctor_get(x_46, 0);
+lean_inc(x_48);
+x_49 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_48);
+lean_dec(x_48);
+if (lean_obj_tag(x_49) == 2)
+{
+lean_object* x_50; lean_object* x_51; uint8_t x_52; 
+x_50 = lean_ctor_get(x_49, 1);
 lean_inc(x_50);
-if (lean_obj_tag(x_50) == 0)
-{
-lean_object* x_51; lean_object* x_52; 
-x_51 = lean_ctor_get(x_49, 0);
-lean_inc(x_51);
-x_52 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_51);
-lean_dec(x_51);
-if (lean_obj_tag(x_52) == 2)
-{
-lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_53 = lean_ctor_get(x_52, 1);
-lean_inc(x_53);
-lean_dec(x_52);
-x_54 = l_Lean_Parser_Term_have___elambda__1___closed__7;
-x_55 = lean_string_dec_eq(x_53, x_54);
-lean_dec(x_53);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; 
-x_56 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-lean_inc(x_17);
-x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_56, x_17);
-x_32 = x_57;
-goto block_48;
-}
-else
-{
-x_32 = x_49;
-goto block_48;
-}
-}
-else
-{
-lean_object* x_58; lean_object* x_59; 
-lean_dec(x_52);
-x_58 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-lean_inc(x_17);
-x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_58, x_17);
-x_32 = x_59;
-goto block_48;
-}
-}
-else
-{
-lean_object* x_60; lean_object* x_61; 
+lean_dec(x_49);
+x_51 = l_Lean_Parser_Term_have___elambda__1___closed__7;
+x_52 = lean_string_dec_eq(x_50, x_51);
 lean_dec(x_50);
-x_60 = l_Lean_Parser_Term_have___elambda__1___closed__10;
-lean_inc(x_17);
-x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_60, x_17);
-x_32 = x_61;
-goto block_48;
+if (x_52 == 0)
+{
+lean_object* x_53; lean_object* x_54; 
+x_53 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+lean_inc(x_14);
+x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_46, x_53, x_14);
+x_29 = x_54;
+goto block_45;
 }
-block_31:
+else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = l_Lean_nullKind;
-x_20 = l_Lean_Parser_ParserState_mkTrailingNode(x_18, x_19, x_16);
-x_21 = lean_ctor_get(x_20, 3);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
+x_29 = x_46;
+goto block_45;
+}
+}
+else
 {
-lean_dec(x_17);
-lean_dec(x_16);
+lean_object* x_55; lean_object* x_56; 
+lean_dec(x_49);
+x_55 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+lean_inc(x_14);
+x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_46, x_55, x_14);
+x_29 = x_56;
+goto block_45;
+}
+}
+else
 {
-uint8_t _tmp_4 = x_2;
-lean_object* _tmp_7 = x_20;
-x_5 = _tmp_4;
-x_8 = _tmp_7;
+lean_object* x_57; lean_object* x_58; 
+lean_dec(x_47);
+x_57 = l_Lean_Parser_Term_have___elambda__1___closed__10;
+lean_inc(x_14);
+x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_46, x_57, x_14);
+x_29 = x_58;
+goto block_45;
+}
+block_28:
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_16 = l_Lean_nullKind;
+lean_inc(x_13);
+x_17 = l_Lean_Parser_ParserState_mkNode(x_15, x_16, x_13);
+x_18 = lean_ctor_get(x_17, 3);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
+{
+lean_dec(x_14);
+lean_dec(x_13);
+{
+uint8_t _tmp_3 = x_1;
+lean_object* _tmp_5 = x_17;
+x_4 = _tmp_3;
+x_6 = _tmp_5;
 }
 goto _start;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+lean_dec(x_18);
+lean_dec(x_5);
+x_20 = l_Lean_Parser_ParserState_restore(x_17, x_13, x_14);
+lean_dec(x_13);
+x_21 = lean_ctor_get(x_20, 0);
+lean_inc(x_21);
+x_22 = lean_array_get_size(x_21);
 lean_dec(x_21);
-lean_dec(x_7);
-x_23 = l_Lean_Parser_ParserState_restore(x_20, x_16, x_17);
-lean_dec(x_16);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_array_get_size(x_24);
-lean_dec(x_24);
-x_26 = lean_nat_sub(x_25, x_3);
-lean_dec(x_25);
-x_27 = lean_unsigned_to_nat(1u);
-x_28 = lean_nat_dec_eq(x_26, x_27);
-lean_dec(x_26);
-if (x_28 == 0)
+x_23 = lean_nat_sub(x_22, x_2);
+lean_dec(x_22);
+x_24 = lean_unsigned_to_nat(1u);
+x_25 = lean_nat_dec_eq(x_23, x_24);
+lean_dec(x_23);
+if (x_25 == 0)
 {
-lean_object* x_29; 
-x_29 = l_Lean_Parser_ParserState_mkNode(x_23, x_19, x_3);
-return x_29;
+lean_object* x_26; 
+x_26 = l_Lean_Parser_ParserState_mkNode(x_20, x_16, x_2);
+return x_26;
 }
 else
 {
-if (x_4 == 0)
+if (x_3 == 0)
+{
+lean_object* x_27; 
+x_27 = l_Lean_Parser_ParserState_mkNode(x_20, x_16, x_2);
+return x_27;
+}
+else
+{
+lean_dec(x_2);
+return x_20;
+}
+}
+}
+}
+block_45:
 {
 lean_object* x_30; 
-x_30 = l_Lean_Parser_ParserState_mkNode(x_23, x_19, x_3);
-return x_30;
-}
-else
+x_30 = lean_ctor_get(x_29, 3);
+lean_inc(x_30);
+if (lean_obj_tag(x_30) == 0)
 {
-lean_dec(x_3);
-return x_23;
-}
-}
-}
-}
-block_48:
-{
-lean_object* x_33; 
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_31 = lean_ctor_get(x_29, 1);
+lean_inc(x_31);
+lean_inc(x_5);
+x_32 = l_Lean_Parser_tokenFn(x_5, x_29);
 x_33 = lean_ctor_get(x_32, 3);
 lean_inc(x_33);
 if (lean_obj_tag(x_33) == 0)
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-x_34 = lean_ctor_get(x_32, 1);
+lean_object* x_34; lean_object* x_35; 
+x_34 = lean_ctor_get(x_32, 0);
 lean_inc(x_34);
-lean_inc(x_7);
-x_35 = l_Lean_Parser_tokenFn(x_7, x_32);
-x_36 = lean_ctor_get(x_35, 3);
-lean_inc(x_36);
-if (lean_obj_tag(x_36) == 0)
-{
-lean_object* x_37; lean_object* x_38; 
-x_37 = lean_ctor_get(x_35, 0);
-lean_inc(x_37);
-x_38 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_37);
-lean_dec(x_37);
-if (lean_obj_tag(x_38) == 2)
-{
-lean_object* x_39; lean_object* x_40; uint8_t x_41; 
-x_39 = lean_ctor_get(x_38, 1);
-lean_inc(x_39);
-lean_dec(x_38);
-x_40 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__2;
-x_41 = lean_string_dec_eq(x_39, x_40);
-lean_dec(x_39);
-if (x_41 == 0)
-{
-lean_object* x_42; lean_object* x_43; 
-x_42 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
-x_43 = l_Lean_Parser_ParserState_mkErrorsAt(x_35, x_42, x_34);
-x_18 = x_43;
-goto block_31;
-}
-else
-{
+x_35 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_34);
 lean_dec(x_34);
-x_18 = x_35;
-goto block_31;
-}
-}
-else
+if (lean_obj_tag(x_35) == 2)
 {
-lean_object* x_44; lean_object* x_45; 
-lean_dec(x_38);
-x_44 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
-x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_35, x_44, x_34);
-x_18 = x_45;
-goto block_31;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
+lean_object* x_36; lean_object* x_37; uint8_t x_38; 
+x_36 = lean_ctor_get(x_35, 1);
+lean_inc(x_36);
+lean_dec(x_35);
+x_37 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__2;
+x_38 = lean_string_dec_eq(x_36, x_37);
 lean_dec(x_36);
-x_46 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
-x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_35, x_46, x_34);
-x_18 = x_47;
-goto block_31;
+if (x_38 == 0)
+{
+lean_object* x_39; lean_object* x_40; 
+x_39 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
+x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_39, x_31);
+x_15 = x_40;
+goto block_28;
+}
+else
+{
+lean_dec(x_31);
+x_15 = x_32;
+goto block_28;
 }
 }
 else
 {
+lean_object* x_41; lean_object* x_42; 
+lean_dec(x_35);
+x_41 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
+x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_41, x_31);
+x_15 = x_42;
+goto block_28;
+}
+}
+else
+{
+lean_object* x_43; lean_object* x_44; 
 lean_dec(x_33);
-x_18 = x_32;
-goto block_31;
+x_43 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
+x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_43, x_31);
+x_15 = x_44;
+goto block_28;
+}
+}
+else
+{
+lean_dec(x_30);
+x_15 = x_29;
+goto block_28;
 }
 }
 }
 else
 {
-lean_dec(x_14);
-lean_dec(x_7);
-if (x_5 == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
 lean_dec(x_11);
-lean_dec(x_10);
-x_62 = lean_box(0);
-x_63 = l_Lean_Parser_ParserState_pushSyntax(x_13, x_62);
-x_64 = l_Lean_nullKind;
-x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_3);
-return x_65;
-}
-else
-{
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
-x_66 = l_Lean_Parser_ParserState_restore(x_13, x_10, x_11);
-lean_dec(x_10);
-x_67 = lean_ctor_get(x_66, 0);
-lean_inc(x_67);
-x_68 = lean_array_get_size(x_67);
-lean_dec(x_67);
-x_69 = lean_nat_sub(x_68, x_3);
-lean_dec(x_68);
-x_70 = lean_unsigned_to_nat(2u);
-x_71 = lean_nat_dec_eq(x_69, x_70);
-lean_dec(x_69);
-if (x_71 == 0)
-{
-lean_object* x_72; lean_object* x_73; 
-x_72 = l_Lean_nullKind;
-x_73 = l_Lean_Parser_ParserState_mkNode(x_66, x_72, x_3);
-return x_73;
-}
-else
-{
+lean_dec(x_5);
 if (x_4 == 0)
 {
-lean_object* x_74; lean_object* x_75; 
-x_74 = l_Lean_nullKind;
-x_75 = l_Lean_Parser_ParserState_mkNode(x_66, x_74, x_3);
-return x_75;
+lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_59 = lean_box(0);
+x_60 = l_Lean_Parser_ParserState_pushSyntax(x_10, x_59);
+x_61 = l_Lean_nullKind;
+x_62 = l_Lean_Parser_ParserState_mkNode(x_60, x_61, x_2);
+return x_62;
 }
 else
 {
-lean_object* x_76; 
-lean_dec(x_3);
-x_76 = l_Lean_Parser_ParserState_popSyntax(x_66);
-return x_76;
+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_63 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9);
+lean_dec(x_8);
+x_64 = lean_ctor_get(x_63, 0);
+lean_inc(x_64);
+x_65 = lean_array_get_size(x_64);
+lean_dec(x_64);
+x_66 = lean_nat_sub(x_65, x_2);
+lean_dec(x_65);
+x_67 = lean_unsigned_to_nat(2u);
+x_68 = lean_nat_dec_eq(x_66, x_67);
+lean_dec(x_66);
+if (x_68 == 0)
+{
+lean_object* x_69; lean_object* x_70; 
+x_69 = l_Lean_nullKind;
+x_70 = l_Lean_Parser_ParserState_mkNode(x_63, x_69, x_2);
+return x_70;
+}
+else
+{
+if (x_3 == 0)
+{
+lean_object* x_71; lean_object* x_72; 
+x_71 = l_Lean_nullKind;
+x_72 = l_Lean_Parser_ParserState_mkNode(x_63, x_71, x_2);
+return x_72;
+}
+else
+{
+lean_object* x_73; 
+lean_dec(x_2);
+x_73 = l_Lean_Parser_ParserState_popSyntax(x_63);
+return x_73;
 }
 }
 }
 }
 }
 }
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-x_8 = lean_array_get_size(x_7);
-lean_dec(x_7);
-x_9 = 0;
-x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2(x_1, x_2, x_8, x_3, x_9, x_4, x_5, x_6);
-return x_10;
+lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = 0;
+x_8 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2(x_1, x_6, x_2, x_7, x_3, x_4);
+return x_8;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_where___elambda__1___closed__1() {
@@ -33016,96 +32292,95 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_where___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_where___elambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_4 = lean_ctor_get(x_3, 0);
-lean_inc(x_4);
-x_5 = lean_array_get_size(x_4);
-lean_dec(x_4);
-x_16 = lean_ctor_get(x_3, 1);
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+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_14 = lean_ctor_get(x_2, 1);
+lean_inc(x_14);
+lean_inc(x_1);
+x_15 = l_Lean_Parser_tokenFn(x_1, x_2);
+x_16 = lean_ctor_get(x_15, 3);
 lean_inc(x_16);
-lean_inc(x_2);
-x_17 = l_Lean_Parser_tokenFn(x_2, x_3);
-x_18 = lean_ctor_get(x_17, 3);
-lean_inc(x_18);
-if (lean_obj_tag(x_18) == 0)
+if (lean_obj_tag(x_16) == 0)
 {
-lean_object* x_19; lean_object* x_20; 
-x_19 = lean_ctor_get(x_17, 0);
+lean_object* x_17; lean_object* x_18; 
+x_17 = lean_ctor_get(x_15, 0);
+lean_inc(x_17);
+x_18 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_17);
+lean_dec(x_17);
+if (lean_obj_tag(x_18) == 2)
+{
+lean_object* x_19; lean_object* x_20; uint8_t x_21; 
+x_19 = lean_ctor_get(x_18, 1);
 lean_inc(x_19);
-x_20 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_19);
+lean_dec(x_18);
+x_20 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__2;
+x_21 = lean_string_dec_eq(x_19, x_20);
 lean_dec(x_19);
-if (lean_obj_tag(x_20) == 2)
+if (x_21 == 0)
 {
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-lean_dec(x_20);
-x_22 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__2;
-x_23 = lean_string_dec_eq(x_21, x_22);
-lean_dec(x_21);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
-x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16);
-x_6 = x_25;
-goto block_15;
+lean_object* x_22; lean_object* x_23; 
+x_22 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
+x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14);
+x_5 = x_23;
+goto block_13;
 }
 else
 {
-lean_dec(x_16);
-x_6 = x_17;
-goto block_15;
+lean_dec(x_14);
+x_5 = x_15;
+goto block_13;
+}
+}
+else
+{
+lean_object* x_24; lean_object* x_25; 
+lean_dec(x_18);
+x_24 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
+x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_24, x_14);
+x_5 = x_25;
+goto block_13;
 }
 }
 else
 {
 lean_object* x_26; lean_object* x_27; 
-lean_dec(x_20);
+lean_dec(x_16);
 x_26 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
-x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_26, x_16);
-x_6 = x_27;
-goto block_15;
+x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_26, x_14);
+x_5 = x_27;
+goto block_13;
 }
+block_13:
+{
+lean_object* x_6; 
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 0)
+{
+uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+x_7 = 0;
+x_8 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1(x_7, x_7, x_1, x_5);
+x_9 = l_Lean_Parser_Term_where___elambda__1___closed__2;
+x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_4);
+lean_dec(x_4);
+return x_10;
 }
 else
 {
-lean_object* x_28; lean_object* x_29; 
-lean_dec(x_18);
-x_28 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5;
-x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_28, x_16);
-x_6 = x_29;
-goto block_15;
-}
-block_15:
-{
-lean_object* x_7; 
-x_7 = lean_ctor_get(x_6, 3);
-lean_inc(x_7);
-if (lean_obj_tag(x_7) == 0)
-{
-uint8_t x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_8 = 1;
-x_9 = 0;
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1(x_8, x_9, x_9, x_1, x_2, x_6);
+lean_object* x_11; lean_object* x_12; 
+lean_dec(x_6);
+lean_dec(x_1);
 x_11 = l_Lean_Parser_Term_where___elambda__1___closed__2;
-x_12 = l_Lean_Parser_ParserState_mkTrailingNode(x_10, x_11, x_5);
-lean_dec(x_5);
+x_12 = l_Lean_Parser_ParserState_mkTrailingNode(x_5, x_11, x_4);
+lean_dec(x_4);
 return x_12;
 }
-else
-{
-lean_object* x_13; lean_object* x_14; 
-lean_dec(x_7);
-lean_dec(x_2);
-x_13 = l_Lean_Parser_Term_where___elambda__1___closed__2;
-x_14 = l_Lean_Parser_ParserState_mkTrailingNode(x_6, x_13, x_5);
-lean_dec(x_5);
-return x_14;
-}
 }
 }
 }
@@ -33185,7 +32460,7 @@ lean_object* _init_l_Lean_Parser_Term_where___closed__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_where___elambda__1___boxed), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_where___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -33209,54 +32484,39 @@ x_1 = l_Lean_Parser_Term_where___closed__9;
 return x_1;
 }
 }
-lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
-_start:
-{
-uint8_t x_9; uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
-x_9 = lean_unbox(x_1);
-lean_dec(x_1);
-x_10 = lean_unbox(x_2);
-lean_dec(x_2);
-x_11 = lean_unbox(x_4);
-lean_dec(x_4);
-x_12 = lean_unbox(x_5);
-lean_dec(x_5);
-x_13 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2(x_9, x_10, x_3, x_11, x_12, x_6, x_7, x_8);
-lean_dec(x_6);
-return x_13;
-}
-}
-lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 uint8_t x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; 
 x_7 = lean_unbox(x_1);
 lean_dec(x_1);
-x_8 = lean_unbox(x_2);
-lean_dec(x_2);
-x_9 = lean_unbox(x_3);
+x_8 = lean_unbox(x_3);
 lean_dec(x_3);
-x_10 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1(x_7, x_8, x_9, x_4, x_5, x_6);
+x_9 = lean_unbox(x_4);
 lean_dec(x_4);
+x_10 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2(x_7, x_2, x_8, x_9, x_5, x_6);
 return x_10;
 }
 }
-lean_object* l_Lean_Parser_Term_where___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_4; 
-x_4 = l_Lean_Parser_Term_where___elambda__1(x_1, x_2, x_3);
+uint8_t x_5; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox(x_1);
 lean_dec(x_1);
-return x_4;
+x_6 = lean_unbox(x_2);
+lean_dec(x_2);
+x_7 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1(x_5, x_6, x_3, x_4);
+return x_7;
 }
 }
 lean_object* l___regBuiltinParser_Lean_Parser_Term_where(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_where___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_where___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_where;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -33298,22 +32558,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_fcomp___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_fcomp___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_fcomp___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_fcomp___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_fcomp___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_fcomp___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_fcomp___closed__1() {
@@ -33332,7 +32592,7 @@ lean_object* _init_l_Lean_Parser_Term_fcomp___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_fcomp___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_fcomp___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -33359,10 +32619,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_fcomp(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_fcomp___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_fcomp___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_fcomp;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -33404,22 +32664,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_prod___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_prod___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_prod___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_prod___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_prod___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_prod___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_prod___closed__1() {
@@ -33438,7 +32698,7 @@ lean_object* _init_l_Lean_Parser_Term_prod___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_prod___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_prod___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -33465,10 +32725,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_prod(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_prod___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_prod___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_prod;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -33510,22 +32770,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_add___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_add___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_add___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_add___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_add___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_add___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_add___closed__1() {
@@ -33544,7 +32804,7 @@ lean_object* _init_l_Lean_Parser_Term_add___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_add___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_add___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -33571,10 +32831,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_add(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_add___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_add___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_add;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -33616,22 +32876,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_sub___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_sub___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_sub___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_sub___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_sub___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_sub___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_sub___closed__1() {
@@ -33650,7 +32910,7 @@ lean_object* _init_l_Lean_Parser_Term_sub___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sub___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sub___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -33677,10 +32937,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_sub(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_sub___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_sub___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_sub;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -33722,22 +32982,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_mul___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_mul___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_mul___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_mul___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_mul___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_mul___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_mul___closed__1() {
@@ -33756,7 +33016,7 @@ lean_object* _init_l_Lean_Parser_Term_mul___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mul___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mul___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -33783,10 +33043,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_mul(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_mul___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_mul___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_mul;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -33828,22 +33088,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_div___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_div___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_div___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_div___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_div___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_div___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_div___closed__1() {
@@ -33862,7 +33122,7 @@ lean_object* _init_l_Lean_Parser_Term_div___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_div___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_div___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -33889,10 +33149,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_div(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_div___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_div___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_div;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -33934,22 +33194,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_mod___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_mod___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_mod___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_mod___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_mod___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_mod___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_mod___closed__1() {
@@ -33968,7 +33228,7 @@ lean_object* _init_l_Lean_Parser_Term_mod___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mod___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mod___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -33995,10 +33255,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_mod(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_mod___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_mod___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_mod;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -34040,22 +33300,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_modN___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_modN___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_modN___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_modN___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_modN___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_modN___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_modN___closed__1() {
@@ -34074,7 +33334,7 @@ lean_object* _init_l_Lean_Parser_Term_modN___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_modN___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_modN___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -34101,10 +33361,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_modN(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_modN___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_modN___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_modN;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -34146,22 +33406,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_pow___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_pow___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_pow___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_pow___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_pow___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_pow___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_pow___closed__1() {
@@ -34180,7 +33440,7 @@ lean_object* _init_l_Lean_Parser_Term_pow___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_pow___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_pow___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -34207,10 +33467,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_pow(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_pow___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_pow___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_pow;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -34261,22 +33521,22 @@ x_4 = l_Lean_Parser_Term_unicodeInfixL(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_le___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_le___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_le___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_le___elambda__1___closed__5;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_le___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_le___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_le___closed__1() {
@@ -34295,7 +33555,7 @@ lean_object* _init_l_Lean_Parser_Term_le___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_le___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_le___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -34322,10 +33582,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_le(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_le___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_le___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_le;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -34376,22 +33636,22 @@ x_4 = l_Lean_Parser_Term_unicodeInfixL(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_ge___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_ge___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_ge___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_ge___elambda__1___closed__5;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_ge___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_ge___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_ge___closed__1() {
@@ -34410,7 +33670,7 @@ lean_object* _init_l_Lean_Parser_Term_ge___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_ge___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_ge___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -34437,10 +33697,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_ge(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_ge___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_ge___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_ge;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -34482,22 +33742,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_lt___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_lt___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_lt___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_lt___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_lt___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_lt___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_lt___closed__1() {
@@ -34516,7 +33776,7 @@ lean_object* _init_l_Lean_Parser_Term_lt___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_lt___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_lt___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -34543,10 +33803,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_lt(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_lt___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_lt___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_lt;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -34588,22 +33848,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_gt___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_gt___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_gt___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_gt___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_gt___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_gt___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_gt___closed__1() {
@@ -34622,7 +33882,7 @@ lean_object* _init_l_Lean_Parser_Term_gt___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_gt___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_gt___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -34649,10 +33909,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_gt(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_gt___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_gt___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_gt;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -34694,22 +33954,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_eq___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_eq___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_eq___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_eq___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_eq___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_eq___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_eq___closed__1() {
@@ -34728,7 +33988,7 @@ lean_object* _init_l_Lean_Parser_Term_eq___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_eq___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_eq___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -34755,10 +34015,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_eq(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_eq___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_eq___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_eq;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -34800,22 +34060,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_ne___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_ne___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_ne___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_ne___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_ne___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_ne___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_ne___closed__1() {
@@ -34834,7 +34094,7 @@ lean_object* _init_l_Lean_Parser_Term_ne___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_ne___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_ne___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -34861,10 +34121,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_ne(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_ne___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_ne___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_ne;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -34906,22 +34166,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_beq___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_beq___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_beq___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_beq___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_beq___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_beq___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_beq___closed__1() {
@@ -34940,7 +34200,7 @@ lean_object* _init_l_Lean_Parser_Term_beq___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_beq___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_beq___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -34967,10 +34227,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_beq(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_beq___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_beq___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_beq;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -35012,22 +34272,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_bne___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_bne___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_bne___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_bne___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_bne___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_bne___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_bne___closed__1() {
@@ -35046,7 +34306,7 @@ lean_object* _init_l_Lean_Parser_Term_bne___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bne___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bne___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -35073,10 +34333,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_bne(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_bne___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_bne___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_bne;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -35127,22 +34387,22 @@ x_4 = l_Lean_Parser_Term_unicodeInfixL(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_heq___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_heq___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_heq___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_heq___elambda__1___closed__5;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_heq___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_heq___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_heq___closed__1() {
@@ -35161,7 +34421,7 @@ lean_object* _init_l_Lean_Parser_Term_heq___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_heq___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_heq___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -35188,10 +34448,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_heq(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_heq___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_heq___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_heq;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -35233,22 +34493,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_equiv___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_equiv___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_equiv___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_equiv___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_equiv___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_equiv___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_equiv___closed__1() {
@@ -35267,7 +34527,7 @@ lean_object* _init_l_Lean_Parser_Term_equiv___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_equiv___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_equiv___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -35294,10 +34554,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_equiv(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_equiv___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_equiv___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_equiv;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -35339,22 +34599,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_subst___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_subst___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_subst___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_subst___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_subst___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_subst___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_subst___closed__1() {
@@ -35373,7 +34633,7 @@ lean_object* _init_l_Lean_Parser_Term_subst___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_subst___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_subst___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -35400,10 +34660,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_subst(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_subst___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_subst___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_subst;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -35454,22 +34714,22 @@ x_4 = l_Lean_Parser_Term_unicodeInfixR(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_and___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_and___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_and___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_and___elambda__1___closed__5;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_and___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_and___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_and___closed__1() {
@@ -35488,7 +34748,7 @@ lean_object* _init_l_Lean_Parser_Term_and___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_and___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_and___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -35515,10 +34775,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_and(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_and___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_and___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_and;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -35569,22 +34829,22 @@ x_4 = l_Lean_Parser_Term_unicodeInfixR(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_or___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_or___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_or___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_or___elambda__1___closed__5;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_or___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_or___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_or___closed__1() {
@@ -35603,7 +34863,7 @@ lean_object* _init_l_Lean_Parser_Term_or___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_or___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_or___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -35630,10 +34890,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_or(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_or___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_or___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_or;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -35684,22 +34944,22 @@ x_4 = l_Lean_Parser_Term_unicodeInfixL(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Parser_Term_iff___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_iff___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_iff___elambda__1___closed__5;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_iff___elambda__1___closed__5;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_iff___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_iff___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_iff___closed__1() {
@@ -35718,7 +34978,7 @@ lean_object* _init_l_Lean_Parser_Term_iff___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_iff___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_iff___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -35745,10 +35005,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_iff(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_iff___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_iff___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_iff;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -35790,22 +35050,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_band___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_band___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_band___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_band___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_band___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_band___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_band___closed__1() {
@@ -35824,7 +35084,7 @@ lean_object* _init_l_Lean_Parser_Term_band___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_band___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_band___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -35851,10 +35111,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_band(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_band___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_band___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_band;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -35896,22 +35156,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_bor___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_bor___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_bor___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_bor___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_bor___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_bor___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_bor___closed__1() {
@@ -35930,7 +35190,7 @@ lean_object* _init_l_Lean_Parser_Term_bor___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bor___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bor___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -35957,10 +35217,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_bor(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_bor___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_bor___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_bor;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36002,22 +35262,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_append___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_append___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_append___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_append___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_append___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_append___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_append___closed__1() {
@@ -36036,7 +35296,7 @@ lean_object* _init_l_Lean_Parser_Term_append___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_append___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_append___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -36063,10 +35323,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_append(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_append___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_append___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_append;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36108,22 +35368,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_cons___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_cons___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_cons___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_cons___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_cons___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_cons___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_cons___closed__1() {
@@ -36142,7 +35402,7 @@ lean_object* _init_l_Lean_Parser_Term_cons___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_cons___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_cons___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -36169,10 +35429,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_cons(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_cons___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_cons___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_cons;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36214,22 +35474,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_orelse___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_orelse___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_orelse___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_orelse___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_orelse___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_orelse___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_orelse___closed__1() {
@@ -36248,7 +35508,7 @@ lean_object* _init_l_Lean_Parser_Term_orelse___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_orelse___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_orelse___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -36275,10 +35535,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_orelse(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_orelse___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_orelse___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_orelse;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36320,22 +35580,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_orM___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_orM___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_orM___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_orM___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_orM___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_orM___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_orM___closed__1() {
@@ -36354,7 +35614,7 @@ lean_object* _init_l_Lean_Parser_Term_orM___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_orM___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_orM___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -36381,10 +35641,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_orM(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_orM___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_orM___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_orM;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36426,22 +35686,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_andM___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_andM___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_andM___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_andM___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_andM___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_andM___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_andM___closed__1() {
@@ -36460,7 +35720,7 @@ lean_object* _init_l_Lean_Parser_Term_andM___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_andM___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_andM___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -36487,10 +35747,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_andM(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_andM___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_andM___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_andM;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36532,22 +35792,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_andthen___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_andthen___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_andthen___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_andthen___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_andthen___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_andthen___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_andthen___closed__1() {
@@ -36566,7 +35826,7 @@ lean_object* _init_l_Lean_Parser_Term_andthen___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_andthen___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_andthen___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -36593,10 +35853,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_andthen(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_andthen___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_andthen___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_andthen;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36638,22 +35898,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_bindOp___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_bindOp___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_bindOp___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_bindOp___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_bindOp___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_bindOp___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_bindOp___closed__1() {
@@ -36672,7 +35932,7 @@ lean_object* _init_l_Lean_Parser_Term_bindOp___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bindOp___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bindOp___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -36699,10 +35959,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_bindOp(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_bindOp___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_bindOp___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_bindOp;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36744,22 +36004,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_mapRev___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_mapRev___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_mapRev___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_mapRev___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_mapRev___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_mapRev___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_mapRev___closed__1() {
@@ -36778,7 +36038,7 @@ lean_object* _init_l_Lean_Parser_Term_mapRev___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mapRev___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mapRev___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -36805,10 +36065,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_mapRev(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_mapRev___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_mapRev___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_mapRev;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36850,22 +36110,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_seq___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_seq___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_seq___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_seq___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_seq___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_seq___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_seq___closed__1() {
@@ -36884,7 +36144,7 @@ lean_object* _init_l_Lean_Parser_Term_seq___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_seq___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_seq___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -36911,10 +36171,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_seq(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_seq___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_seq___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_seq;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -36956,22 +36216,22 @@ x_3 = l_Lean_Parser_Term_infixL(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_seqLeft___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_seqLeft___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_seqLeft___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_seqLeft___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_seqLeft___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_seqLeft___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_seqLeft___closed__1() {
@@ -36990,7 +36250,7 @@ lean_object* _init_l_Lean_Parser_Term_seqLeft___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_seqLeft___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_seqLeft___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -37017,10 +36277,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_seqLeft(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_seqLeft___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_seqLeft___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_seqLeft;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -37062,22 +36322,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_seqRight___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_seqRight___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_seqRight___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_seqRight___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_seqRight___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_seqRight___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_seqRight___closed__1() {
@@ -37096,7 +36356,7 @@ lean_object* _init_l_Lean_Parser_Term_seqRight___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_seqRight___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_seqRight___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -37123,10 +36383,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_seqRight(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_seqRight___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_seqRight___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_seqRight;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -37168,22 +36428,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_map___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_map___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_map___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_map___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_map___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_map___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_map___closed__1() {
@@ -37202,7 +36462,7 @@ lean_object* _init_l_Lean_Parser_Term_map___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_map___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_map___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -37229,10 +36489,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_map(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_map___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_map___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_map;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -37274,22 +36534,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_mapConst___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_mapConst___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_mapConst___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_mapConst___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_mapConst___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_mapConst___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_mapConst___closed__1() {
@@ -37308,7 +36568,7 @@ lean_object* _init_l_Lean_Parser_Term_mapConst___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mapConst___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mapConst___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -37335,10 +36595,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_mapConst(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_mapConst___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_mapConst___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_mapConst;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -37380,22 +36640,22 @@ x_3 = l_Lean_Parser_Term_infixR(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Parser_Term_mapConstRev___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Term_mapConstRev___elambda__1(lean_object* x_1, lean_object* x_2) {
 _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_mapConstRev___elambda__1___closed__4;
-x_5 = lean_ctor_get(x_4, 1);
+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; 
+x_3 = l_Lean_Parser_Term_mapConstRev___elambda__1___closed__4;
+x_4 = lean_ctor_get(x_3, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
-x_6 = lean_ctor_get(x_3, 0);
-lean_inc(x_6);
-x_7 = lean_array_get_size(x_6);
+x_6 = lean_array_get_size(x_5);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_1, x_2);
+x_8 = l_Lean_Parser_Term_mapConstRev___elambda__1___closed__2;
+x_9 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_8, x_6);
 lean_dec(x_6);
-x_8 = lean_apply_3(x_5, x_1, x_2, x_3);
-x_9 = l_Lean_Parser_Term_mapConstRev___elambda__1___closed__2;
-x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_7);
-lean_dec(x_7);
-return x_10;
+return x_9;
 }
 }
 lean_object* _init_l_Lean_Parser_Term_mapConstRev___closed__1() {
@@ -37414,7 +36674,7 @@ lean_object* _init_l_Lean_Parser_Term_mapConstRev___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mapConstRev___elambda__1), 3, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_mapConstRev___elambda__1), 2, 0);
 return x_1;
 }
 }
@@ -37441,10 +36701,10 @@ return x_1;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_mapConstRev(lean_object* x_1) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = 1;
-x_3 = l_Lean_Parser_termParser___closed__2;
-x_4 = l_Lean_Parser_Term_mapConstRev___elambda__1___closed__2;
+lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+x_2 = l_Lean_Parser_termParser___closed__2;
+x_3 = l_Lean_Parser_Term_mapConstRev___elambda__1___closed__2;
+x_4 = 0;
 x_5 = l_Lean_Parser_Term_mapConstRev;
 x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1);
 return x_6;
@@ -37463,24 +36723,24 @@ lean_dec_ref(res);
 res = initialize_Init_Lean_Parser_Level(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_darrow___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___rarg___closed__1);
-l_Lean_Parser_darrow___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___rarg___closed__2);
-l_Lean_Parser_darrow___elambda__1___rarg___closed__3 = _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__3();
-lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___rarg___closed__3);
-l_Lean_Parser_darrow___elambda__1___rarg___closed__4 = _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__4();
-lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___rarg___closed__4);
-l_Lean_Parser_darrow___elambda__1___rarg___closed__5 = _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__5();
-lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___rarg___closed__5);
-l_Lean_Parser_darrow___elambda__1___rarg___closed__6 = _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__6();
-lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___rarg___closed__6);
-l_Lean_Parser_darrow___elambda__1___rarg___closed__7 = _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__7();
-lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___rarg___closed__7);
-l_Lean_Parser_darrow___elambda__1___rarg___closed__8 = _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__8();
-lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___rarg___closed__8);
-l_Lean_Parser_darrow___elambda__1___rarg___closed__9 = _init_l_Lean_Parser_darrow___elambda__1___rarg___closed__9();
-lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___rarg___closed__9);
+l_Lean_Parser_darrow___elambda__1___closed__1 = _init_l_Lean_Parser_darrow___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___closed__1);
+l_Lean_Parser_darrow___elambda__1___closed__2 = _init_l_Lean_Parser_darrow___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___closed__2);
+l_Lean_Parser_darrow___elambda__1___closed__3 = _init_l_Lean_Parser_darrow___elambda__1___closed__3();
+lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___closed__3);
+l_Lean_Parser_darrow___elambda__1___closed__4 = _init_l_Lean_Parser_darrow___elambda__1___closed__4();
+lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___closed__4);
+l_Lean_Parser_darrow___elambda__1___closed__5 = _init_l_Lean_Parser_darrow___elambda__1___closed__5();
+lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___closed__5);
+l_Lean_Parser_darrow___elambda__1___closed__6 = _init_l_Lean_Parser_darrow___elambda__1___closed__6();
+lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___closed__6);
+l_Lean_Parser_darrow___elambda__1___closed__7 = _init_l_Lean_Parser_darrow___elambda__1___closed__7();
+lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___closed__7);
+l_Lean_Parser_darrow___elambda__1___closed__8 = _init_l_Lean_Parser_darrow___elambda__1___closed__8();
+lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___closed__8);
+l_Lean_Parser_darrow___elambda__1___closed__9 = _init_l_Lean_Parser_darrow___elambda__1___closed__9();
+lean_mark_persistent(l_Lean_Parser_darrow___elambda__1___closed__9);
 l_Lean_Parser_darrow___closed__1 = _init_l_Lean_Parser_darrow___closed__1();
 lean_mark_persistent(l_Lean_Parser_darrow___closed__1);
 l_Lean_Parser_darrow___closed__2 = _init_l_Lean_Parser_darrow___closed__2();
@@ -37637,8 +36897,6 @@ l_Lean_Parser_Term_str___elambda__1___closed__3 = _init_l_Lean_Parser_Term_str__
 lean_mark_persistent(l_Lean_Parser_Term_str___elambda__1___closed__3);
 l_Lean_Parser_Term_str___elambda__1___closed__4 = _init_l_Lean_Parser_Term_str___elambda__1___closed__4();
 lean_mark_persistent(l_Lean_Parser_Term_str___elambda__1___closed__4);
-l_Lean_Parser_Term_str___elambda__1___closed__5 = _init_l_Lean_Parser_Term_str___elambda__1___closed__5();
-lean_mark_persistent(l_Lean_Parser_Term_str___elambda__1___closed__5);
 l_Lean_Parser_Term_str___closed__1 = _init_l_Lean_Parser_Term_str___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_str___closed__1);
 l_Lean_Parser_Term_str___closed__2 = _init_l_Lean_Parser_Term_str___closed__2();
@@ -37660,8 +36918,6 @@ l_Lean_Parser_Term_char___elambda__1___closed__3 = _init_l_Lean_Parser_Term_char
 lean_mark_persistent(l_Lean_Parser_Term_char___elambda__1___closed__3);
 l_Lean_Parser_Term_char___elambda__1___closed__4 = _init_l_Lean_Parser_Term_char___elambda__1___closed__4();
 lean_mark_persistent(l_Lean_Parser_Term_char___elambda__1___closed__4);
-l_Lean_Parser_Term_char___elambda__1___closed__5 = _init_l_Lean_Parser_Term_char___elambda__1___closed__5();
-lean_mark_persistent(l_Lean_Parser_Term_char___elambda__1___closed__5);
 l_Lean_Parser_Term_char___closed__1 = _init_l_Lean_Parser_Term_char___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_char___closed__1);
 l_Lean_Parser_Term_char___closed__2 = _init_l_Lean_Parser_Term_char___closed__2();
@@ -37951,8 +37207,6 @@ l_Lean_Parser_Term_typeAscription___closed__5 = _init_l_Lean_Parser_Term_typeAsc
 lean_mark_persistent(l_Lean_Parser_Term_typeAscription___closed__5);
 l_Lean_Parser_Term_typeAscription___closed__6 = _init_l_Lean_Parser_Term_typeAscription___closed__6();
 lean_mark_persistent(l_Lean_Parser_Term_typeAscription___closed__6);
-l_Lean_Parser_Term_typeAscription___closed__7 = _init_l_Lean_Parser_Term_typeAscription___closed__7();
-lean_mark_persistent(l_Lean_Parser_Term_typeAscription___closed__7);
 l_Lean_Parser_Term_typeAscription = _init_l_Lean_Parser_Term_typeAscription();
 lean_mark_persistent(l_Lean_Parser_Term_typeAscription);
 l_Lean_Parser_Term_tupleTail___elambda__1___closed__1 = _init_l_Lean_Parser_Term_tupleTail___elambda__1___closed__1();
@@ -38792,6 +38046,10 @@ l_Lean_Parser_Term_explicitBinder___closed__6 = _init_l_Lean_Parser_Term_explici
 lean_mark_persistent(l_Lean_Parser_Term_explicitBinder___closed__6);
 l_Lean_Parser_Term_explicitBinder___closed__7 = _init_l_Lean_Parser_Term_explicitBinder___closed__7();
 lean_mark_persistent(l_Lean_Parser_Term_explicitBinder___closed__7);
+l_Lean_Parser_Term_explicitBinder___closed__8 = _init_l_Lean_Parser_Term_explicitBinder___closed__8();
+lean_mark_persistent(l_Lean_Parser_Term_explicitBinder___closed__8);
+l_Lean_Parser_Term_explicitBinder___closed__9 = _init_l_Lean_Parser_Term_explicitBinder___closed__9();
+lean_mark_persistent(l_Lean_Parser_Term_explicitBinder___closed__9);
 l_Lean_Parser_Term_implicitBinder___elambda__1___closed__1 = _init_l_Lean_Parser_Term_implicitBinder___elambda__1___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_implicitBinder___elambda__1___closed__1);
 l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2 = _init_l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2();
@@ -38974,6 +38232,8 @@ l_Lean_Parser_Term_matchAlt___closed__9 = _init_l_Lean_Parser_Term_matchAlt___cl
 lean_mark_persistent(l_Lean_Parser_Term_matchAlt___closed__9);
 l_Lean_Parser_Term_matchAlt___closed__10 = _init_l_Lean_Parser_Term_matchAlt___closed__10();
 lean_mark_persistent(l_Lean_Parser_Term_matchAlt___closed__10);
+l_Lean_Parser_Term_matchAlt___closed__11 = _init_l_Lean_Parser_Term_matchAlt___closed__11();
+lean_mark_persistent(l_Lean_Parser_Term_matchAlt___closed__11);
 l_Lean_Parser_Term_matchAlt = _init_l_Lean_Parser_Term_matchAlt();
 lean_mark_persistent(l_Lean_Parser_Term_matchAlt);
 l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__1 = _init_l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__1();
@@ -39207,8 +38467,6 @@ l_Lean_Parser_Term_quotedName___elambda__1___closed__3 = _init_l_Lean_Parser_Ter
 lean_mark_persistent(l_Lean_Parser_Term_quotedName___elambda__1___closed__3);
 l_Lean_Parser_Term_quotedName___elambda__1___closed__4 = _init_l_Lean_Parser_Term_quotedName___elambda__1___closed__4();
 lean_mark_persistent(l_Lean_Parser_Term_quotedName___elambda__1___closed__4);
-l_Lean_Parser_Term_quotedName___elambda__1___closed__5 = _init_l_Lean_Parser_Term_quotedName___elambda__1___closed__5();
-lean_mark_persistent(l_Lean_Parser_Term_quotedName___elambda__1___closed__5);
 l_Lean_Parser_Term_quotedName___closed__1 = _init_l_Lean_Parser_Term_quotedName___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_quotedName___closed__1);
 l_Lean_Parser_Term_quotedName___closed__2 = _init_l_Lean_Parser_Term_quotedName___closed__2();
@@ -39381,24 +38639,24 @@ lean_mark_persistent(l_Lean_Parser_Term_let);
 res = l___regBuiltinParser_Lean_Parser_Term_let(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__1);
-l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__2);
-l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__3 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__3();
-lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__3);
-l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__4 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__4();
-lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__4);
-l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__5 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__5();
-lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__5);
-l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__6 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__6();
-lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__6);
-l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__7 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__7();
-lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__7);
-l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__8 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__8();
-lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__8);
-l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__9 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__9();
-lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___rarg___closed__9);
+l_Lean_Parser_Term_leftArrow___elambda__1___closed__1 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___closed__1);
+l_Lean_Parser_Term_leftArrow___elambda__1___closed__2 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___closed__2);
+l_Lean_Parser_Term_leftArrow___elambda__1___closed__3 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__3();
+lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___closed__3);
+l_Lean_Parser_Term_leftArrow___elambda__1___closed__4 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__4();
+lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___closed__4);
+l_Lean_Parser_Term_leftArrow___elambda__1___closed__5 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__5();
+lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___closed__5);
+l_Lean_Parser_Term_leftArrow___elambda__1___closed__6 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__6();
+lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___closed__6);
+l_Lean_Parser_Term_leftArrow___elambda__1___closed__7 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__7();
+lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___closed__7);
+l_Lean_Parser_Term_leftArrow___elambda__1___closed__8 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__8();
+lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___closed__8);
+l_Lean_Parser_Term_leftArrow___elambda__1___closed__9 = _init_l_Lean_Parser_Term_leftArrow___elambda__1___closed__9();
+lean_mark_persistent(l_Lean_Parser_Term_leftArrow___elambda__1___closed__9);
 l_Lean_Parser_Term_leftArrow___closed__1 = _init_l_Lean_Parser_Term_leftArrow___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_leftArrow___closed__1);
 l_Lean_Parser_Term_leftArrow___closed__2 = _init_l_Lean_Parser_Term_leftArrow___closed__2();
@@ -39729,8 +38987,6 @@ l_Lean_Parser_Term_app___closed__3 = _init_l_Lean_Parser_Term_app___closed__3();
 lean_mark_persistent(l_Lean_Parser_Term_app___closed__3);
 l_Lean_Parser_Term_app___closed__4 = _init_l_Lean_Parser_Term_app___closed__4();
 lean_mark_persistent(l_Lean_Parser_Term_app___closed__4);
-l_Lean_Parser_Term_app___closed__5 = _init_l_Lean_Parser_Term_app___closed__5();
-lean_mark_persistent(l_Lean_Parser_Term_app___closed__5);
 l_Lean_Parser_Term_app = _init_l_Lean_Parser_Term_app();
 lean_mark_persistent(l_Lean_Parser_Term_app);
 res = l___regBuiltinParser_Lean_Parser_Term_app(lean_io_mk_world());
@@ -39742,10 +38998,10 @@ l_Lean_Parser_Term_checkIsSort___closed__2 = _init_l_Lean_Parser_Term_checkIsSor
 lean_mark_persistent(l_Lean_Parser_Term_checkIsSort___closed__2);
 l_Lean_Parser_Term_checkIsSort = _init_l_Lean_Parser_Term_checkIsSort();
 lean_mark_persistent(l_Lean_Parser_Term_checkIsSort);
-l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__1);
-l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_Term_sortApp___elambda__1___rarg___closed__2);
+l_Lean_Parser_Term_sortApp___elambda__1___closed__1 = _init_l_Lean_Parser_Term_sortApp___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Term_sortApp___elambda__1___closed__1);
+l_Lean_Parser_Term_sortApp___elambda__1___closed__2 = _init_l_Lean_Parser_Term_sortApp___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_Term_sortApp___elambda__1___closed__2);
 l_Lean_Parser_Term_sortApp___closed__1 = _init_l_Lean_Parser_Term_sortApp___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_sortApp___closed__1);
 l_Lean_Parser_Term_sortApp___closed__2 = _init_l_Lean_Parser_Term_sortApp___closed__2();
@@ -39754,8 +39010,6 @@ l_Lean_Parser_Term_sortApp___closed__3 = _init_l_Lean_Parser_Term_sortApp___clos
 lean_mark_persistent(l_Lean_Parser_Term_sortApp___closed__3);
 l_Lean_Parser_Term_sortApp___closed__4 = _init_l_Lean_Parser_Term_sortApp___closed__4();
 lean_mark_persistent(l_Lean_Parser_Term_sortApp___closed__4);
-l_Lean_Parser_Term_sortApp___closed__5 = _init_l_Lean_Parser_Term_sortApp___closed__5();
-lean_mark_persistent(l_Lean_Parser_Term_sortApp___closed__5);
 l_Lean_Parser_Term_sortApp = _init_l_Lean_Parser_Term_sortApp();
 lean_mark_persistent(l_Lean_Parser_Term_sortApp);
 res = l___regBuiltinParser_Lean_Parser_Term_sortApp(lean_io_mk_world());
@@ -39773,10 +39027,6 @@ l_Lean_Parser_Term_proj___elambda__1___closed__5 = _init_l_Lean_Parser_Term_proj
 lean_mark_persistent(l_Lean_Parser_Term_proj___elambda__1___closed__5);
 l_Lean_Parser_Term_proj___elambda__1___closed__6 = _init_l_Lean_Parser_Term_proj___elambda__1___closed__6();
 lean_mark_persistent(l_Lean_Parser_Term_proj___elambda__1___closed__6);
-l_Lean_Parser_Term_proj___elambda__1___closed__7 = _init_l_Lean_Parser_Term_proj___elambda__1___closed__7();
-lean_mark_persistent(l_Lean_Parser_Term_proj___elambda__1___closed__7);
-l_Lean_Parser_Term_proj___elambda__1___closed__8 = _init_l_Lean_Parser_Term_proj___elambda__1___closed__8();
-lean_mark_persistent(l_Lean_Parser_Term_proj___elambda__1___closed__8);
 l_Lean_Parser_Term_proj___closed__1 = _init_l_Lean_Parser_Term_proj___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_proj___closed__1);
 l_Lean_Parser_Term_proj___closed__2 = _init_l_Lean_Parser_Term_proj___closed__2();
@@ -39793,8 +39043,6 @@ l_Lean_Parser_Term_proj___closed__7 = _init_l_Lean_Parser_Term_proj___closed__7(
 lean_mark_persistent(l_Lean_Parser_Term_proj___closed__7);
 l_Lean_Parser_Term_proj___closed__8 = _init_l_Lean_Parser_Term_proj___closed__8();
 lean_mark_persistent(l_Lean_Parser_Term_proj___closed__8);
-l_Lean_Parser_Term_proj___closed__9 = _init_l_Lean_Parser_Term_proj___closed__9();
-lean_mark_persistent(l_Lean_Parser_Term_proj___closed__9);
 l_Lean_Parser_Term_proj = _init_l_Lean_Parser_Term_proj();
 lean_mark_persistent(l_Lean_Parser_Term_proj);
 res = l___regBuiltinParser_Lean_Parser_Term_proj(lean_io_mk_world());
@@ -39817,14 +39065,14 @@ lean_mark_persistent(l_Lean_Parser_Term_arrow);
 res = l___regBuiltinParser_Lean_Parser_Term_arrow(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__1);
-l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__2);
-l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__3 = _init_l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__3();
-lean_mark_persistent(l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__3);
-l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__4 = _init_l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__4();
-lean_mark_persistent(l_Lean_Parser_Term_arrayRef___elambda__1___rarg___closed__4);
+l_Lean_Parser_Term_arrayRef___elambda__1___closed__1 = _init_l_Lean_Parser_Term_arrayRef___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Term_arrayRef___elambda__1___closed__1);
+l_Lean_Parser_Term_arrayRef___elambda__1___closed__2 = _init_l_Lean_Parser_Term_arrayRef___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_Term_arrayRef___elambda__1___closed__2);
+l_Lean_Parser_Term_arrayRef___elambda__1___closed__3 = _init_l_Lean_Parser_Term_arrayRef___elambda__1___closed__3();
+lean_mark_persistent(l_Lean_Parser_Term_arrayRef___elambda__1___closed__3);
+l_Lean_Parser_Term_arrayRef___elambda__1___closed__4 = _init_l_Lean_Parser_Term_arrayRef___elambda__1___closed__4();
+lean_mark_persistent(l_Lean_Parser_Term_arrayRef___elambda__1___closed__4);
 l_Lean_Parser_Term_arrayRef___closed__1 = _init_l_Lean_Parser_Term_arrayRef___closed__1();
 lean_mark_persistent(l_Lean_Parser_Term_arrayRef___closed__1);
 l_Lean_Parser_Term_arrayRef___closed__2 = _init_l_Lean_Parser_Term_arrayRef___closed__2();
@@ -39835,21 +39083,17 @@ l_Lean_Parser_Term_arrayRef___closed__4 = _init_l_Lean_Parser_Term_arrayRef___cl
 lean_mark_persistent(l_Lean_Parser_Term_arrayRef___closed__4);
 l_Lean_Parser_Term_arrayRef___closed__5 = _init_l_Lean_Parser_Term_arrayRef___closed__5();
 lean_mark_persistent(l_Lean_Parser_Term_arrayRef___closed__5);
-l_Lean_Parser_Term_arrayRef___closed__6 = _init_l_Lean_Parser_Term_arrayRef___closed__6();
-lean_mark_persistent(l_Lean_Parser_Term_arrayRef___closed__6);
-l_Lean_Parser_Term_arrayRef___closed__7 = _init_l_Lean_Parser_Term_arrayRef___closed__7();
-lean_mark_persistent(l_Lean_Parser_Term_arrayRef___closed__7);
 l_Lean_Parser_Term_arrayRef = _init_l_Lean_Parser_Term_arrayRef();
 lean_mark_persistent(l_Lean_Parser_Term_arrayRef);
 res = l___regBuiltinParser_Lean_Parser_Term_arrayRef(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__1 = _init_l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__1();
-lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__1);
-l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2 = _init_l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2();
-lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__2);
-l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__3 = _init_l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__3();
-lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___rarg___closed__3);
+l_Lean_Parser_Term_dollar___elambda__1___closed__1 = _init_l_Lean_Parser_Term_dollar___elambda__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___closed__1);
+l_Lean_Parser_Term_dollar___elambda__1___closed__2 = _init_l_Lean_Parser_Term_dollar___elambda__1___closed__2();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___closed__2);
+l_Lean_Parser_Term_dollar___elambda__1___closed__3 = _init_l_Lean_Parser_Term_dollar___elambda__1___closed__3();
+lean_mark_persistent(l_Lean_Parser_Term_dollar___elambda__1___closed__3);
 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();
@@ -39860,8 +39104,6 @@ l_Lean_Parser_Term_dollar___closed__4 = _init_l_Lean_Parser_Term_dollar___closed
 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 = _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());
diff --git a/stage0/stdlib/Init/Lean/Parser/Transform.c b/stage0/stdlib/Init/Lean/Parser/Transform.c
index 62a9b1d11c..0c6cf993ec 100644
--- a/stage0/stdlib/Init/Lean/Parser/Transform.c
+++ b/stage0/stdlib/Init/Lean/Parser/Transform.c
@@ -21,6 +21,7 @@ lean_object* lean_array_get_size(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_setTailInfo(lean_object*, lean_object*);
 lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*);
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 extern lean_object* l___private_Init_Lean_Parser_Parser_14__antiquotNestedExpr___elambda__1___closed__2;
@@ -41,7 +42,6 @@ lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_manyToSepBy___spec__1__
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 extern lean_object* l_Lean_mkOptionalNode___closed__2;
 lean_object* l_Lean_Syntax_getTailInfo___main(lean_object*);
-lean_object* l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_manyToSepBy___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
@@ -61,7 +61,7 @@ else
 {
 lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 x_8 = lean_array_fget(x_3, x_4);
-x_9 = l_Array_back___at_Lean_Parser_checkLeadingFn___spec__1(x_5);
+x_9 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_5);
 x_10 = l_Lean_Syntax_getTailInfo___main(x_9);
 x_11 = lean_unsigned_to_nat(1u);
 x_12 = lean_nat_add(x_4, x_11);
diff --git a/stage0/stdlib/Init/LeanInit.c b/stage0/stdlib/Init/LeanInit.c
index 92489c0675..b824d6b3f8 100644
--- a/stage0/stdlib/Init/LeanInit.c
+++ b/stage0/stdlib/Init/LeanInit.c
@@ -47,7 +47,6 @@ lean_object* l_Lean_Macro_throwUnsupported___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_identKind___closed__1;
 lean_object* l_Lean_fieldIdxKind___closed__2;
 lean_object* l_Lean_Syntax_getOptional_x3f(lean_object*);
-lean_object* l_Lean_ParserDescr_orelse(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_MacroM_monadQuotation___lambda__2(lean_object*);
 lean_object* l___private_Init_LeanInit_8__decodeHexDigit___boxed(lean_object*, lean_object*);
 uint32_t l_Lean_idBeginEscape;
@@ -57,7 +56,6 @@ lean_object* l___private_Init_LeanInit_4__extractMainModule(lean_object*, lean_o
 uint8_t lean_name_eq(lean_object*, lean_object*);
 lean_object* l_Array_filterSepElemsM___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_isAtom___boxed(lean_object*);
-lean_object* l_Lean_ParserDescr_optional(uint8_t, lean_object*);
 lean_object* l_Array_mapSepElemsM___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_toNat___boxed(lean_object*);
 lean_object* l_Lean_identKind___closed__2;
@@ -65,7 +63,6 @@ lean_object* l___private_Init_LeanInit_8__decodeHexDigit(lean_object*, lean_obje
 lean_object* l___private_Init_LeanInit_1__eraseMacroScopesAux___main(lean_object*);
 lean_object* l___private_Init_LeanInit_15__mapSepElemsMAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_15__mapSepElemsMAux(lean_object*);
-lean_object* l_Lean_ParserDescr_lookahead(uint8_t, lean_object*);
 lean_object* l_Array_findSomeMAux___main___at_Lean_Syntax_findAux___main___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_5__extractMacroScopesAux(lean_object*, lean_object*);
 extern lean_object* l_Array_empty___closed__1;
@@ -76,21 +73,17 @@ lean_object* l_Lean_fieldIdxKind___closed__1;
 lean_object* l___private_Init_LeanInit_15__mapSepElemsMAux___main(lean_object*);
 uint8_t l_Char_isDigit(uint32_t);
 lean_object* l_Lean_charLitKind___closed__2;
-lean_object* l_Lean_ParserDescr_many(uint8_t, lean_object*);
 lean_object* l_Lean_isGreek___boxed(lean_object*);
 uint32_t l_Lean_idEndEscape;
 lean_object* l___private_Init_LeanInit_7__decodeOctalLitAux(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_isIdRest___boxed(lean_object*);
 lean_object* l_Lean_mkIdentFrom(lean_object*, lean_object*);
 uint8_t l_Lean_isIdBeginEscape(uint32_t);
-lean_object* l_Lean_ParserDescr_ident(uint8_t);
 lean_object* l___private_Init_LeanInit_9__decodeHexLitAux___main(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_strLit(uint8_t);
 lean_object* l_Lean_Name_HasToString___closed__1;
 lean_object* l_Lean_mkNameSimple(lean_object*);
 lean_object* l_Lean_isIdFirst___boxed(lean_object*);
 lean_object* l_Lean_mkHole___boxed(lean_object*);
-lean_object* l_Lean_ParserDescr_andthen___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_14__filterSepElemsMAux___main___at_Array_filterSepElems___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* l_Array_findSomeMAux___main___at_Lean_Syntax_findAux___main___spec__1___boxed(lean_object*, lean_object*, lean_object*);
@@ -102,7 +95,6 @@ lean_object* l_Lean_Syntax_termIdToAntiquot___closed__3;
 lean_object* l___private_Init_LeanInit_12__decodeQuotedChar___boxed__const__4;
 lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_inhabited;
-lean_object* l_Lean_ParserDescr_charLit(uint8_t);
 extern lean_object* l_String_splitAux___main___closed__1;
 lean_object* l_Lean_Syntax_identToStrLit(lean_object*);
 lean_object* l___private_Init_LeanInit_6__decodeBinLitAux___main(lean_object*, lean_object*, lean_object*);
@@ -119,7 +111,6 @@ lean_object* l_Lean_mkIdentFrom___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_decodeStrLitAux___main___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_NameGenerator_Inhabited;
 lean_object* l_Lean_mkTermIdFromIdent___closed__1;
-lean_object* l_Lean_ParserDescr_try(uint8_t, lean_object*);
 lean_object* l_Lean_nameLitKind;
 lean_object* l_Lean_Syntax_termIdToAntiquot___closed__2;
 lean_object* l_Lean_mkAppStx___closed__8;
@@ -143,14 +134,12 @@ lean_object* l_Lean_Syntax_strLitToAtom(lean_object*);
 lean_object* l_Lean_Syntax_isLit_x3f___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_hasArgs___boxed(lean_object*);
 lean_object* l_Lean_mkStxNumLit(lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescrCore_inhabited(uint8_t);
 lean_object* l_Lean_Name_HasAppend___closed__1;
 lean_object* l_Array_mapSepElems___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_Name_hasMacroScopes(lean_object*);
 lean_object* l_Lean_MacroM_monadQuotation___lambda__3(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_isLit_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_termIdToAntiquot___closed__4;
-lean_object* l_Lean_ParserDescr_many1(uint8_t, lean_object*);
 lean_object* l___private_Init_LeanInit_15__mapSepElemsMAux___main___at_Array_mapSepElems___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_isCharLit_x3f(lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
@@ -160,7 +149,6 @@ uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_findAux___main(lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_6__decodeBinLitAux___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_numLitKind;
-lean_object* l_Lean_ParserDescr_many___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_choiceKind___closed__1;
 lean_object* l___private_Init_LeanInit_7__decodeOctalLitAux___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapSepElemsM(lean_object*);
@@ -174,10 +162,8 @@ lean_object* l_Lean_Name_append___main(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_isSimpleTermId_x3f___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getId___boxed(lean_object*);
 lean_object* l___private_Init_LeanInit_13__decodeNameLitAux(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_numLit___boxed(lean_object*);
 lean_object* l_Lean_Syntax_isFieldIdx_x3f(lean_object*);
 lean_object* l_Substring_takeWhileAux___main___at___private_Init_LeanInit_13__decodeNameLitAux___main___spec__2(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_many1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Macro_addMacroScope(lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_14__filterSepElemsMAux___main___at_Array_filterSepElems___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkTermIdFrom___boxed(lean_object*, lean_object*);
@@ -204,47 +190,35 @@ lean_object* l_Lean_mkNullNode(lean_object*);
 lean_object* l_Lean_strLitKind___closed__2;
 lean_object* l_Lean_NameGenerator_Inhabited___closed__1;
 size_t l_Lean_Name_hash(lean_object*);
-lean_object* l_Lean_ParserDescr_parser(uint8_t, lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 lean_object* l_Array_mapSepElemsM___at_Array_mapSepElems___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Name_HasToString;
 lean_object* l___private_Init_LeanInit_13__decodeNameLitAux___main___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_lookahead___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_sepBy(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getId(lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_choiceKind;
 lean_object* l_Lean_charLitKind;
 lean_object* l_Substring_takeWhileAux___main___at___private_Init_LeanInit_13__decodeNameLitAux___main___spec__1___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_andthen(uint8_t, lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_charLit___boxed(lean_object*);
 lean_object* l___private_Init_LeanInit_6__decodeBinLitAux___main___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_symbol___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findSomeMAux___main___at_Lean_Syntax_getHeadInfo___main___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_9__decodeHexLitAux___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_numLitKind___closed__2;
-lean_object* l_Lean_ParserDescr_node(uint8_t, lean_object*, lean_object*);
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
 lean_object* l_Lean_mkAppStx___closed__6;
-lean_object* l_Lean_ParserDescr_try___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_ident___boxed(lean_object*);
 lean_object* l_Lean_mkOptionalNode(lean_object*);
 lean_object* l_Nat_pred(lean_object*);
 uint8_t l_Array_isEmpty___rarg(lean_object*);
 lean_object* l_Lean_Name_toStringWithSep___boxed(lean_object*, lean_object*);
 lean_object* l_Array_filterSepElemsM(lean_object*);
 lean_object* l_Lean_firstFrontendMacroScope;
-lean_object* l_Lean_ParserDescr_node___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_nameLit___boxed(lean_object*);
+lean_object* l_Lean_ParserDescr_inhabited___closed__1;
 lean_object* l_Lean_NameGenerator_mkChild(lean_object*);
-lean_object* l_Lean_ParserDescr_parser___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_isCharLit_x3f___boxed(lean_object*);
 lean_object* l___private_Init_LeanInit_2__assembleParts(lean_object*, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_nullKind___closed__1;
 lean_object* l_Lean_Syntax_decodeStrLit___boxed(lean_object*);
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_nonReservedSymbol___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_isIdEndEscape(uint32_t);
 lean_object* l_Lean_Syntax_decodeCharLit(lean_object*);
 lean_object* l_Lean_MacroScopesView_inhabited___closed__1;
@@ -262,12 +236,8 @@ lean_object* l_Lean_Syntax_getHeadInfo___main(lean_object*);
 lean_object* l_Lean_mkAppStx___closed__3;
 lean_object* l_Lean_isLetterLike___boxed(lean_object*);
 lean_object* l_Lean_Syntax_isIdOrAtom_x3f(lean_object*);
-lean_object* l_Lean_ParserDescrCore_inhabited___boxed(lean_object*);
 uint8_t l_Lean_Name_hasMacroScopes___main(lean_object*);
-lean_object* l_Lean_ParserDescr_strLit___boxed(lean_object*);
 lean_object* l_Lean_identKind;
-lean_object* l_Lean_ParserDescr_trailingNode(lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_sepBy1(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_mkCTermId(lean_object*);
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
 lean_object* l_Lean_Syntax_inhabited;
@@ -305,7 +275,6 @@ lean_object* l___private_Init_LeanInit_12__decodeQuotedChar___boxed__const__2;
 lean_object* l_Lean_mkHole___closed__1;
 lean_object* l_Lean_Name_hasMacroScopes___boxed(lean_object*);
 lean_object* l_Lean_isIdBeginEscape___boxed(lean_object*);
-lean_object* l_Lean_ParserDescr_numLit(uint8_t);
 lean_object* l_Lean_mkStxStrLit(lean_object*, lean_object*);
 lean_object* lean_nat_mul(lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_13__decodeNameLitAux___boxed(lean_object*, lean_object*, lean_object*);
@@ -320,7 +289,6 @@ lean_object* l_Lean_mkTermIdFrom(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_decodeNameLit(lean_object*);
 lean_object* l_Lean_mkOptionalNode___closed__1;
 lean_object* l_Lean_Syntax_isNameLit_x3f(lean_object*);
-lean_object* l_Lean_ParserDescr_orelse___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_isIdEndEscape___boxed(lean_object*);
 lean_object* l_Lean_Syntax_getOptionalIdent_x3f___boxed(lean_object*);
 lean_object* l___private_Init_LeanInit_10__decodeDecimalLitAux___main___boxed(lean_object*, lean_object*, lean_object*);
@@ -333,13 +301,13 @@ lean_object* l_Lean_Syntax_isNone___boxed(lean_object*);
 lean_object* l_Lean_mkCIdentFrom___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_mkHole___closed__2;
 lean_object* l_Lean_mkCIdentFrom___closed__1;
+lean_object* l_Lean_ParserDescr_inhabited;
 lean_object* l_Lean_Syntax_decodeNameLit___boxed(lean_object*);
 lean_object* lean_string_length(lean_object*);
 lean_object* l_Lean_MacroM_monadQuotation___closed__1;
 lean_object* l_Lean_nameLitKind___closed__2;
 uint8_t l_Lean_isSubScriptAlnum(uint32_t);
 lean_object* l_List_foldl___main___at_Lean_MacroScopesView_review___spec__1(lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_sepBy___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Macro_throwUnsupported(lean_object*, lean_object*);
 lean_object* lean_mk_syntax_ident(lean_object*);
 lean_object* l_Lean_mkStxLit(lean_object*, lean_object*, lean_object*);
@@ -362,15 +330,12 @@ lean_object* l_Lean_mkAtomFrom___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_14__filterSepElemsMAux___main___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
 lean_object* l_Array_filterSepElemsM___at_Array_filterSepElems___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*);
-lean_object* l_Lean_ParserDescr_symbol(uint8_t, lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_9__decodeHexLitAux(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MacroM_monadQuotation___lambda__1(lean_object*);
 lean_object* l___private_Init_LeanInit_14__filterSepElemsMAux___boxed(lean_object*);
 uint8_t l_UInt32_decLe(uint32_t, uint32_t);
-lean_object* l_Lean_ParserDescr_optional___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_mkAppStx___closed__2;
 lean_object* l___private_Init_LeanInit_14__filterSepElemsMAux___main___boxed(lean_object*);
-lean_object* l_Lean_ParserDescr_nonReservedSymbol(lean_object*, uint8_t);
 lean_object* l_Lean_Name_hasMacroScopes___main___boxed(lean_object*);
 lean_object* l_Lean_Name_hasMacroScopes___main___closed__1;
 lean_object* l_Lean_Syntax_findAux(lean_object*, lean_object*);
@@ -386,7 +351,6 @@ lean_object* lean_name_mk_numeral(lean_object*, lean_object*);
 lean_object* l_Lean_mkAppStx___closed__1;
 lean_object* l___private_Init_LeanInit_3__extractImported___main(lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_string_hash(lean_object*);
-lean_object* l_Lean_ParserDescr_sepBy1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_1__eraseMacroScopesAux___main___boxed(lean_object*);
 lean_object* l_Lean_Name_append___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_14__filterSepElemsMAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -401,7 +365,6 @@ uint32_t l_Char_ofNat(lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l___private_Init_LeanInit_12__decodeQuotedChar___boxed__const__3;
 uint8_t l_Lean_Syntax_isIdent(lean_object*);
-lean_object* l_Lean_ParserDescr_nameLit(uint8_t);
 uint8_t l_Lean_isGreek(uint32_t x_1) {
 _start:
 {
@@ -1530,399 +1493,24 @@ return x_17;
 }
 }
 }
-lean_object* l_Lean_ParserDescrCore_inhabited(uint8_t x_1) {
+lean_object* _init_l_Lean_ParserDescr_inhabited___closed__1() {
 _start:
 {
-lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = lean_box(0);
-x_3 = l_String_splitAux___main___closed__1;
-x_4 = lean_alloc_ctor(11, 2, 1);
-lean_ctor_set(x_4, 0, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set_uint8(x_4, sizeof(void*)*2, x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescrCore_inhabited___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_ParserDescrCore_inhabited(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_andthen(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-lean_ctor_set_uint8(x_4, sizeof(void*)*2, x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_andthen___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_ParserDescr_andthen(x_4, x_2, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_ParserDescr_orelse(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_alloc_ctor(1, 2, 1);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-lean_ctor_set_uint8(x_4, sizeof(void*)*2, x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_orelse___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_ParserDescr_orelse(x_4, x_2, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_ParserDescr_optional(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_ctor(2, 1, 1);
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_String_splitAux___main___closed__1;
+x_3 = lean_alloc_ctor(11, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
-lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_1);
+lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_ParserDescr_optional___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* _init_l_Lean_ParserDescr_inhabited() {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_ParserDescr_optional(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_lookahead(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_ctor(3, 1, 1);
-lean_ctor_set(x_3, 0, x_2);
-lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_1);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_lookahead___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_ParserDescr_lookahead(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_try(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_ctor(4, 1, 1);
-lean_ctor_set(x_3, 0, x_2);
-lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_1);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_try___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_ParserDescr_try(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_many(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_ctor(5, 1, 1);
-lean_ctor_set(x_3, 0, x_2);
-lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_1);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_many___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_ParserDescr_many(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_many1(uint8_t x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_ctor(6, 1, 1);
-lean_ctor_set(x_3, 0, x_2);
-lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_1);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_many1___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_1);
-lean_dec(x_1);
-x_4 = l_Lean_ParserDescr_many1(x_3, x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_sepBy(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_alloc_ctor(7, 2, 1);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-lean_ctor_set_uint8(x_4, sizeof(void*)*2, x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_sepBy___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_ParserDescr_sepBy(x_4, x_2, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_ParserDescr_sepBy1(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_alloc_ctor(8, 2, 1);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-lean_ctor_set_uint8(x_4, sizeof(void*)*2, x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_sepBy1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_ParserDescr_sepBy1(x_4, x_2, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_ParserDescr_node(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_alloc_ctor(9, 2, 1);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-lean_ctor_set_uint8(x_4, sizeof(void*)*2, x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_node___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_ParserDescr_node(x_4, x_2, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_ParserDescr_trailingNode(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_3, 0, x_1);
-lean_ctor_set(x_3, 1, x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_symbol(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_alloc_ctor(11, 2, 1);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-lean_ctor_set_uint8(x_4, sizeof(void*)*2, x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_symbol___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_ParserDescr_symbol(x_4, x_2, x_3);
-return x_5;
-}
-}
-lean_object* l_Lean_ParserDescr_numLit(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_ctor(13, 0, 1);
-lean_ctor_set_uint8(x_2, 0, x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_ParserDescr_numLit___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_ParserDescr_numLit(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_strLit(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_ctor(14, 0, 1);
-lean_ctor_set_uint8(x_2, 0, x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_ParserDescr_strLit___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_ParserDescr_strLit(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_charLit(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_ctor(15, 0, 1);
-lean_ctor_set_uint8(x_2, 0, x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_ParserDescr_charLit___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_ParserDescr_charLit(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_nameLit(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_ctor(16, 0, 1);
-lean_ctor_set_uint8(x_2, 0, x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_ParserDescr_nameLit___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_ParserDescr_nameLit(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_ident(uint8_t x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_ctor(17, 0, 1);
-lean_ctor_set_uint8(x_2, 0, x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_ParserDescr_ident___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = lean_unbox(x_1);
-lean_dec(x_1);
-x_3 = l_Lean_ParserDescr_ident(x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_nonReservedSymbol(lean_object* x_1, uint8_t x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_ctor(12, 1, 1);
-lean_ctor_set(x_3, 0, x_1);
-lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2);
-return x_3;
-}
-}
-lean_object* l_Lean_ParserDescr_nonReservedSymbol___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = lean_unbox(x_2);
-lean_dec(x_2);
-x_4 = l_Lean_ParserDescr_nonReservedSymbol(x_1, x_3);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_parser(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_alloc_ctor(18, 2, 1);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-lean_ctor_set_uint8(x_4, sizeof(void*)*2, x_1);
-return x_4;
-}
-}
-lean_object* l_Lean_ParserDescr_parser___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-uint8_t x_4; lean_object* x_5; 
-x_4 = lean_unbox(x_1);
-lean_dec(x_1);
-x_5 = l_Lean_ParserDescr_parser(x_4, x_2, x_3);
-return x_5;
+lean_object* x_1; 
+x_1 = l_Lean_ParserDescr_inhabited___closed__1;
+return x_1;
 }
 }
 lean_object* _init_l_Lean_Syntax_inhabited() {
@@ -6957,6 +6545,10 @@ l_Lean_NameGenerator_Inhabited___closed__3 = _init_l_Lean_NameGenerator_Inhabite
 lean_mark_persistent(l_Lean_NameGenerator_Inhabited___closed__3);
 l_Lean_NameGenerator_Inhabited = _init_l_Lean_NameGenerator_Inhabited();
 lean_mark_persistent(l_Lean_NameGenerator_Inhabited);
+l_Lean_ParserDescr_inhabited___closed__1 = _init_l_Lean_ParserDescr_inhabited___closed__1();
+lean_mark_persistent(l_Lean_ParserDescr_inhabited___closed__1);
+l_Lean_ParserDescr_inhabited = _init_l_Lean_ParserDescr_inhabited();
+lean_mark_persistent(l_Lean_ParserDescr_inhabited);
 l_Lean_Syntax_inhabited = _init_l_Lean_Syntax_inhabited();
 lean_mark_persistent(l_Lean_Syntax_inhabited);
 l_Lean_choiceKind___closed__1 = _init_l_Lean_choiceKind___closed__1();