From e525a8d7c3866e2744d9ac136c55c429c2fdde3e Mon Sep 17 00:00:00 2001 From: Leonardo de Moura Date: Fri, 5 Jun 2020 09:58:11 -0700 Subject: [PATCH] chore: update stage0 --- stage0/src/Init/LeanInit.lean | 5 +- stage0/src/Lean/Elab/Syntax.lean | 8 +- stage0/src/Lean/Parser/Command.lean | 18 +- stage0/src/Lean/Parser/Level.lean | 14 +- stage0/src/Lean/Parser/Parser.lean | 203 +- stage0/src/Lean/Parser/Syntax.lean | 22 +- stage0/src/Lean/Parser/Tactic.lean | 10 +- stage0/src/Lean/Parser/Term.lean | 135 +- stage0/stdlib/Init/LeanInit.c | 10 +- stage0/stdlib/Lean/Elab/Syntax.c | 2689 +- stage0/stdlib/Lean/Parser/Command.c | 1476 +- stage0/stdlib/Lean/Parser/Level.c | 2139 +- stage0/stdlib/Lean/Parser/Module.c | 24 +- stage0/stdlib/Lean/Parser/Parser.c | 3775 +- stage0/stdlib/Lean/Parser/Syntax.c | 1551 +- stage0/stdlib/Lean/Parser/Tactic.c | 2241 +- stage0/stdlib/Lean/Parser/Term.c | 29009 ++++++++-------- .../stdlib/Lean/PrettyPrinter/Parenthesizer.c | 61 +- 18 files changed, 21950 insertions(+), 21440 deletions(-) diff --git a/stage0/src/Init/LeanInit.lean b/stage0/src/Init/LeanInit.lean index 6895bd8890..71723ef23b 100644 --- a/stage0/src/Init/LeanInit.lean +++ b/stage0/src/Init/LeanInit.lean @@ -148,16 +148,17 @@ inductive ParserDescr | sepBy1 : ParserDescr → ParserDescr → ParserDescr | node : Name → ParserDescr → ParserDescr | trailingNode : Name → ParserDescr → ParserDescr -| symbol : String → Nat → ParserDescr +| symbol : String → ParserDescr | nonReservedSymbol : String → Bool → ParserDescr | numLit : ParserDescr | strLit : ParserDescr | charLit : ParserDescr | nameLit : ParserDescr | ident : ParserDescr +| rbpLt : Nat → ParserDescr | parser : Name → Nat → ParserDescr -instance ParserDescr.inhabited : Inhabited ParserDescr := ⟨ParserDescr.symbol "" 0⟩ +instance ParserDescr.inhabited : Inhabited ParserDescr := ⟨ParserDescr.symbol ""⟩ abbrev TrailingParserDescr := ParserDescr /- Syntax -/ diff --git a/stage0/src/Lean/Elab/Syntax.lean b/stage0/src/Lean/Elab/Syntax.lean index 183a1c8701..8b3fe25d19 100644 --- a/stage0/src/Lean/Elab/Syntax.lean +++ b/stage0/src/Lean/Elab/Syntax.lean @@ -102,13 +102,7 @@ partial def toParserDescrAux : Syntax → ToParserDescrM Syntax if ctx.leadingIdentAsSymbol && rbp?.isNone then `(ParserDescr.nonReservedSymbol $(quote atom) false) else - match rbp? with - | some rbp => `(ParserDescr.symbol $(quote atom) $(quote rbp)) - | none => do - env ← liftM getEnv; - match Parser.getTokenLbp? env atom with - | some lbp => `(ParserDescr.symbol $(quote atom) $(quote lbp)) - | none => `(ParserDescr.symbol $(quote atom) 0) + `(ParserDescr.symbol $(quote atom)) | none => liftM throwUnsupportedSyntax else if kind == `Lean.Parser.Syntax.num then `(ParserDescr.numLit) diff --git a/stage0/src/Lean/Parser/Command.lean b/stage0/src/Lean/Parser/Command.lean index 5a4bcd658a..a88ccb259c 100644 --- a/stage0/src/Lean/Parser/Command.lean +++ b/stage0/src/Lean/Parser/Command.lean @@ -23,7 +23,7 @@ categoryParser `command rbp `($x $y) will be parsed as an application, not two commands. Use `($x:command $y:command) instead. Multiple command will be put in a `null node, but a single command will not (so that you can directly match against a quotation in a command kind's elaborator). -/ -@[builtinTermParser] def Term.stxQuot := parser! symbol "`(" appPrec >> (termParser <|> many1 commandParser true) >> ")" +@[builtinTermParser] def Term.stxQuot := parser! [appPrec] "`(" >> (termParser <|> many1 commandParser true) >> ")" namespace Command def commentBody : Parser := @@ -54,15 +54,15 @@ def «constant» := parser! "constant " >> declId >> declSig >> optional d def «instance» := parser! "instance " >> optional declId >> declSig >> declVal def «axiom» := parser! "axiom " >> declId >> declSig def «example» := parser! "example " >> declSig >> declVal -def inferMod := parser! try (symbol "{" appPrec >> "}") +def inferMod := parser! try ("{" >> "}") def introRule := parser! " | " >> ident >> optional inferMod >> optDeclSig def «inductive» := parser! "inductive " >> declId >> optDeclSig >> many introRule def classInductive := parser! try ("class " >> "inductive ") >> declId >> optDeclSig >> many introRule -def structExplicitBinder := parser! symbol "(" appPrec >> many ident >> optional inferMod >> optDeclSig >> optional Term.binderDefault >> ")" -def structImplicitBinder := parser! symbol "{" appPrec >> many ident >> optional inferMod >> optDeclSig >> "}" -def structInstBinder := parser! symbol "[" appPrec >> many ident >> optional inferMod >> optDeclSig >> "]" +def structExplicitBinder := parser! "(" >> many ident >> optional inferMod >> optDeclSig >> optional Term.binderDefault >> ")" +def structImplicitBinder := parser! "{" >> many ident >> optional inferMod >> optDeclSig >> "}" +def structInstBinder := parser! "[" >> many ident >> optional inferMod >> optDeclSig >> "]" def structFields := parser! many (structExplicitBinder <|> structImplicitBinder <|> structInstBinder) -def structCtor := parser! ident >> optional inferMod >> symbol " :: " 67 +def structCtor := parser! ident >> optional inferMod >> " :: " def structureTk := parser! "structure " def classTk := parser! "class " def «extends» := parser! " extends " >> sepBy1 termParser ", " @@ -85,12 +85,12 @@ declModifiers >> («abbrev» <|> «def» <|> «theorem» <|> «constant» <|> « @[builtinCommandParser] def «resolve_name» := parser! "#resolve_name " >> ident @[builtinCommandParser] def «init_quot» := parser! "init_quot" @[builtinCommandParser] def «set_option» := parser! "set_option " >> ident >> (nonReservedSymbol "true" <|> nonReservedSymbol "false" <|> strLit <|> numLit) -@[builtinCommandParser] def «attribute» := parser! optional "local " >> "attribute " >> symbol "[" appPrec >> sepBy1 attrInstance ", " >> "]" >> many1 ident -@[builtinCommandParser] def «export» := parser! "export " >> ident >> symbol "(" appPrec >> many1 ident >> ")" +@[builtinCommandParser] def «attribute» := parser! optional "local " >> "attribute " >> "[" >> sepBy1 attrInstance ", " >> "]" >> many1 ident +@[builtinCommandParser] def «export» := parser! "export " >> ident >> "(" >> many1 ident >> ")" def openHiding := parser! try (ident >> "hiding") >> many1 ident def openRenamingItem := parser! ident >> unicodeSymbol "→" "->" >> ident def openRenaming := parser! try (ident >> "renaming") >> sepBy1 openRenamingItem ", " -def openOnly := parser! try (ident >> symbol "(" appPrec) >> many1 ident >> ")" +def openOnly := parser! try (ident >> "(") >> many1 ident >> ")" def openSimple := parser! many1 ident @[builtinCommandParser] def «open» := parser! "open " >> (openHiding <|> openRenaming <|> openOnly <|> openSimple) diff --git a/stage0/src/Lean/Parser/Level.lean b/stage0/src/Lean/Parser/Level.lean index 9d12fff1a8..7182754723 100644 --- a/stage0/src/Lean/Parser/Level.lean +++ b/stage0/src/Lean/Parser/Level.lean @@ -17,13 +17,13 @@ categoryParser `level rbp namespace Level -@[builtinLevelParser] def paren := parser! symbol "(" appPrec >> levelParser >> ")" -@[builtinLevelParser] def max := parser! nonReservedSymbol "max " true >> many1 (levelParser appPrec) -@[builtinLevelParser] def imax := parser! nonReservedSymbol "imax " true >> many1 (levelParser appPrec) -@[builtinLevelParser] def hole := parser! symbol "_" appPrec -@[builtinLevelParser] def num := parser! numLit -@[builtinLevelParser] def ident := parser! ident -@[builtinLevelParser] def addLit := tparser! symbol "+" (65:Nat) >> numLit +@[builtinLevelParser] def paren := parser! [appPrec] "(" >> levelParser >> ")" +@[builtinLevelParser] def max := parser! [appPrec] nonReservedSymbol "max " true >> many1 (levelParser appPrec) +@[builtinLevelParser] def imax := parser! [appPrec] nonReservedSymbol "imax " true >> many1 (levelParser appPrec) +@[builtinLevelParser] def hole := parser! [appPrec] "_" +@[builtinLevelParser] def num := parser! [appPrec] numLit +@[builtinLevelParser] def ident := parser! [appPrec] ident +@[builtinLevelParser] def addLit := tparser! [65] "+" >> numLit end Level diff --git a/stage0/src/Lean/Parser/Parser.lean b/stage0/src/Lean/Parser/Parser.lean index 2e0b17b7c2..e1078664d2 100644 --- a/stage0/src/Lean/Parser/Parser.lean +++ b/stage0/src/Lean/Parser/Parser.lean @@ -92,28 +92,7 @@ input.get (input.next pos) (e.g., a list). -/ def appPrec : Nat := 1024 -structure TokenConfig := -(val : String) -(lbp : Option Nat := none) -(lbpNoWs : Option Nat := none) -- optional left-binding power when there is not whitespace before the token. - -namespace TokenConfig - -def beq : TokenConfig → TokenConfig → Bool -| ⟨val₁, lbp₁, lbpnws₁⟩, ⟨val₂, lbp₂, lbpnws₂⟩ => val₁ == val₂ && lbp₁ == lbp₂ && lbpnws₁ == lbpnws₂ - -instance : HasBeq TokenConfig := -⟨beq⟩ - -def toStr : TokenConfig → String -| ⟨val, some lbp, some lbpnws⟩ => val ++ ":" ++ toString lbp ++ ":" ++ toString lbpnws -| ⟨val, some lbp, none⟩ => val ++ ":" ++ toString lbp -| ⟨val, none, some lbpnws⟩ => val ++ ":none:" ++ toString lbpnws -| ⟨val, none, none⟩ => val - -instance : HasToString TokenConfig := ⟨toStr⟩ - -end TokenConfig +abbrev Token := String structure TokenCacheEntry := (startPos stopPos : String.Pos := 0) @@ -125,7 +104,7 @@ structure ParserCache := def initCacheForInput (input : String) : ParserCache := { tokenCache := { startPos := input.bsize + 1 /- make sure it is not a valid position -/} } -abbrev TokenTable := Trie TokenConfig +abbrev TokenTable := Trie Token abbrev SyntaxNodeKindSet := PersistentHashMap SyntaxNodeKind Unit @@ -276,8 +255,8 @@ instance ParserFn.inhabited : Inhabited ParserFn := ⟨fun _ => id⟩ inductive FirstTokens | epsilon : FirstTokens | unknown : FirstTokens -| tokens : List TokenConfig → FirstTokens -| optTokens : List TokenConfig → FirstTokens +| tokens : List Token → FirstTokens +| optTokens : List Token → FirstTokens namespace FirstTokens @@ -311,7 +290,7 @@ instance : HasToString FirstTokens := ⟨toStr⟩ end FirstTokens structure ParserInfo := -(collectTokens : List TokenConfig → List TokenConfig := id) +(collectTokens : List Token → List Token := id) (collectKinds : SyntaxNodeKindSet → SyntaxNodeKindSet := id) (firstTokens : FirstTokens := FirstTokens.unknown) @@ -793,31 +772,30 @@ def isIdCont : String → ParserState → Bool else false -private def isToken (idStartPos idStopPos : Nat) (tk : Option TokenConfig) : Bool := +private def isToken (idStartPos idStopPos : Nat) (tk : Option Token) : Bool := match tk with | none => false | some tk => -- if a token is both a symbol and a valid identifier (i.e. a keyword), -- we want it to be recognized as a symbol - tk.val.bsize ≥ idStopPos - idStartPos + tk.bsize ≥ idStopPos - idStartPos -def mkTokenAndFixPos (startPos : Nat) (tk : Option TokenConfig) : ParserFn := +def mkTokenAndFixPos (startPos : Nat) (tk : Option Token) : ParserFn := fun c s => match tk with | none => s.mkErrorAt "token" startPos | some tk => let input := c.input; let leading := mkEmptySubstringAt input startPos; - let val := tk.val; - let stopPos := startPos + val.bsize; + let stopPos := startPos + tk.bsize; let s := s.setPos stopPos; let s := whitespace c s; let wsStopPos := s.pos; let trailing := { str := input, startPos := stopPos, stopPos := wsStopPos : Substring }; - let atom := mkAtom { leading := leading, pos := startPos, trailing := trailing } val; + let atom := mkAtom { leading := leading, pos := startPos, trailing := trailing } tk; s.pushSyntax atom -def mkIdResult (startPos : Nat) (tk : Option TokenConfig) (val : Name) : ParserFn := +def mkIdResult (startPos : Nat) (tk : Option Token) (val : Name) : ParserFn := fun c s => let stopPos := s.pos; if isToken startPos stopPos tk then @@ -833,7 +811,7 @@ else let atom := mkIdent info rawVal val; s.pushSyntax atom -partial def identFnAux (startPos : Nat) (tk : Option TokenConfig) : Name → ParserFn +partial def identFnAux (startPos : Nat) (tk : Option Token) : Name → ParserFn | r, c, s => let input := c.input; let i := s.pos; @@ -961,20 +939,20 @@ fun c s => @[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 } ] } +def symbolInfo (sym : String) : ParserInfo := +{ collectTokens := fun tks => sym :: tks, + firstTokens := FirstTokens.tokens [ sym ] } @[inline] def symbolFn (sym : String) : ParserFn := symbolFnAux sym ("'" ++ sym ++ "'") -@[inline] def symbolAux (sym : String) (lbp : Option Nat := none) : Parser := +@[inline] def symbolAux (sym : String) : Parser := let sym := sym.trim; -{ info := symbolInfo sym lbp, +{ info := symbolInfo sym, fn := symbolFn sym } -@[inline] def symbol (sym : String) (lbp : Nat) : Parser := -symbolAux sym lbp +@[inline] def symbol (sym : String) : Parser := +symbolAux sym /-- Check if the following token is the symbol _or_ identifier `sym`. Useful for parsing local tokens that have not been added to the token table (but may have @@ -1006,9 +984,9 @@ nonReservedSymbolFnAux sym ("'" ++ sym ++ "'") def nonReservedSymbolInfo (sym : String) (includeIdent : Bool) : ParserInfo := { firstTokens := if includeIdent then - FirstTokens.tokens [ { val := sym }, { val := "ident" } ] + FirstTokens.tokens [ sym, "ident" ] else - FirstTokens.tokens [ { val := sym } ] } + FirstTokens.tokens [ sym ] } @[inline] def nonReservedSymbol (sym : String) (includeIdent := false) : Parser := let sym := sym.trim; @@ -1057,9 +1035,9 @@ def checkNoWsBefore (errorMsg : String) : Parser := { info := epsilonInfo, 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 } ] } +def symbolNoWsInfo (sym : String) : ParserInfo := +{ collectTokens := fun tks => sym :: tks, + firstTokens := FirstTokens.tokens [ sym ] } @[inline] def symbolNoWsFnAux (sym : String) (errorMsg : String) : ParserFn := fun c s => @@ -1082,28 +1060,28 @@ fun c s => symbolNoWsFnAux sym ("'" ++ sym ++ "' without whitespace 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) : Parser := +@[inline] def symbolNoWsAux (sym : String) : Parser := let sym := sym.trim; -{ info := symbolNoWsInfo sym lbp, +{ info := symbolNoWsInfo sym, fn := symbolNoWsFn sym } -@[inline] def symbolNoWs (sym : String) (lbp : Nat) : Parser := -symbolNoWsAux sym lbp +@[inline] def symbolNoWs (sym : String) : Parser := +symbolNoWsAux sym 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 } ] } +def unicodeSymbolInfo (sym asciiSym : String) : ParserInfo := +{ collectTokens := fun tks => sym :: asciiSym :: tks, + firstTokens := FirstTokens.tokens [ sym, asciiSym ] } @[inline] def unicodeSymbolFn (sym asciiSym : String) : ParserFn := unicodeSymbolFnAux sym asciiSym ["'" ++ sym ++ "', '" ++ asciiSym ++ "'"] -@[inline] def unicodeSymbol (sym asciiSym : String) (lbp : Option Nat := none) : Parser := +@[inline] def unicodeSymbol (sym asciiSym : String) : Parser := let sym := sym.trim; let asciiSym := asciiSym.trim; -{ info := unicodeSymbolInfo sym asciiSym lbp, +{ info := unicodeSymbolInfo sym asciiSym, fn := unicodeSymbolFn sym asciiSym } /- Succeeds if RBP < upper -/ @@ -1112,12 +1090,14 @@ fun c s => if c.rbp < upper then s else s.mkUnexpectedError errorMsg -def checkRbpLt (lower : Nat) (errorMsg : String := "unexpected RBP") : Parser := +private def precErrorMsg := "unexpected token at this precedence level; consider parenthesizing the term" + +@[inline] def checkRbpLt (upper : Nat) (errorMsg : String := precErrorMsg) : Parser := { info := epsilonInfo, - fn := checkRbpLtFn lower errorMsg } + fn := checkRbpLtFn upper errorMsg } /- Succeeds if RBP <= upper -/ -def checkRbpLe (upper : Nat) (errorMsg : String := "unexpected RBP") : Parser := +@[inline] def checkRbpLe (upper : Nat) (errorMsg : String := precErrorMsg) : Parser := checkRbpLt (upper + 1) errorMsg /- Version of `leadingNode` which uses `checkRbpLe` -/ @@ -1126,11 +1106,11 @@ checkRbpLt (upper + 1) errorMsg checkRbpLe prec >> leadingNode n p /- Version of `trailingNode` which uses `checkRbpLt` -/ -@[inline] def trailingNodePrec (n : SyntaxNodeKind) (prec : Nat) (p : Parser) : Parser := +@[inline] def trailingNodePrec (n : SyntaxNodeKind) (prec : Nat) (p : Parser) : TrailingParser := checkRbpLt prec >> trailingNode n p def mkAtomicInfo (k : String) : ParserInfo := -{ firstTokens := FirstTokens.tokens [ { val := k } ] } +{ firstTokens := FirstTokens.tokens [ k ] } def numLitFn : ParserFn := fun c s => @@ -1219,7 +1199,7 @@ def unquotedSymbol : Parser := { fn := unquotedSymbolFn } instance stringToParserCoe : HasCoe String Parser := -⟨fun s => symbol s 0⟩ +⟨fun s => symbol s ⟩ namespace ParserState @@ -1390,27 +1370,6 @@ instance ParserCategory.inhabited : Inhabited ParserCategory := ⟨{ tables := { abbrev ParserCategories := PersistentHashMap Name ParserCategory -def currLbp (left : Syntax) (c : ParserContext) (s : ParserState) : ParserState × Nat := -let (s, stx?) := peekToken c s; -match stx? with -| some stx@(Syntax.atom _ sym) => - if sym == "$" && checkTailNoWs stx then (s, appPrec) -- TODO: split `lbpNoWs` into "before" and "after", and set right lbp for '$' in antiquotations - else match c.tokens.matchPrefix sym 0 with - | (_, some tk) => match tk.lbp, tk.lbpNoWs with - | some lbp, none => (s, lbp) - | none, some lbpNoWs => (s, lbpNoWs) - | some lbp, some lbpNoWs => if checkTailNoWs left then (s, lbpNoWs) else (s, lbp) - | none, none => (s, 0) - | _ => (s, 0) -| some (Syntax.ident _ _ _ _) => (s, appPrec) --- TODO(Leo): add support for associating lbp with syntax node kinds. -| some (Syntax.node k _) => - if isLitKind k || k == fieldIdxKind then - (s, appPrec) - else - (s, 0) -| _ => (s, 0) - def indexed {α : Type} (map : TokenMap α) (c : ParserContext) (s : ParserState) (leadingIdentAsSymbol : Bool) : ParserState × List α := let (s, stx) := peekToken c s; let find (n : Name) : ParserState × List α := @@ -1459,7 +1418,7 @@ categoryParser `term rbp /- Antiquotations -/ /- ============== -/ -def dollarSymbol : Parser := symbol "$" 1 +def dollarSymbol : Parser := symbol "$" /-- Fail if previous token is immediately followed by ':'. -/ private def noImmediateColon : Parser := @@ -1489,7 +1448,7 @@ 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. -def antiquotNestedExpr : Parser := node `antiquotNestedExpr (symbol "(" appPrec >> termParser >> ")") +def antiquotNestedExpr : Parser := node `antiquotNestedExpr (symbol "(" >> termParser >> ")") def antiquotExpr : Parser := identNoAntiquot <|> antiquotNestedExpr /-- @@ -1500,7 +1459,7 @@ def antiquotExpr : Parser := identNoAntiquot <|> antiquotNestedExpr produces the syntax tree for `$e`. -/ 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; +let nameP := checkNoWsBefore ("no space before ':" ++ name ++ "'") >> symbol ":" >> nonReservedSymbol name; -- if parsing the kind fails and `anonymous` is true, check that we're not ignoring a different -- antiquotation kind via `noImmediateColon` let nameP := if anonymous then nameP <|> noImmediateColon >> pushNone >> pushNone else nameP; @@ -1510,7 +1469,7 @@ node kind $ try $ many (checkNoWsBefore "" >> dollarSymbol) >> checkNoWsBefore "no space before spliced term" >> antiquotExpr >> nameP >> - optional (checkNoWsBefore "" >> symbolAux "*" none) + optional (checkNoWsBefore "" >> symbol "*") def tryAnti (c : ParserContext) (s : ParserState) : Bool := let (s, stx?) := peekToken c s; @@ -1597,21 +1556,19 @@ s.pushSyntax result partial def trailingLoop (tables : PrattParsingTables) (c : ParserContext) : ParserState → ParserState | s => - let left := s.stxStack.back; - let (s, lbp) := currLbp left c s; - if c.rbp ≥ lbp then s + let identAsSymbol := false; + let (s, ps) := indexed tables.trailingTable c s identAsSymbol; + if ps.isEmpty && tables.trailingParsers.isEmpty then + s -- no available trailing parser else - let iniSz := s.stackSize; - let identAsSymbol := false; - let (s, ps) := indexed tables.trailingTable c s identAsSymbol; - if ps.isEmpty && tables.trailingParsers.isEmpty then - s -- no available trailing parser + let iniSz := s.stackSize; + let iniPos := s.pos; + let s := trailingLoopStep tables ps c s; + if s.hasError then + if s.pos == iniPos then s.restore iniSz iniPos else s else - let s := trailingLoopStep tables ps c s; - if s.hasError then s - else - let s := mkTrailingResult s iniSz; - trailingLoop s + let s := mkTrailingResult s iniSz; + trailingLoop s /-- @@ -1636,14 +1593,13 @@ partial def trailingLoop (tables : PrattParsingTables) (c : ParserContext) : Par overlap with antiquotation parsers nested inside them. -/ @[inline] def prattParser (kind : Name) (tables : PrattParsingTables) (leadingIdentAsSymbol : Bool) (antiquotParser : ParserFn) : ParserFn := fun c s => - let left := s.stxStack.back; - let (s, lbp) := currLbp left c s; - if c.rbp > lbp then s.mkUnexpectedError "unexpected token" + let iniSz := s.stackSize; + let iniPos := s.pos; + let s := leadingParser kind tables leadingIdentAsSymbol antiquotParser c s; + if s.hasError then + s else - let s := leadingParser kind tables leadingIdentAsSymbol antiquotParser c s; - if s.hasError then s - else - trailingLoop tables c s + trailingLoop tables c s def mkBuiltinTokenTable : IO (IO.Ref TokenTable) := IO.mkRef {} @[init mkBuiltinTokenTable] constant builtinTokenTable : IO.Ref TokenTable := arbitrary _ @@ -1671,13 +1627,13 @@ categories ← IO.ofExcept $ addParserCategoryCore categories catName { tables : builtinParserCategoriesRef.set categories inductive ParserExtensionOleanEntry -| token (val : TokenConfig) : ParserExtensionOleanEntry +| token (val : Token) : ParserExtensionOleanEntry | kind (val : SyntaxNodeKind) : ParserExtensionOleanEntry | category (catName : Name) (leadingIdentAsSymbol : Bool) | parser (catName : Name) (declName : Name) : ParserExtensionOleanEntry inductive ParserExtensionEntry -| token (val : TokenConfig) : ParserExtensionEntry +| token (val : Token) : ParserExtensionEntry | kind (val : SyntaxNodeKind) : ParserExtensionEntry | category (catName : Name) (leadingIdentAsSymbol : Bool) | parser (catName : Name) (declName : Name) (leading : Bool) (p : Parser) : ParserExtensionEntry @@ -1706,14 +1662,11 @@ private def mergePrecendences (msgPreamble : String) (sym : String) : Option Nat else throw $ msgPreamble ++ "precedence mismatch for '" ++ toString sym ++ "', previous: " ++ toString a ++ ", new: " ++ toString b -private def addTokenConfig (tokens : TokenTable) (tk : TokenConfig) : Except String TokenTable := do -if tk.val == "" then throw "invalid empty symbol" -else match tokens.find? tk.val with - | none => pure $ tokens.insert tk.val tk - | some oldTk => do - lbp ← mergePrecendences "" tk.val oldTk.lbp tk.lbp; - lbpNoWs ← mergePrecendences "(no whitespace) " tk.val oldTk.lbpNoWs tk.lbpNoWs; - pure $ tokens.insert tk.val { tk with lbp := lbp, lbpNoWs := lbpNoWs } +private def addTokenConfig (tokens : TokenTable) (tk : Token) : Except String TokenTable := do +if tk == "" then throw "invalid empty symbol" +else match tokens.find? tk with + | none => pure $ tokens.insert tk tk + | some _ => pure tokens def throwUnknownParserCategory {α} (catName : Name) : ExceptT String Id α := throw ("unknown parser category '" ++ toString catName ++ "'") @@ -1723,8 +1676,8 @@ match categories.find? catName with | none => throwUnknownParserCategory catName | some cat => - let addTokens (tks : List TokenConfig) : Except String ParserCategories := - let tks := tks.map $ fun tk => mkNameSimple tk.val; + let addTokens (tks : List Token) : Except String ParserCategories := + let tks := tks.map $ fun tk => mkNameSimple tk; let tables := tks.eraseDups.foldl (fun (tables : PrattParsingTables) tk => { tables with leadingTable := tables.leadingTable.insert tk p }) cat.tables; pure $ categories.insert catName { cat with tables := tables }; match p.info.firstTokens with @@ -1735,8 +1688,8 @@ match categories.find? catName with pure $ categories.insert catName { cat with tables := tables } private def addTrailingParserAux (tables : PrattParsingTables) (p : TrailingParser) : PrattParsingTables := -let addTokens (tks : List TokenConfig) : PrattParsingTables := - let tks := tks.map $ fun tk => mkNameSimple tk.val; +let addTokens (tks : List Token) : PrattParsingTables := + let tks := tks.map $ fun tk => mkNameSimple tk; tks.eraseDups.foldl (fun (tables : PrattParsingTables) tk => { tables with trailingTable := tables.trailingTable.insert tk p }) tables; match p.info.firstTokens with | FirstTokens.tokens tks => addTokens tks @@ -1806,12 +1759,13 @@ def compileParserDescr (categories : ParserCategories) : ParserDescr → Except | 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 $ symbol tk lbp +| ParserDescr.symbol tk => pure $ symbol tk | ParserDescr.numLit => pure $ numLit | ParserDescr.strLit => pure $ strLit | ParserDescr.charLit => pure $ charLit | ParserDescr.nameLit => pure $ nameLit | ParserDescr.ident => pure $ ident +| ParserDescr.rbpLt prec => pure $ checkRbpLt prec | ParserDescr.nonReservedSymbol tk includeIdent => pure $ nonReservedSymbol tk includeIdent | ParserDescr.parser catName rbp => match categories.find? catName with @@ -1916,7 +1870,7 @@ fun ctx s => @[init] def setCategoryParserFnRef : IO Unit := categoryParserFnRef.set categoryParserFnImpl -def addToken (env : Environment) (tk : TokenConfig) : Except String Environment := do +def addToken (env : Environment) (tk : Token) : Except String Environment := do -- Recall that `ParserExtension.addEntry` is pure, and assumes `addTokenConfig` does not fail. -- So, we must run it here to handle exception. _ ← addTokenConfig (parserExtension.getState env).tokens tk; @@ -1936,11 +1890,6 @@ kinds.foldl (fun ks k _ => k::ks) [] def getTokenTable (env : Environment) : TokenTable := (parserExtension.getState env).tokens -def getTokenLbp? (env : Environment) (sym : String) : Option Nat := do -let tokens := getTokenTable env; -tk ← tokens.find? sym; -tk.lbp - def mkInputContext (input : String) (fileName : String) : InputContext := { input := input, fileName := fileName, diff --git a/stage0/src/Lean/Parser/Syntax.lean b/stage0/src/Lean/Parser/Syntax.lean index 04a8d5082b..bbf19c9036 100644 --- a/stage0/src/Lean/Parser/Syntax.lean +++ b/stage0/src/Lean/Parser/Syntax.lean @@ -23,9 +23,9 @@ def «precedence» := parser! ":" >> precedenceLit def optPrecedence := optional (try «precedence») namespace Syntax -@[builtinSyntaxParser] def paren := parser! symbol "(" appPrec >> many1 syntaxParser >> ")" -@[builtinSyntaxParser] def cat := parser! ident >> optPrecedence -@[builtinSyntaxParser] def atom := parser! strLit >> optPrecedence +@[builtinSyntaxParser] def paren := parser! [appPrec] "(" >> many1 syntaxParser >> ")" +@[builtinSyntaxParser] def cat := parser! [appPrec] ident >> optPrecedence +@[builtinSyntaxParser] def atom := parser! [appPrec] strLit >> optPrecedence @[builtinSyntaxParser] def num := parser! nonReservedSymbol "num" @[builtinSyntaxParser] def str := parser! nonReservedSymbol "str" @[builtinSyntaxParser] def char := parser! nonReservedSymbol "char" @@ -35,10 +35,10 @@ namespace Syntax @[builtinSyntaxParser] def sepBy := parser! nonReservedSymbol "sepBy " >> syntaxParser appPrec >> syntaxParser appPrec @[builtinSyntaxParser] def sepBy1 := parser! nonReservedSymbol "sepBy1 " >> syntaxParser appPrec >> syntaxParser appPrec -@[builtinSyntaxParser] def optional := tparser! symbolAux "?" none -@[builtinSyntaxParser] def many := tparser! symbolAux "*" none -@[builtinSyntaxParser] def many1 := tparser! symbolAux "+" none -@[builtinSyntaxParser] def orelse := tparser! symbol " <|> " 2 >> syntaxParser 1 +@[builtinSyntaxParser] def optional := tparser! "?" +@[builtinSyntaxParser] def many := tparser! "*" +@[builtinSyntaxParser] def many1 := tparser! "+" +@[builtinSyntaxParser] def orelse := tparser! [2] " <|> " >> syntaxParser 1 end Syntax @@ -59,7 +59,7 @@ def mixfixSymbol := quotedSymbolPrec <|> unquotedSymbol def strLitPrec := parser! strLit >> optPrecedence def identPrec := parser! ident >> optPrecedence -def optKind : Parser := optional (symbol "[" appPrec >> ident >> "]") +def optKind : Parser := optional ("[" >> ident >> "]") -- TODO: remove " := " after old frontend is gone @[builtinCommandParser] def «notation» := parser! "notation" >> many (strLitPrec <|> quotedSymbolPrec <|> identPrec) >> (" := " <|> darrow) >> termParser @[builtinCommandParser] def «macro_rules» := parser! "macro_rules" >> optKind >> Term.matchAlts @@ -69,9 +69,9 @@ def macroArgType := nonReservedSymbol "ident" <|> nonReservedSymbol "num" <|> def macroArgSimple := parser! ident >> checkNoWsBefore "no space before ':'" >> ":" >> macroArgType def macroArg := try strLitPrec <|> try macroArgSimple def macroHead := macroArg <|> try identPrec -def macroTailTactic : Parser := try (" : " >> identEq "tactic") >> darrow >> symbol "`(" appPrec >> sepBy1 tacticParser "; " true true >> ")" -def macroTailCommand : Parser := try (" : " >> identEq "command") >> darrow >> symbol "`(" appPrec >> many1 commandParser true >> ")" -def macroTailDefault : Parser := try (" : " >> ident) >> darrow >> ((symbol "`(" appPrec >> categoryParserOfStack 2 >> ")") <|> termParser) +def macroTailTactic : Parser := try (" : " >> identEq "tactic") >> darrow >> "`(" >> sepBy1 tacticParser "; " true true >> ")" +def macroTailCommand : Parser := try (" : " >> identEq "command") >> darrow >> "`(" >> many1 commandParser true >> ")" +def macroTailDefault : Parser := try (" : " >> ident) >> darrow >> (("`(" >> categoryParserOfStack 2 >> ")") <|> termParser) def macroTail := macroTailTactic <|> macroTailCommand <|> macroTailDefault @[builtinCommandParser] def «macro» := parser! "macro " >> macroHead >> many macroArg >> macroTail diff --git a/stage0/src/Lean/Parser/Tactic.lean b/stage0/src/Lean/Parser/Tactic.lean index d129c79044..658bda0b7d 100644 --- a/stage0/src/Lean/Parser/Tactic.lean +++ b/stage0/src/Lean/Parser/Tactic.lean @@ -37,7 +37,7 @@ def ident' : Parser := ident <|> underscore @[builtinTacticParser] def «skip» := parser! nonReservedSymbol "skip" @[builtinTacticParser] def «traceState» := parser! nonReservedSymbol "traceState" @[builtinTacticParser] def «failIfSuccess» := parser! nonReservedSymbol "failIfSuccess " >> tacticParser -@[builtinTacticParser] def «generalize» := parser! nonReservedSymbol "generalize" >> optional (try (ident >> " : ")) >> termParser 50 >> symbol " = " 50 >> ident +@[builtinTacticParser] def «generalize» := parser! nonReservedSymbol "generalize" >> optional (try (ident >> " : ")) >> termParser 50 >> " = " >> ident def majorPremise := parser! optional (try (ident >> " : ")) >> termParser def inductionAlt : Parser := nodeWithAntiquot "inductionAlt" `Lean.Parser.Tactic.inductionAlt $ ident' >> many ident' >> darrow >> (Term.hole <|> Term.namedHole <|> tacticParser) def inductionAlts : Parser := withPosition $ fun pos => "|" >> sepBy1 inductionAlt (checkColGe pos.column "alternatives must be indented" >> "|") @@ -48,10 +48,10 @@ def generalizingVars := optional (" generalizing " >> many1 ident) @[builtinTacticParser] def «cases» := parser! nonReservedSymbol "cases " >> majorPremise >> withAlts def withIds : Parser := optional (" with " >> many1 ident') @[builtinTacticParser] def «injection» := parser! nonReservedSymbol "injection " >> termParser >> withIds -@[builtinTacticParser] def paren := parser! symbol "(" appPrec >> nonEmptySeq >> ")" -@[builtinTacticParser] def nestedTacticBlock := parser! symbol "begin " appPrec >> seq >> "end" -@[builtinTacticParser] def nestedTacticBlockCurly := parser! symbol "{" appPrec >> seq >> "}" -@[builtinTacticParser] def orelse := tparser! symbol " <|> " 2 >> tacticParser 1 +@[builtinTacticParser] def paren := parser! [appPrec] "(" >> nonEmptySeq >> ")" +@[builtinTacticParser] def nestedTacticBlock := parser! [appPrec] "begin " >> seq >> "end" +@[builtinTacticParser] def nestedTacticBlockCurly := parser! [appPrec] "{" >> seq >> "}" +@[builtinTacticParser] def orelse := tparser! [2] " <|> " >> tacticParser 1 end Tactic end Parser diff --git a/stage0/src/Lean/Parser/Term.lean b/stage0/src/Lean/Parser/Term.lean index 746358995e..adc19ce949 100644 --- a/stage0/src/Lean/Parser/Term.lean +++ b/stage0/src/Lean/Parser/Term.lean @@ -30,16 +30,16 @@ namespace Term /- Helper functions for defining simple parsers -/ def unicodeInfixR (sym : String) (asciiSym : String) (lbp : Nat) : TrailingParser := -unicodeSymbol sym asciiSym lbp >> termParser (lbp - 1) +checkRbpLt lbp >> unicodeSymbol sym asciiSym >> termParser (lbp - 1) def infixR (sym : String) (lbp : Nat) : TrailingParser := -symbol sym lbp >> termParser (lbp - 1) +checkRbpLt lbp >> symbol sym >> termParser (lbp - 1) def unicodeInfixL (sym : String) (asciiSym : String) (lbp : Nat) : TrailingParser := -unicodeSymbol sym asciiSym lbp >> termParser lbp +checkRbpLt lbp >> unicodeSymbol sym asciiSym >> termParser lbp def infixL (sym : String) (lbp : Nat) : TrailingParser := -symbol sym lbp >> termParser lbp +checkRbpLt lbp >> symbol sym >> termParser lbp def leadPrec := appPrec - 1 @@ -47,56 +47,56 @@ def leadPrec := appPrec - 1 -- NOTE: `checkNoWsBefore` should be used *before* `parser!` so that it is also applied to the generated -- antiquotation. def explicitUniv := checkNoWsBefore "no space before '.{'" >> parser! ".{" >> sepBy1 levelParser ", " >> "}" -def namedPattern := checkNoWsBefore "no space before '@'" >> parser! symbol "@" appPrec >> termParser appPrec -@[builtinTermParser] def id := parser! ident >> optional (explicitUniv <|> namedPattern) -@[builtinTermParser] def num : Parser := parser! numLit -@[builtinTermParser] def str : Parser := parser! strLit -@[builtinTermParser] def char : Parser := parser! charLit -@[builtinTermParser] def type := parser! symbol "Type" appPrec >> optional (checkRbpLt appPrec >> levelParser appPrec) -@[builtinTermParser] def sort := parser! symbol "Sort" appPrec >> optional (checkRbpLt appPrec >> levelParser appPrec) -@[builtinTermParser] def prop := parser! symbol "Prop" appPrec -@[builtinTermParser] def hole := parser! symbol "_" appPrec -@[builtinTermParser] def namedHole := parser! symbol "?" appPrec >> ident -@[builtinTermParser] def «sorry» := parser! symbol "sorry" appPrec -@[builtinTermParser] def cdot := parser! symbol "·" appPrec -@[builtinTermParser] def emptyC := parser! symbol "∅" appPrec +def namedPattern := checkNoWsBefore "no space before '@'" >> parser! "@" >> termParser appPrec +@[builtinTermParser] def id := parser! [appPrec] ident >> optional (explicitUniv <|> namedPattern) +@[builtinTermParser] def num : Parser := parser! [appPrec] numLit +@[builtinTermParser] def str : Parser := parser! [appPrec] strLit +@[builtinTermParser] def char : Parser := parser! [appPrec] charLit +@[builtinTermParser] def type := parser! [appPrec] "Type" >> optional (checkRbpLt appPrec >> levelParser appPrec) +@[builtinTermParser] def sort := parser! [appPrec] "Sort" >> optional (checkRbpLt appPrec >> levelParser appPrec) +@[builtinTermParser] def prop := parser! [appPrec] "Prop" +@[builtinTermParser] def hole := parser! [appPrec] "_" +@[builtinTermParser] def namedHole := parser! [appPrec] "?" >> ident +@[builtinTermParser] def «sorry» := parser! [appPrec] "sorry" +@[builtinTermParser] def cdot := parser! [appPrec] "·" +@[builtinTermParser] def emptyC := parser! [appPrec] "∅" def typeAscription := parser! " : " >> termParser def tupleTail := parser! ", " >> sepBy1 termParser ", " def parenSpecial : Parser := optional (tupleTail <|> typeAscription) -@[builtinTermParser] def paren := parser! symbol "(" appPrec >> optional (termParser >> parenSpecial) >> ")" -@[builtinTermParser] def anonymousCtor := parser! symbol "⟨" appPrec >> sepBy termParser ", " >> "⟩" +@[builtinTermParser] def paren := parser! [appPrec] "(" >> optional (termParser >> parenSpecial) >> ")" +@[builtinTermParser] def anonymousCtor := parser! [appPrec] "⟨" >> sepBy termParser ", " >> "⟩" def optIdent : Parser := optional (try (ident >> " : ")) -@[builtinTermParser] def «if» := parser! symbol "if " leadPrec >> optIdent >> termParser >> " then " >> termParser >> " else " >> termParser +@[builtinTermParser] def «if» := parser! [leadPrec] "if " >> optIdent >> termParser >> " then " >> termParser >> " else " >> termParser def fromTerm := parser! " from " >> termParser def haveAssign := parser! " := " >> termParser -@[builtinTermParser] def «have» := parser! symbol "have " leadPrec >> optIdent >> termParser >> (haveAssign <|> fromTerm) >> "; " >> termParser -@[builtinTermParser] def «suffices» := parser! symbol "suffices " leadPrec >> optIdent >> termParser >> fromTerm >> "; " >> termParser -@[builtinTermParser] def «show» := parser! symbol "show " leadPrec >> termParser >> fromTerm -def structInstArrayRef := parser! symbol "[" appPrec >> termParser >>"]" +@[builtinTermParser] def «have» := parser! [leadPrec] "have " >> optIdent >> termParser >> (haveAssign <|> fromTerm) >> "; " >> termParser +@[builtinTermParser] def «suffices» := parser! [leadPrec] "suffices " >> optIdent >> termParser >> fromTerm >> "; " >> termParser +@[builtinTermParser] def «show» := parser! [leadPrec] "show " >> termParser >> fromTerm +def structInstArrayRef := parser! "[" >> termParser >>"]" def structInstLVal := (ident <|> fieldIdx <|> structInstArrayRef) >> many (group ("." >> (ident <|> fieldIdx)) <|> structInstArrayRef) def structInstField := parser! structInstLVal >> " := " >> termParser -@[builtinTermParser] def structInst := parser! symbol "{" appPrec >> optional (try (termParser >> "with")) >> sepBy structInstField ", " true >> optional ".." >> optional (" : " >> termParser) >> "}" +@[builtinTermParser] def structInst := parser! [appPrec] "{" >> optional (try (termParser >> "with")) >> sepBy structInstField ", " true >> optional ".." >> optional (" : " >> termParser) >> "}" def typeSpec := parser! " : " >> termParser def optType : Parser := optional typeSpec -@[builtinTermParser] def subtype := parser! symbol "{" appPrec >> ident >> optType >> " // " >> termParser >> "}" -@[builtinTermParser] def listLit := parser! symbol "[" appPrec >> sepBy termParser "," true >> "]" -@[builtinTermParser] def arrayLit := parser! symbol "#[" appPrec >> sepBy termParser "," true >> "]" -@[builtinTermParser] def explicit := parser! symbol "@" appPrec >> termParser appPrec -@[builtinTermParser] def inaccessible := parser! symbol ".(" appPrec >> termParser >> ")" +@[builtinTermParser] def subtype := parser! [appPrec] "{" >> ident >> optType >> " // " >> termParser >> "}" +@[builtinTermParser] def listLit := parser! [appPrec] "[" >> sepBy termParser "," true >> "]" +@[builtinTermParser] def arrayLit := parser! [appPrec] "#[" >> sepBy termParser "," true >> "]" +@[builtinTermParser] def explicit := parser! [appPrec] "@" >> termParser appPrec +@[builtinTermParser] def inaccessible := parser! [appPrec] ".(" >> termParser >> ")" def binderIdent : Parser := ident <|> hole def binderType (requireType := false) : Parser := if requireType then group (" : " >> termParser) else optional (" : " >> termParser) -def binderTactic := parser! try (" := " >> symbol " by " leadPrec) >> Tactic.nonEmptySeq +def binderTactic := parser! try (" := " >> " by ") >> Tactic.nonEmptySeq def binderDefault := parser! " := " >> termParser -def explicitBinder (requireType := false) := parser! symbol "(" appPrec >> many1 binderIdent >> binderType requireType >> optional (binderTactic <|> binderDefault) >> ")" -def implicitBinder (requireType := false) := parser! symbol "{" appPrec >> many1 binderIdent >> binderType requireType >> "}" -def instBinder := parser! symbol "[" appPrec >> optIdent >> termParser >> "]" +def explicitBinder (requireType := false) := parser! "(" >> many1 binderIdent >> binderType requireType >> optional (binderTactic <|> binderDefault) >> ")" +def implicitBinder (requireType := false) := parser! "{" >> many1 binderIdent >> binderType requireType >> "}" +def instBinder := parser! "[" >> optIdent >> termParser >> "]" def bracketedBinder (requireType := false) := explicitBinder requireType <|> implicitBinder requireType <|> instBinder -@[builtinTermParser] def depArrow := parser! bracketedBinder true >> checkRbpLe 25 "expected parentheses around dependent arrow" >> unicodeSymbol " → " " -> " >> termParser +@[builtinTermParser] def depArrow := parser! [appPrec] bracketedBinder true >> checkRbpLe 25 "expected parentheses around dependent arrow" >> unicodeSymbol " → " " -> " >> termParser def simpleBinder := parser! many1 binderIdent -@[builtinTermParser] def «forall» := parser! unicodeSymbol "∀" "forall" leadPrec >> many1 (simpleBinder <|> bracketedBinder) >> ", " >> termParser +@[builtinTermParser] def «forall» := parser! [leadPrec] unicodeSymbol "∀" "forall" >> many1 (simpleBinder <|> bracketedBinder) >> ", " >> termParser def funBinder : Parser := implicitBinder <|> instBinder <|> termParser appPrec -@[builtinTermParser] def «fun» := parser! unicodeSymbol "λ" "fun" leadPrec >> many1 funBinder >> darrow >> termParser +@[builtinTermParser] def «fun» := parser! [leadPrec] unicodeSymbol "λ" "fun" >> many1 funBinder >> darrow >> termParser def matchAlt : Parser := nodeWithAntiquot "matchAlt" `Lean.Parser.Term.matchAlt $ @@ -107,14 +107,14 @@ withPosition $ fun pos => (if optionalFirstBar then optional "|" else "|") >> sepBy1 matchAlt (checkColGe pos.column "alternatives must be indented" >> "|") -@[builtinTermParser] def «match» := parser! symbol "match " leadPrec >> sepBy1 termParser ", " >> optType >> " with " >> matchAlts -@[builtinTermParser] def «nomatch» := parser! symbol "nomatch " leadPrec >> termParser -@[builtinTermParser] def «parser!» := parser! symbol "parser! " leadPrec >> termParser -@[builtinTermParser] def «tparser!» := parser! symbol "tparser! " leadPrec >> termParser -@[builtinTermParser] def borrowed := parser! symbol "@&" appPrec >> termParser (appPrec - 1) -@[builtinTermParser] def quotedName := parser! nameLit +@[builtinTermParser] def «match» := parser! [leadPrec] "match " >> sepBy1 termParser ", " >> optType >> " with " >> matchAlts +@[builtinTermParser] def «nomatch» := parser! [leadPrec] "nomatch " >> termParser +@[builtinTermParser] def «parser!» := parser! [leadPrec] "parser! " >> termParser -- TODO optional prec +@[builtinTermParser] def «tparser!» := parser! [leadPrec] "tparser! " >> termParser +@[builtinTermParser] def borrowed := parser! [appPrec] "@&" >> termParser (appPrec - 1) +@[builtinTermParser] def quotedName := parser! [appPrec] nameLit -- NOTE: syntax quotations are defined in Init.Lean.Parser.Command -@[builtinTermParser] def «match_syntax» := parser! symbol "match_syntax" leadPrec >> termParser >> " with " >> matchAlts +@[builtinTermParser] def «match_syntax» := parser! [leadPrec] "match_syntax" >> termParser >> " with " >> matchAlts /- Remark: we use `checkWsBefore` to ensure `let x[i] := e; b` is not parsed as `let x [i] := e; b` where `[i]` is an `instBinder`. -/ def letIdLhs : Parser := ident >> checkWsBefore "expected space before binders" >> many bracketedBinder >> optType @@ -122,41 +122,41 @@ def letIdDecl : Parser := nodeWithAntiquot "letDecl" `Lean.Parser.Term.letDecl def letPatDecl : Parser := node `Lean.Parser.Term.letDecl $ try (termParser >> pushNone >> optType >> " := ") >> termParser def letEqnsDecl : Parser := node `Lean.Parser.Term.letDecl $ letIdLhs >> matchAlts false def letDecl := letIdDecl <|> letPatDecl <|> letEqnsDecl -@[builtinTermParser] def «let» := parser! symbol "let " leadPrec >> letDecl >> "; " >> termParser -@[builtinTermParser] def «let!» := parser! symbol "let! " leadPrec >> letDecl >> "; " >> termParser +@[builtinTermParser] def «let» := parser! [leadPrec] "let " >> letDecl >> "; " >> termParser +@[builtinTermParser] def «let!» := parser! [leadPrec] "let! " >> letDecl >> "; " >> termParser def leftArrow : Parser := unicodeSymbol " ← " " <- " -def doLet := parser! symbol "let " leadPrec >> letDecl +def doLet := parser! "let ">> letDecl def doId := parser! try (ident >> optType >> leftArrow) >> termParser def doPat := parser! try (termParser >> leftArrow) >> termParser >> optional (" | " >> termParser) def doExpr := parser! termParser def doElem := doLet <|> doId <|> doPat <|> doExpr def doSeq := sepBy1 doElem "; " -def bracketedDoSeq := parser! symbol "{" appPrec >> doSeq >> "}" -@[builtinTermParser] def liftMethod := parser! leftArrow >> termParser -@[builtinTermParser] def «do» := parser! symbol "do " leadPrec >> (bracketedDoSeq <|> doSeq) +def bracketedDoSeq := parser! [appPrec] "{" >> doSeq >> "}" +@[builtinTermParser] def liftMethod := parser! [0] leftArrow >> termParser +@[builtinTermParser] def «do» := parser! [leadPrec] "do " >> (bracketedDoSeq <|> doSeq) @[builtinTermParser] def nativeRefl := parser! "nativeRefl! " >> termParser appPrec @[builtinTermParser] def nativeDecide := parser! "nativeDecide! " >> termParser appPrec @[builtinTermParser] def decide := parser! "decide! " >> termParser appPrec -@[builtinTermParser] def not := parser! symbol "¬" appPrec >> termParser 40 -@[builtinTermParser] def bnot := parser! symbol "!" appPrec >> termParser 40 +@[builtinTermParser] def not := parser! [appPrec] "¬" >> termParser 40 +@[builtinTermParser] def bnot := parser! [appPrec] "!" >> termParser 40 -- symbol precedence should be higher, but must match the one of `sub` below -@[builtinTermParser] def uminus := parser! symbol "-" 65 >> termParser 100 +@[builtinTermParser] def uminus := parser! [65] "-" >> termParser 100 -def namedArgument := parser! try (symbol "(" appPrec >> ident >> " := ") >> termParser >> ")" -@[builtinTermParser] def app := tparser! many1 (namedArgument <|> termParser appPrec) +def namedArgument := parser! try ("(" >> ident >> " := ") >> termParser >> ")" +@[builtinTermParser] def app := tparser! [appPrec] many1 (namedArgument <|> termParser appPrec) def checkIsSort := checkStackTop (fun stx => stx.isOfKind `Lean.Parser.Term.type || stx.isOfKind `Lean.Parser.Term.sort) -@[builtinTermParser] def proj := tparser! symbolNoWs "." (appPrec+1) >> (fieldIdx <|> ident) +@[builtinTermParser] def proj := tparser! [appPrec+1] symbolNoWs "." >> (fieldIdx <|> ident) @[builtinTermParser] def arrow := tparser! unicodeInfixR " → " " -> " 25 -@[builtinTermParser] def arrayRef := tparser! symbolNoWs "[" (appPrec+1) >> termParser >>"]" +@[builtinTermParser] def arrayRef := tparser! [appPrec+1] symbolNoWs "[" >> termParser >>"]" -@[builtinTermParser] def dollar := tparser! try (dollarSymbol >> checkWsBefore "space expected") >> termParser 0 -@[builtinTermParser] def dollarProj := tparser! symbol "$." 1 >> (fieldIdx <|> ident) +@[builtinTermParser] def dollar := tparser! [1] try (dollarSymbol >> checkWsBefore "space expected") >> termParser 0 +@[builtinTermParser] def dollarProj := tparser! [1] "$." >> (fieldIdx <|> ident) -@[builtinTermParser] def «where» := tparser! symbol " where " 1 >> sepBy1 letDecl (group ("; " >> symbol " where " 1)) +@[builtinTermParser] def «where» := tparser! [1] " where " >> sepBy1 letDecl (group ("; " >> symbol " where ")) @[builtinTermParser] def fcomp := tparser! infixR " ∘ " 90 @@ -181,7 +181,7 @@ def checkIsSort := checkStackTop (fun stx => stx.isOfKind `Lean.Parser.Term.type @[builtinTermParser] def heq := tparser! unicodeInfixL " ≅ " " ~= " 50 @[builtinTermParser] def equiv := tparser! infixL " ≈ " 50 -@[builtinTermParser] def subst := tparser! symbol " ▸ " 75 >> sepBy1 (termParser 75) (symbol " ▸ " 75) +@[builtinTermParser] def subst := tparser! [75] " ▸ " >> sepBy1 (termParser 75) " ▸ " @[builtinTermParser] def and := tparser! unicodeInfixR " ∧ " " /\\ " 35 @[builtinTermParser] def or := tparser! unicodeInfixR " ∨ " " \\/ " 30 @@ -206,12 +206,15 @@ def checkIsSort := checkStackTop (fun stx => stx.isOfKind `Lean.Parser.Term.type @[builtinTermParser] def mapConst := tparser! infixR " <$ " 100 @[builtinTermParser] def mapConstRev := tparser! infixR " $> " 100 -@[builtinTermParser] def tacticBlock := parser! symbol "begin " appPrec >> Tactic.seq >> "end" -@[builtinTermParser] def byTactic := parser! symbol "by " leadPrec >> Tactic.nonEmptySeq +@[builtinTermParser] def tacticBlock := parser! [appPrec] "begin " >> Tactic.seq >> "end" +@[builtinTermParser] def byTactic := parser! [leadPrec] "by " >> Tactic.nonEmptySeq -- Use `unboxSingleton` trick similar to the one used at Command.lean for `Term.stxQuot` -@[builtinTermParser] def tacticStxQuot : Parser := node `Lean.Parser.Term.stxQuot $ symbol "`(tactic|" appPrec >> sepBy1 tacticParser "; " true true >> ")" -@[builtinTermParser] def levelStxQuot : Parser := node `Lean.Parser.Term.stxQuot $ symbol "`(level|" appPrec >> levelParser >> ")" -@[builtinTermParser] def funBinderStxQuot : Parser := node `Lean.Parser.Term.stxQuot $ symbol "`(funBinder|" appPrec >> funBinder >> ")" +@[builtinTermParser] def tacticStxQuot : Parser := +checkRbpLe appPrec >> (node `Lean.Parser.Term.stxQuot $ "`(tactic|" >> sepBy1 tacticParser "; " true true >> ")") +@[builtinTermParser] def levelStxQuot : Parser := +checkRbpLe appPrec >> (node `Lean.Parser.Term.stxQuot $ "`(level|" >> levelParser >> ")") +@[builtinTermParser] def funBinderStxQuot : Parser := +checkRbpLe appPrec >> (node `Lean.Parser.Term.stxQuot $ "`(funBinder|" >> funBinder >> ")") end Term end Parser diff --git a/stage0/stdlib/Init/LeanInit.c b/stage0/stdlib/Init/LeanInit.c index 88dbb472c9..77684bc93e 100644 --- a/stage0/stdlib/Init/LeanInit.c +++ b/stage0/stdlib/Init/LeanInit.c @@ -1483,13 +1483,11 @@ return x_17; lean_object* _init_l_Lean_ParserDescr_inhabited___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; +lean_object* x_1; lean_object* x_2; x_1 = l_String_splitAux___main___closed__1; -x_2 = lean_unsigned_to_nat(0u); -x_3 = lean_alloc_ctor(11, 2, 0); -lean_ctor_set(x_3, 0, x_1); -lean_ctor_set(x_3, 1, x_2); -return x_3; +x_2 = lean_alloc_ctor(11, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; } } lean_object* _init_l_Lean_ParserDescr_inhabited() { diff --git a/stage0/stdlib/Lean/Elab/Syntax.c b/stage0/stdlib/Lean/Elab/Syntax.c index 2f3804dd03..4ebeeb0e2b 100644 --- a/stage0/stdlib/Lean/Elab/Syntax.c +++ b/stage0/stdlib/Lean/Elab/Syntax.c @@ -36,7 +36,6 @@ 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*); lean_object* l_Lean_Elab_Command_getOptions(lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabSyntax___closed__19; -lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__128; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__58; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__22; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__18; @@ -131,7 +130,6 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__81; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__6; lean_object* l_Lean_Elab_Command_expandMacro___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__27; -lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__124; extern lean_object* l_Lean_Parser_Syntax_ident___elambda__1___closed__1; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__73; lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__4; @@ -164,7 +162,6 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__103; lean_object* l_Array_filterSepElemsM___at_Lean_Elab_Command_elabNoKindMacroRulesAux___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__28; lean_object* l___private_Init_LeanInit_13__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_Lean_Elab_Term_toParserDescrAux___main___closed__123; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__30; lean_object* l_Lean_Elab_Term_checkLeftRec___closed__1; lean_object* l_Lean_Elab_Term_checkLeftRec___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -192,7 +189,6 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__42; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__112; lean_object* lean_array_fget(lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabMixfix___rarg(lean_object*); -lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__127; lean_object* l_Lean_Elab_Command_getCurrNamespace(lean_object*, lean_object*); uint8_t lean_nat_dec_eq(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__5; @@ -206,9 +202,9 @@ extern lean_object* l_Lean_numLitKind; extern lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1___closed__2; extern lean_object* l_Lean_Parser_Syntax_num___elambda__1___closed__1; lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_toParserDescrAux___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_dollarSymbol___elambda__1___closed__1; lean_object* l___private_Lean_Elab_Syntax_8__regTraceClasses___closed__1; lean_object* l_Lean_Elab_Term_throwUnsupportedSyntax___rarg(lean_object*); -extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__1; extern lean_object* l_Lean_Expr_isSyntheticSorry___closed__1; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__87; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__68; @@ -292,7 +288,6 @@ lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux___boxed(lean_object*, l lean_object* l___private_Lean_Elab_Syntax_1__expandOptPrecedence(lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__93; lean_object* l___private_Lean_Elab_Syntax_7__antiquote___boxed(lean_object*, lean_object*); -extern lean_object* l_Lean_numLitKind___closed__2; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__121; extern lean_object* l_Lean_Parser_Command_docComment___elambda__1___closed__2; lean_object* l_Lean_Elab_Command_elabSyntax___closed__28; @@ -361,7 +356,7 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__7; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__71; extern lean_object* l_Lean_mkAppStx___closed__3; lean_object* l_Lean_Elab_Command_inferMacroRulesAltKind(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__126; +extern lean_object* l_Lean_Parser_appPrec; uint8_t l_Lean_Name_hasMacroScopes___main(lean_object*); lean_object* l_Lean_Parser_registerParserCategory(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__63; @@ -374,7 +369,6 @@ extern lean_object* l___private_Lean_Elab_Quotation_8__letBindRhss___main___clos extern lean_object* l___private_Lean_Elab_Quotation_8__letBindRhss___main___closed__11; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__102; lean_object* l_Lean_Elab_Command_elabSyntax___closed__4; -lean_object* l_Lean_Parser_getTokenLbp_x3f(lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabReserve(lean_object*, lean_object*); lean_object* l_Lean_Name_appendAfter(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__15; @@ -391,7 +385,6 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__3; extern lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__1; lean_object* l___private_Lean_Elab_Command_7__mkTermState(lean_object*); uint8_t l_Lean_Parser_isParserCategory(lean_object*, lean_object*); -lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__125; lean_object* l_Lean_Elab_Command_getCurrMacroScope(lean_object*, lean_object*); extern lean_object* l_Lean_SourceInfo_inhabited___closed__1; lean_object* l_Lean_Elab_Command_getMainModule(lean_object*, lean_object*); @@ -462,6 +455,7 @@ extern lean_object* l_Lean_Parser_Term_matchAlt___closed__2; lean_object* l_Lean_Elab_Command_elabSyntax___closed__13; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__57; +lean_object* l___private_Lean_Elab_Syntax_1__expandOptPrecedence___closed__1; lean_object* l___private_Lean_Elab_Syntax_1__expandOptPrecedence___boxed(lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__122; lean_object* l___private_Lean_Elab_Syntax_4__withNotFirst___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -521,7 +515,6 @@ extern lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__2; lean_object* l_Lean_Elab_Command_elabSyntax___closed__12; lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_Syntax_7__antiquote___main___spec__3(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Elab_Term_elabArrow___lambda__1___closed__3; -extern lean_object* l_Lean_Parser_currLbp___closed__1; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__88; extern lean_object* l_Lean_Parser_Syntax_sepBy___elambda__1___closed__2; lean_object* l_Lean_Elab_Command_elabSyntax___closed__26; @@ -568,6 +561,16 @@ 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; lean_object* l_Lean_Elab_Command_logTrace(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* _init_l___private_Lean_Elab_Syntax_1__expandOptPrecedence___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Parser_appPrec; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} lean_object* l___private_Lean_Elab_Syntax_1__expandOptPrecedence(lean_object* x_1) { _start: { @@ -587,7 +590,7 @@ lean_dec(x_6); if (lean_obj_tag(x_8) == 0) { lean_object* x_9; -x_9 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_9 = l___private_Lean_Elab_Syntax_1__expandOptPrecedence___closed__1; return x_9; } else @@ -2476,90 +2479,26 @@ lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__95() { _start: { lean_object* x_1; -x_1 = lean_mk_string("0"); +x_1 = lean_mk_string("ParserDescr.nonReservedSymbol"); return x_1; } } lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__96() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_SourceInfo_inhabited___closed__1; -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__95; -x_3 = lean_alloc_ctor(2, 2, 0); -lean_ctor_set(x_3, 0, x_1); -lean_ctor_set(x_3, 1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__95; +x_2 = lean_string_utf8_byte_size(x_1); +return x_2; } } lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__97() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Array_empty___closed__1; -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__96; -x_3 = lean_array_push(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__98() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_numLitKind___closed__2; -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__97; -x_3 = lean_alloc_ctor(1, 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_Elab_Term_toParserDescrAux___main___closed__99() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Array_empty___closed__1; -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__98; -x_3 = lean_array_push(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__100() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Nat_HasQuote___closed__2; -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__99; -x_3 = lean_alloc_ctor(1, 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_Elab_Term_toParserDescrAux___main___closed__101() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("ParserDescr.nonReservedSymbol"); -return x_1; -} -} -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__102() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__101; -x_2 = lean_string_utf8_byte_size(x_1); -return x_2; -} -} -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__103() { -_start: -{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__101; +x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__95; x_2 = lean_unsigned_to_nat(0u); -x_3 = l_Lean_Elab_Term_toParserDescrAux___main___closed__102; +x_3 = l_Lean_Elab_Term_toParserDescrAux___main___closed__96; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2567,7 +2506,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__104() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__98() { _start: { lean_object* x_1; @@ -2575,51 +2514,51 @@ x_1 = lean_mk_string("nonReservedSymbol"); return x_1; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__105() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__99() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_iterateMAux___main___at___private_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__4; -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__104; +x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__98; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__106() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__100() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_iterateMAux___main___at___private_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__6; -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__104; +x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__98; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__107() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__101() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__106; +x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__100; x_3 = lean_alloc_ctor(0, 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_Elab_Term_toParserDescrAux___main___closed__108() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__102() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__107; +x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__101; 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_Elab_Term_toParserDescrAux___main___closed__109() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__103() { _start: { lean_object* x_1; lean_object* x_2; @@ -2628,13 +2567,13 @@ x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__110() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__104() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Bool_HasRepr___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l_Lean_Elab_Term_toParserDescrAux___main___closed__109; +x_3 = l_Lean_Elab_Term_toParserDescrAux___main___closed__103; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2642,7 +2581,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__111() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__105() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2652,7 +2591,7 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__112() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__106() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2662,41 +2601,41 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__113() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__107() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__112; +x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__106; x_2 = l_Bool_HasRepr___closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__114() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__108() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__113; +x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__107; x_3 = lean_alloc_ctor(0, 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_Elab_Term_toParserDescrAux___main___closed__115() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__109() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__114; +x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__108; 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_Elab_Term_toParserDescrAux___main___closed__116() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__110() { _start: { lean_object* x_1; @@ -2704,22 +2643,22 @@ x_1 = lean_mk_string("ParserDescr.parser"); return x_1; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__117() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__111() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__116; +x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__110; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__118() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__112() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__116; +x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__110; x_2 = lean_unsigned_to_nat(0u); -x_3 = l_Lean_Elab_Term_toParserDescrAux___main___closed__117; +x_3 = l_Lean_Elab_Term_toParserDescrAux___main___closed__111; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2727,7 +2666,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__119() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__113() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2737,7 +2676,7 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__120() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__114() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2747,31 +2686,31 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__121() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__115() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__120; +x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__114; x_3 = lean_alloc_ctor(0, 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_Elab_Term_toParserDescrAux___main___closed__122() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__116() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__121; +x_2 = l_Lean_Elab_Term_toParserDescrAux___main___closed__115; 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_Elab_Term_toParserDescrAux___main___closed__123() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__117() { _start: { lean_object* x_1; @@ -2779,27 +2718,27 @@ x_1 = lean_mk_string("unknown category '"); return x_1; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__124() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__118() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__123; +x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__117; x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__125() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__119() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__124; +x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__118; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__126() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__120() { _start: { lean_object* x_1; @@ -2807,21 +2746,21 @@ x_1 = lean_mk_string("invalid atomic left recursive syntax"); return x_1; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__127() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__121() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__126; +x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__120; x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__128() { +lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__122() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__127; +x_1 = l_Lean_Elab_Term_toParserDescrAux___main___closed__121; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; @@ -6337,7 +6276,7 @@ return x_1352; } else { -lean_object* x_1353; lean_object* x_1354; lean_object* x_1355; lean_object* x_1356; lean_object* x_1357; uint8_t x_1580; +lean_object* x_1353; lean_object* x_1354; lean_object* x_1355; lean_object* x_1356; lean_object* x_1357; lean_object* x_1358; uint8_t x_1448; x_1353 = lean_ctor_get(x_1347, 0); lean_inc(x_1353); lean_dec(x_1347); @@ -6346,40 +6285,611 @@ x_1355 = l_Lean_Syntax_getArg(x_1, x_1354); lean_dec(x_1); x_1356 = l___private_Lean_Elab_Syntax_1__expandOptPrecedence(x_1355); lean_dec(x_1355); -x_1580 = lean_ctor_get_uint8(x_2, sizeof(void*)*1 + 2); +x_1448 = lean_ctor_get_uint8(x_2, sizeof(void*)*1 + 2); lean_dec(x_2); -if (x_1580 == 0) +if (x_1448 == 0) { -lean_object* x_1581; -x_1581 = lean_box(0); -x_1357 = x_1581; -goto block_1579; +lean_object* x_1449; lean_object* x_1450; lean_object* x_1451; lean_object* x_1452; lean_object* x_1453; +lean_dec(x_1356); +x_1449 = l_Lean_Elab_Term_getCurrMacroScope(x_4, x_5); +lean_dec(x_4); +x_1450 = lean_ctor_get(x_1449, 0); +lean_inc(x_1450); +x_1451 = lean_ctor_get(x_1449, 1); +lean_inc(x_1451); +lean_dec(x_1449); +x_1452 = lean_box(x_3); +x_1453 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1453, 0, x_1450); +lean_ctor_set(x_1453, 1, x_1452); +x_1357 = x_1453; +x_1358 = x_1451; +goto block_1447; } else { if (lean_obj_tag(x_1356) == 0) { -lean_object* x_1582; lean_object* x_1583; lean_object* x_1584; lean_object* x_1585; uint8_t x_1586; -x_1582 = l_Lean_Elab_Term_getCurrMacroScope(x_4, x_5); +lean_object* x_1454; lean_object* x_1455; lean_object* x_1456; lean_object* x_1457; uint8_t x_1458; +x_1454 = l_Lean_Elab_Term_getCurrMacroScope(x_4, x_5); lean_dec(x_4); -x_1583 = lean_ctor_get(x_1582, 0); -lean_inc(x_1583); -x_1584 = lean_ctor_get(x_1582, 1); -lean_inc(x_1584); -lean_dec(x_1582); -x_1585 = l_Lean_Elab_Term_getMainModule___rarg(x_1584); -x_1586 = !lean_is_exclusive(x_1585); -if (x_1586 == 0) +x_1455 = lean_ctor_get(x_1454, 0); +lean_inc(x_1455); +x_1456 = lean_ctor_get(x_1454, 1); +lean_inc(x_1456); +lean_dec(x_1454); +x_1457 = l_Lean_Elab_Term_getMainModule___rarg(x_1456); +x_1458 = !lean_is_exclusive(x_1457); +if (x_1458 == 0) { -lean_object* x_1587; lean_object* x_1588; lean_object* x_1589; lean_object* x_1590; lean_object* x_1591; lean_object* x_1592; lean_object* x_1593; lean_object* x_1594; lean_object* x_1595; lean_object* x_1596; lean_object* x_1597; lean_object* x_1598; lean_object* x_1599; lean_object* x_1600; lean_object* x_1601; lean_object* x_1602; lean_object* x_1603; lean_object* x_1604; lean_object* x_1605; lean_object* x_1606; lean_object* x_1607; lean_object* x_1608; lean_object* x_1609; lean_object* x_1610; lean_object* x_1611; lean_object* x_1612; lean_object* x_1613; lean_object* x_1614; lean_object* x_1615; lean_object* x_1616; lean_object* x_1617; lean_object* x_1618; lean_object* x_1619; lean_object* x_1620; lean_object* x_1621; lean_object* x_1622; -x_1587 = lean_ctor_get(x_1585, 0); -x_1588 = l_Lean_Elab_Term_toParserDescrAux___main___closed__105; -lean_inc(x_1583); +lean_object* x_1459; lean_object* x_1460; lean_object* x_1461; lean_object* x_1462; lean_object* x_1463; lean_object* x_1464; lean_object* x_1465; lean_object* x_1466; lean_object* x_1467; lean_object* x_1468; lean_object* x_1469; lean_object* x_1470; lean_object* x_1471; lean_object* x_1472; lean_object* x_1473; lean_object* x_1474; lean_object* x_1475; lean_object* x_1476; lean_object* x_1477; lean_object* x_1478; lean_object* x_1479; lean_object* x_1480; lean_object* x_1481; lean_object* x_1482; lean_object* x_1483; lean_object* x_1484; lean_object* x_1485; lean_object* x_1486; lean_object* x_1487; lean_object* x_1488; lean_object* x_1489; lean_object* x_1490; lean_object* x_1491; lean_object* x_1492; lean_object* x_1493; lean_object* x_1494; +x_1459 = lean_ctor_get(x_1457, 0); +x_1460 = l_Lean_Elab_Term_toParserDescrAux___main___closed__99; +lean_inc(x_1455); +lean_inc(x_1459); +x_1461 = l_Lean_addMacroScope(x_1459, x_1460, x_1455); +x_1462 = l_Lean_SourceInfo_inhabited___closed__1; +x_1463 = l_Lean_Elab_Term_toParserDescrAux___main___closed__97; +x_1464 = l_Lean_Elab_Term_toParserDescrAux___main___closed__102; +x_1465 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_1465, 0, x_1462); +lean_ctor_set(x_1465, 1, x_1463); +lean_ctor_set(x_1465, 2, x_1461); +lean_ctor_set(x_1465, 3, x_1464); +x_1466 = l_Array_empty___closed__1; +x_1467 = lean_array_push(x_1466, x_1465); +x_1468 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_1469 = lean_array_push(x_1467, x_1468); +x_1470 = l_Lean_mkTermIdFromIdent___closed__2; +x_1471 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1471, 0, x_1470); +lean_ctor_set(x_1471, 1, x_1469); +x_1472 = lean_array_push(x_1466, x_1471); +x_1473 = l_Lean_mkStxStrLit(x_1353, x_1462); +x_1474 = l_Lean_mkOptionalNode___closed__2; +x_1475 = lean_array_push(x_1474, x_1473); +x_1476 = l_Lean_String_HasQuote___closed__2; +x_1477 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1477, 0, x_1476); +lean_ctor_set(x_1477, 1, x_1475); +x_1478 = lean_array_push(x_1466, x_1477); +x_1479 = l_Lean_Elab_Term_toParserDescrAux___main___closed__105; +x_1480 = l_Lean_addMacroScope(x_1459, x_1479, x_1455); +x_1481 = l_Lean_Elab_Term_toParserDescrAux___main___closed__104; +x_1482 = l_Lean_Elab_Term_toParserDescrAux___main___closed__109; +x_1483 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_1483, 0, x_1462); +lean_ctor_set(x_1483, 1, x_1481); +lean_ctor_set(x_1483, 2, x_1480); +lean_ctor_set(x_1483, 3, x_1482); +x_1484 = lean_array_push(x_1466, x_1483); +x_1485 = lean_array_push(x_1484, x_1468); +x_1486 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1486, 0, x_1470); +lean_ctor_set(x_1486, 1, x_1485); +x_1487 = lean_array_push(x_1478, x_1486); +x_1488 = l_Lean_nullKind___closed__2; +x_1489 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1489, 0, x_1488); +lean_ctor_set(x_1489, 1, x_1487); +x_1490 = lean_array_push(x_1472, x_1489); +x_1491 = l_Lean_mkAppStx___closed__8; +x_1492 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1492, 0, x_1491); +lean_ctor_set(x_1492, 1, x_1490); +x_1493 = lean_box(x_3); +x_1494 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1494, 0, x_1492); +lean_ctor_set(x_1494, 1, x_1493); +lean_ctor_set(x_1457, 0, x_1494); +return x_1457; +} +else +{ +lean_object* x_1495; lean_object* x_1496; lean_object* x_1497; lean_object* x_1498; lean_object* x_1499; lean_object* x_1500; lean_object* x_1501; lean_object* x_1502; lean_object* x_1503; lean_object* x_1504; lean_object* x_1505; lean_object* x_1506; lean_object* x_1507; lean_object* x_1508; lean_object* x_1509; lean_object* x_1510; lean_object* x_1511; lean_object* x_1512; lean_object* x_1513; lean_object* x_1514; lean_object* x_1515; lean_object* x_1516; lean_object* x_1517; lean_object* x_1518; lean_object* x_1519; lean_object* x_1520; lean_object* x_1521; lean_object* x_1522; lean_object* x_1523; lean_object* x_1524; lean_object* x_1525; lean_object* x_1526; lean_object* x_1527; lean_object* x_1528; lean_object* x_1529; lean_object* x_1530; lean_object* x_1531; lean_object* x_1532; +x_1495 = lean_ctor_get(x_1457, 0); +x_1496 = lean_ctor_get(x_1457, 1); +lean_inc(x_1496); +lean_inc(x_1495); +lean_dec(x_1457); +x_1497 = l_Lean_Elab_Term_toParserDescrAux___main___closed__99; +lean_inc(x_1455); +lean_inc(x_1495); +x_1498 = l_Lean_addMacroScope(x_1495, x_1497, x_1455); +x_1499 = l_Lean_SourceInfo_inhabited___closed__1; +x_1500 = l_Lean_Elab_Term_toParserDescrAux___main___closed__97; +x_1501 = l_Lean_Elab_Term_toParserDescrAux___main___closed__102; +x_1502 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_1502, 0, x_1499); +lean_ctor_set(x_1502, 1, x_1500); +lean_ctor_set(x_1502, 2, x_1498); +lean_ctor_set(x_1502, 3, x_1501); +x_1503 = l_Array_empty___closed__1; +x_1504 = lean_array_push(x_1503, x_1502); +x_1505 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_1506 = lean_array_push(x_1504, x_1505); +x_1507 = l_Lean_mkTermIdFromIdent___closed__2; +x_1508 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1508, 0, x_1507); +lean_ctor_set(x_1508, 1, x_1506); +x_1509 = lean_array_push(x_1503, x_1508); +x_1510 = l_Lean_mkStxStrLit(x_1353, x_1499); +x_1511 = l_Lean_mkOptionalNode___closed__2; +x_1512 = lean_array_push(x_1511, x_1510); +x_1513 = l_Lean_String_HasQuote___closed__2; +x_1514 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1514, 0, x_1513); +lean_ctor_set(x_1514, 1, x_1512); +x_1515 = lean_array_push(x_1503, x_1514); +x_1516 = l_Lean_Elab_Term_toParserDescrAux___main___closed__105; +x_1517 = l_Lean_addMacroScope(x_1495, x_1516, x_1455); +x_1518 = l_Lean_Elab_Term_toParserDescrAux___main___closed__104; +x_1519 = l_Lean_Elab_Term_toParserDescrAux___main___closed__109; +x_1520 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_1520, 0, x_1499); +lean_ctor_set(x_1520, 1, x_1518); +lean_ctor_set(x_1520, 2, x_1517); +lean_ctor_set(x_1520, 3, x_1519); +x_1521 = lean_array_push(x_1503, x_1520); +x_1522 = lean_array_push(x_1521, x_1505); +x_1523 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1523, 0, x_1507); +lean_ctor_set(x_1523, 1, x_1522); +x_1524 = lean_array_push(x_1515, x_1523); +x_1525 = l_Lean_nullKind___closed__2; +x_1526 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1526, 0, x_1525); +lean_ctor_set(x_1526, 1, x_1524); +x_1527 = lean_array_push(x_1509, x_1526); +x_1528 = l_Lean_mkAppStx___closed__8; +x_1529 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1529, 0, x_1528); +lean_ctor_set(x_1529, 1, x_1527); +x_1530 = lean_box(x_3); +x_1531 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1531, 0, x_1529); +lean_ctor_set(x_1531, 1, x_1530); +x_1532 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1532, 0, x_1531); +lean_ctor_set(x_1532, 1, x_1496); +return x_1532; +} +} +else +{ +lean_object* x_1533; lean_object* x_1534; lean_object* x_1535; lean_object* x_1536; lean_object* x_1537; +lean_dec(x_1356); +x_1533 = l_Lean_Elab_Term_getCurrMacroScope(x_4, x_5); +lean_dec(x_4); +x_1534 = lean_ctor_get(x_1533, 0); +lean_inc(x_1534); +x_1535 = lean_ctor_get(x_1533, 1); +lean_inc(x_1535); +lean_dec(x_1533); +x_1536 = lean_box(x_3); +x_1537 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1537, 0, x_1534); +lean_ctor_set(x_1537, 1, x_1536); +x_1357 = x_1537; +x_1358 = x_1535; +goto block_1447; +} +} +block_1447: +{ +uint8_t x_1359; +x_1359 = !lean_is_exclusive(x_1357); +if (x_1359 == 0) +{ +lean_object* x_1360; lean_object* x_1361; uint8_t x_1362; +x_1360 = lean_ctor_get(x_1357, 0); +x_1361 = l_Lean_Elab_Term_getMainModule___rarg(x_1358); +x_1362 = !lean_is_exclusive(x_1361); +if (x_1362 == 0) +{ +lean_object* x_1363; lean_object* x_1364; lean_object* x_1365; lean_object* x_1366; lean_object* x_1367; lean_object* x_1368; lean_object* x_1369; lean_object* x_1370; lean_object* x_1371; lean_object* x_1372; lean_object* x_1373; lean_object* x_1374; lean_object* x_1375; lean_object* x_1376; lean_object* x_1377; lean_object* x_1378; lean_object* x_1379; lean_object* x_1380; lean_object* x_1381; lean_object* x_1382; lean_object* x_1383; lean_object* x_1384; lean_object* x_1385; lean_object* x_1386; lean_object* x_1387; +x_1363 = lean_ctor_get(x_1361, 0); +x_1364 = l_Lean_Elab_Term_toParserDescrAux___main___closed__91; +x_1365 = l_Lean_addMacroScope(x_1363, x_1364, x_1360); +x_1366 = l_Lean_SourceInfo_inhabited___closed__1; +x_1367 = l_Lean_Elab_Term_toParserDescrAux___main___closed__90; +x_1368 = l_Lean_Elab_Term_toParserDescrAux___main___closed__94; +x_1369 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_1369, 0, x_1366); +lean_ctor_set(x_1369, 1, x_1367); +lean_ctor_set(x_1369, 2, x_1365); +lean_ctor_set(x_1369, 3, x_1368); +x_1370 = l_Array_empty___closed__1; +x_1371 = lean_array_push(x_1370, x_1369); +x_1372 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_1373 = lean_array_push(x_1371, x_1372); +x_1374 = l_Lean_mkTermIdFromIdent___closed__2; +x_1375 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1375, 0, x_1374); +lean_ctor_set(x_1375, 1, x_1373); +x_1376 = lean_array_push(x_1370, x_1375); +x_1377 = l_Lean_mkStxStrLit(x_1353, x_1366); +x_1378 = l_Lean_mkOptionalNode___closed__2; +x_1379 = lean_array_push(x_1378, x_1377); +x_1380 = l_Lean_String_HasQuote___closed__2; +x_1381 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1381, 0, x_1380); +lean_ctor_set(x_1381, 1, x_1379); +x_1382 = lean_array_push(x_1370, x_1381); +x_1383 = l_Lean_nullKind___closed__2; +x_1384 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1384, 0, x_1383); +lean_ctor_set(x_1384, 1, x_1382); +x_1385 = lean_array_push(x_1376, x_1384); +x_1386 = l_Lean_mkAppStx___closed__8; +x_1387 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1387, 0, x_1386); +lean_ctor_set(x_1387, 1, x_1385); +lean_ctor_set(x_1357, 0, x_1387); +lean_ctor_set(x_1361, 0, x_1357); +return x_1361; +} +else +{ +lean_object* x_1388; lean_object* x_1389; lean_object* x_1390; lean_object* x_1391; lean_object* x_1392; lean_object* x_1393; lean_object* x_1394; lean_object* x_1395; lean_object* x_1396; lean_object* x_1397; lean_object* x_1398; lean_object* x_1399; lean_object* x_1400; lean_object* x_1401; lean_object* x_1402; lean_object* x_1403; lean_object* x_1404; lean_object* x_1405; lean_object* x_1406; lean_object* x_1407; lean_object* x_1408; lean_object* x_1409; lean_object* x_1410; lean_object* x_1411; lean_object* x_1412; lean_object* x_1413; lean_object* x_1414; +x_1388 = lean_ctor_get(x_1361, 0); +x_1389 = lean_ctor_get(x_1361, 1); +lean_inc(x_1389); +lean_inc(x_1388); +lean_dec(x_1361); +x_1390 = l_Lean_Elab_Term_toParserDescrAux___main___closed__91; +x_1391 = l_Lean_addMacroScope(x_1388, x_1390, x_1360); +x_1392 = l_Lean_SourceInfo_inhabited___closed__1; +x_1393 = l_Lean_Elab_Term_toParserDescrAux___main___closed__90; +x_1394 = l_Lean_Elab_Term_toParserDescrAux___main___closed__94; +x_1395 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_1395, 0, x_1392); +lean_ctor_set(x_1395, 1, x_1393); +lean_ctor_set(x_1395, 2, x_1391); +lean_ctor_set(x_1395, 3, x_1394); +x_1396 = l_Array_empty___closed__1; +x_1397 = lean_array_push(x_1396, x_1395); +x_1398 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_1399 = lean_array_push(x_1397, x_1398); +x_1400 = l_Lean_mkTermIdFromIdent___closed__2; +x_1401 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1401, 0, x_1400); +lean_ctor_set(x_1401, 1, x_1399); +x_1402 = lean_array_push(x_1396, x_1401); +x_1403 = l_Lean_mkStxStrLit(x_1353, x_1392); +x_1404 = l_Lean_mkOptionalNode___closed__2; +x_1405 = lean_array_push(x_1404, x_1403); +x_1406 = l_Lean_String_HasQuote___closed__2; +x_1407 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1407, 0, x_1406); +lean_ctor_set(x_1407, 1, x_1405); +x_1408 = lean_array_push(x_1396, x_1407); +x_1409 = l_Lean_nullKind___closed__2; +x_1410 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1410, 0, x_1409); +lean_ctor_set(x_1410, 1, x_1408); +x_1411 = lean_array_push(x_1402, x_1410); +x_1412 = l_Lean_mkAppStx___closed__8; +x_1413 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1413, 0, x_1412); +lean_ctor_set(x_1413, 1, x_1411); +lean_ctor_set(x_1357, 0, x_1413); +x_1414 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1414, 0, x_1357); +lean_ctor_set(x_1414, 1, x_1389); +return x_1414; +} +} +else +{ +lean_object* x_1415; lean_object* x_1416; lean_object* x_1417; lean_object* x_1418; lean_object* x_1419; lean_object* x_1420; lean_object* x_1421; lean_object* x_1422; lean_object* x_1423; lean_object* x_1424; lean_object* x_1425; lean_object* x_1426; lean_object* x_1427; lean_object* x_1428; lean_object* x_1429; lean_object* x_1430; lean_object* x_1431; lean_object* x_1432; lean_object* x_1433; lean_object* x_1434; lean_object* x_1435; lean_object* x_1436; lean_object* x_1437; lean_object* x_1438; lean_object* x_1439; lean_object* x_1440; lean_object* x_1441; lean_object* x_1442; lean_object* x_1443; lean_object* x_1444; lean_object* x_1445; lean_object* x_1446; +x_1415 = lean_ctor_get(x_1357, 0); +x_1416 = lean_ctor_get(x_1357, 1); +lean_inc(x_1416); +lean_inc(x_1415); +lean_dec(x_1357); +x_1417 = l_Lean_Elab_Term_getMainModule___rarg(x_1358); +x_1418 = lean_ctor_get(x_1417, 0); +lean_inc(x_1418); +x_1419 = lean_ctor_get(x_1417, 1); +lean_inc(x_1419); +if (lean_is_exclusive(x_1417)) { + lean_ctor_release(x_1417, 0); + lean_ctor_release(x_1417, 1); + x_1420 = x_1417; +} else { + lean_dec_ref(x_1417); + x_1420 = lean_box(0); +} +x_1421 = l_Lean_Elab_Term_toParserDescrAux___main___closed__91; +x_1422 = l_Lean_addMacroScope(x_1418, x_1421, x_1415); +x_1423 = l_Lean_SourceInfo_inhabited___closed__1; +x_1424 = l_Lean_Elab_Term_toParserDescrAux___main___closed__90; +x_1425 = l_Lean_Elab_Term_toParserDescrAux___main___closed__94; +x_1426 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_1426, 0, x_1423); +lean_ctor_set(x_1426, 1, x_1424); +lean_ctor_set(x_1426, 2, x_1422); +lean_ctor_set(x_1426, 3, x_1425); +x_1427 = l_Array_empty___closed__1; +x_1428 = lean_array_push(x_1427, x_1426); +x_1429 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_1430 = lean_array_push(x_1428, x_1429); +x_1431 = l_Lean_mkTermIdFromIdent___closed__2; +x_1432 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1432, 0, x_1431); +lean_ctor_set(x_1432, 1, x_1430); +x_1433 = lean_array_push(x_1427, x_1432); +x_1434 = l_Lean_mkStxStrLit(x_1353, x_1423); +x_1435 = l_Lean_mkOptionalNode___closed__2; +x_1436 = lean_array_push(x_1435, x_1434); +x_1437 = l_Lean_String_HasQuote___closed__2; +x_1438 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1438, 0, x_1437); +lean_ctor_set(x_1438, 1, x_1436); +x_1439 = lean_array_push(x_1427, x_1438); +x_1440 = l_Lean_nullKind___closed__2; +x_1441 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1441, 0, x_1440); +lean_ctor_set(x_1441, 1, x_1439); +x_1442 = lean_array_push(x_1433, x_1441); +x_1443 = l_Lean_mkAppStx___closed__8; +x_1444 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1444, 0, x_1443); +lean_ctor_set(x_1444, 1, x_1442); +x_1445 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1445, 0, x_1444); +lean_ctor_set(x_1445, 1, x_1416); +if (lean_is_scalar(x_1420)) { + x_1446 = lean_alloc_ctor(0, 2, 0); +} else { + x_1446 = x_1420; +} +lean_ctor_set(x_1446, 0, x_1445); +lean_ctor_set(x_1446, 1, x_1419); +return x_1446; +} +} +} +} +} +else +{ +lean_object* x_1538; lean_object* x_1539; lean_object* x_1540; lean_object* x_1541; uint8_t x_1677; +lean_dec(x_6); +x_1538 = lean_unsigned_to_nat(0u); +x_1539 = l_Lean_Syntax_getIdAt(x_1, x_1538); +x_1540 = l_Lean_Name_eraseMacroScopes(x_1539); +lean_dec(x_1539); +x_1677 = lean_ctor_get_uint8(x_2, sizeof(void*)*1); +if (x_1677 == 0) +{ +lean_object* x_1678; +lean_dec(x_2); +x_1678 = lean_box(0); +x_1541 = x_1678; +goto block_1676; +} +else +{ +lean_object* x_1679; uint8_t x_1680; +x_1679 = lean_ctor_get(x_2, 0); +lean_inc(x_1679); +lean_dec(x_2); +x_1680 = lean_name_eq(x_1540, x_1679); +lean_dec(x_1679); +if (x_1680 == 0) +{ +lean_object* x_1681; +x_1681 = lean_box(0); +x_1541 = x_1681; +goto block_1676; +} +else +{ +lean_object* x_1682; lean_object* x_1683; uint8_t x_1684; +lean_dec(x_1540); +x_1682 = l_Lean_Elab_Term_toParserDescrAux___main___closed__122; +x_1683 = l_Lean_Elab_Term_throwError___rarg(x_1, x_1682, x_4, x_5); +lean_dec(x_1); +x_1684 = !lean_is_exclusive(x_1683); +if (x_1684 == 0) +{ +return x_1683; +} +else +{ +lean_object* x_1685; lean_object* x_1686; lean_object* x_1687; +x_1685 = lean_ctor_get(x_1683, 0); +x_1686 = lean_ctor_get(x_1683, 1); +lean_inc(x_1686); +lean_inc(x_1685); +lean_dec(x_1683); +x_1687 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1687, 0, x_1685); +lean_ctor_set(x_1687, 1, x_1686); +return x_1687; +} +} +} +block_1676: +{ +lean_object* x_1542; lean_object* x_1543; lean_object* x_1544; lean_object* x_1545; lean_object* x_1546; lean_object* x_1547; uint8_t x_1548; uint8_t x_1549; +lean_dec(x_1541); +x_1542 = lean_unsigned_to_nat(1u); +x_1543 = l_Lean_Syntax_getArg(x_1, x_1542); +x_1544 = l___private_Lean_Elab_Syntax_1__expandOptPrecedence(x_1543); +lean_dec(x_1543); +x_1545 = l_Lean_Elab_Term_getEnv___rarg(x_5); +x_1546 = lean_ctor_get(x_1545, 0); +lean_inc(x_1546); +x_1547 = lean_ctor_get(x_1545, 1); +lean_inc(x_1547); +lean_dec(x_1545); +x_1548 = l_Lean_Parser_isParserCategory(x_1546, x_1540); +lean_dec(x_1546); +if (x_1548 == 0) +{ +uint8_t x_1674; +x_1674 = 0; +x_1549 = x_1674; +goto block_1673; +} +else +{ +uint8_t x_1675; +x_1675 = 1; +x_1549 = x_1675; +goto block_1673; +} +block_1673: +{ +lean_object* x_1550; +if (lean_obj_tag(x_1544) == 0) +{ +x_1550 = x_1538; +goto block_1671; +} +else +{ +lean_object* x_1672; +x_1672 = lean_ctor_get(x_1544, 0); +lean_inc(x_1672); +lean_dec(x_1544); +x_1550 = x_1672; +goto block_1671; +} +block_1671: +{ +lean_object* x_1551; lean_object* x_1552; +if (x_1549 == 0) +{ +lean_object* x_1654; lean_object* x_1655; lean_object* x_1656; lean_object* x_1657; lean_object* x_1658; lean_object* x_1659; lean_object* x_1660; lean_object* x_1661; uint8_t x_1662; +lean_dec(x_1550); +x_1654 = lean_unsigned_to_nat(3u); +x_1655 = l_Lean_Syntax_getArg(x_1, x_1654); +lean_dec(x_1); +x_1656 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_1656, 0, x_1540); +x_1657 = l_Lean_Elab_Term_toParserDescrAux___main___closed__119; +x_1658 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_1658, 0, x_1657); +lean_ctor_set(x_1658, 1, x_1656); +x_1659 = l_Array_forMAux___main___at_Lean_Meta_clear___spec__5___closed__8; +x_1660 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_1660, 0, x_1658); +lean_ctor_set(x_1660, 1, x_1659); +x_1661 = l_Lean_Elab_Term_throwError___rarg(x_1655, x_1660, x_4, x_1547); +lean_dec(x_1655); +x_1662 = !lean_is_exclusive(x_1661); +if (x_1662 == 0) +{ +return x_1661; +} +else +{ +lean_object* x_1663; lean_object* x_1664; lean_object* x_1665; +x_1663 = lean_ctor_get(x_1661, 0); +x_1664 = lean_ctor_get(x_1661, 1); +lean_inc(x_1664); +lean_inc(x_1663); +lean_dec(x_1661); +x_1665 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1665, 0, x_1663); +lean_ctor_set(x_1665, 1, x_1664); +return x_1665; +} +} +else +{ +lean_object* x_1666; lean_object* x_1667; lean_object* x_1668; lean_object* x_1669; lean_object* x_1670; +lean_dec(x_1); +x_1666 = l_Lean_Elab_Term_getCurrMacroScope(x_4, x_1547); +lean_dec(x_4); +x_1667 = lean_ctor_get(x_1666, 0); +lean_inc(x_1667); +x_1668 = lean_ctor_get(x_1666, 1); +lean_inc(x_1668); +lean_dec(x_1666); +x_1669 = lean_box(x_3); +x_1670 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1670, 0, x_1667); +lean_ctor_set(x_1670, 1, x_1669); +x_1551 = x_1670; +x_1552 = x_1668; +goto block_1653; +} +block_1653: +{ +uint8_t x_1553; +x_1553 = !lean_is_exclusive(x_1551); +if (x_1553 == 0) +{ +lean_object* x_1554; lean_object* x_1555; uint8_t x_1556; +x_1554 = lean_ctor_get(x_1551, 0); +x_1555 = l_Lean_Elab_Term_getMainModule___rarg(x_1552); +x_1556 = !lean_is_exclusive(x_1555); +if (x_1556 == 0) +{ +lean_object* x_1557; lean_object* x_1558; lean_object* x_1559; lean_object* x_1560; lean_object* x_1561; lean_object* x_1562; lean_object* x_1563; lean_object* x_1564; lean_object* x_1565; lean_object* x_1566; lean_object* x_1567; lean_object* x_1568; lean_object* x_1569; lean_object* x_1570; lean_object* x_1571; lean_object* x_1572; lean_object* x_1573; lean_object* x_1574; lean_object* x_1575; lean_object* x_1576; lean_object* x_1577; lean_object* x_1578; lean_object* x_1579; lean_object* x_1580; lean_object* x_1581; lean_object* x_1582; lean_object* x_1583; lean_object* x_1584; lean_object* x_1585; +x_1557 = lean_ctor_get(x_1555, 0); +x_1558 = l_Lean_Elab_Term_toParserDescrAux___main___closed__113; +x_1559 = l_Lean_addMacroScope(x_1557, x_1558, x_1554); +x_1560 = l_Lean_SourceInfo_inhabited___closed__1; +x_1561 = l_Lean_Elab_Term_toParserDescrAux___main___closed__112; +x_1562 = l_Lean_Elab_Term_toParserDescrAux___main___closed__116; +x_1563 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_1563, 0, x_1560); +lean_ctor_set(x_1563, 1, x_1561); +lean_ctor_set(x_1563, 2, x_1559); +lean_ctor_set(x_1563, 3, x_1562); +x_1564 = l_Array_empty___closed__1; +x_1565 = lean_array_push(x_1564, x_1563); +x_1566 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_1567 = lean_array_push(x_1565, x_1566); +x_1568 = l_Lean_mkTermIdFromIdent___closed__2; +x_1569 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1569, 0, x_1568); +lean_ctor_set(x_1569, 1, x_1567); +x_1570 = lean_array_push(x_1564, x_1569); +x_1571 = l___private_Lean_Syntax_7__quoteName___main(x_1540); +x_1572 = lean_array_push(x_1564, x_1571); +x_1573 = l_Nat_repr(x_1550); +x_1574 = l_Lean_numLitKind; +x_1575 = l_Lean_mkStxLit(x_1574, x_1573, x_1560); +x_1576 = l_Lean_mkOptionalNode___closed__2; +x_1577 = lean_array_push(x_1576, x_1575); +x_1578 = l_Lean_Nat_HasQuote___closed__2; +x_1579 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1579, 0, x_1578); +lean_ctor_set(x_1579, 1, x_1577); +x_1580 = lean_array_push(x_1572, x_1579); +x_1581 = l_Lean_nullKind___closed__2; +x_1582 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1582, 0, x_1581); +lean_ctor_set(x_1582, 1, x_1580); +x_1583 = lean_array_push(x_1570, x_1582); +x_1584 = l_Lean_mkAppStx___closed__8; +x_1585 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1585, 0, x_1584); +lean_ctor_set(x_1585, 1, x_1583); +lean_ctor_set(x_1551, 0, x_1585); +lean_ctor_set(x_1555, 0, x_1551); +return x_1555; +} +else +{ +lean_object* x_1586; lean_object* x_1587; lean_object* x_1588; lean_object* x_1589; lean_object* x_1590; lean_object* x_1591; lean_object* x_1592; lean_object* x_1593; lean_object* x_1594; lean_object* x_1595; lean_object* x_1596; lean_object* x_1597; lean_object* x_1598; lean_object* x_1599; lean_object* x_1600; lean_object* x_1601; lean_object* x_1602; lean_object* x_1603; lean_object* x_1604; lean_object* x_1605; lean_object* x_1606; lean_object* x_1607; lean_object* x_1608; lean_object* x_1609; lean_object* x_1610; lean_object* x_1611; lean_object* x_1612; lean_object* x_1613; lean_object* x_1614; lean_object* x_1615; lean_object* x_1616; +x_1586 = lean_ctor_get(x_1555, 0); +x_1587 = lean_ctor_get(x_1555, 1); lean_inc(x_1587); -x_1589 = l_Lean_addMacroScope(x_1587, x_1588, x_1583); +lean_inc(x_1586); +lean_dec(x_1555); +x_1588 = l_Lean_Elab_Term_toParserDescrAux___main___closed__113; +x_1589 = l_Lean_addMacroScope(x_1586, x_1588, x_1554); x_1590 = l_Lean_SourceInfo_inhabited___closed__1; -x_1591 = l_Lean_Elab_Term_toParserDescrAux___main___closed__103; -x_1592 = l_Lean_Elab_Term_toParserDescrAux___main___closed__108; +x_1591 = l_Lean_Elab_Term_toParserDescrAux___main___closed__112; +x_1592 = l_Lean_Elab_Term_toParserDescrAux___main___closed__116; x_1593 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_1593, 0, x_1590); lean_ctor_set(x_1593, 1, x_1591); @@ -6394,522 +6904,107 @@ x_1599 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1599, 0, x_1598); lean_ctor_set(x_1599, 1, x_1597); x_1600 = lean_array_push(x_1594, x_1599); -x_1601 = l_Lean_mkStxStrLit(x_1353, x_1590); -x_1602 = l_Lean_mkOptionalNode___closed__2; -x_1603 = lean_array_push(x_1602, x_1601); -x_1604 = l_Lean_String_HasQuote___closed__2; -x_1605 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1605, 0, x_1604); -lean_ctor_set(x_1605, 1, x_1603); -x_1606 = lean_array_push(x_1594, x_1605); -x_1607 = l_Lean_Elab_Term_toParserDescrAux___main___closed__111; -x_1608 = l_Lean_addMacroScope(x_1587, x_1607, x_1583); -x_1609 = l_Lean_Elab_Term_toParserDescrAux___main___closed__110; -x_1610 = l_Lean_Elab_Term_toParserDescrAux___main___closed__115; -x_1611 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1611, 0, x_1590); -lean_ctor_set(x_1611, 1, x_1609); -lean_ctor_set(x_1611, 2, x_1608); -lean_ctor_set(x_1611, 3, x_1610); -x_1612 = lean_array_push(x_1594, x_1611); -x_1613 = lean_array_push(x_1612, x_1596); -x_1614 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1614, 0, x_1598); -lean_ctor_set(x_1614, 1, x_1613); -x_1615 = lean_array_push(x_1606, x_1614); -x_1616 = l_Lean_nullKind___closed__2; -x_1617 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1617, 0, x_1616); -lean_ctor_set(x_1617, 1, x_1615); -x_1618 = lean_array_push(x_1600, x_1617); -x_1619 = l_Lean_mkAppStx___closed__8; -x_1620 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1620, 0, x_1619); -lean_ctor_set(x_1620, 1, x_1618); -x_1621 = lean_box(x_3); -x_1622 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1622, 0, x_1620); -lean_ctor_set(x_1622, 1, x_1621); -lean_ctor_set(x_1585, 0, x_1622); -return x_1585; -} -else -{ -lean_object* x_1623; lean_object* x_1624; lean_object* x_1625; lean_object* x_1626; lean_object* x_1627; lean_object* x_1628; lean_object* x_1629; lean_object* x_1630; lean_object* x_1631; lean_object* x_1632; lean_object* x_1633; lean_object* x_1634; lean_object* x_1635; lean_object* x_1636; lean_object* x_1637; lean_object* x_1638; lean_object* x_1639; lean_object* x_1640; lean_object* x_1641; lean_object* x_1642; lean_object* x_1643; lean_object* x_1644; lean_object* x_1645; lean_object* x_1646; lean_object* x_1647; lean_object* x_1648; lean_object* x_1649; lean_object* x_1650; lean_object* x_1651; lean_object* x_1652; lean_object* x_1653; lean_object* x_1654; lean_object* x_1655; lean_object* x_1656; lean_object* x_1657; lean_object* x_1658; lean_object* x_1659; lean_object* x_1660; -x_1623 = lean_ctor_get(x_1585, 0); -x_1624 = lean_ctor_get(x_1585, 1); -lean_inc(x_1624); -lean_inc(x_1623); -lean_dec(x_1585); -x_1625 = l_Lean_Elab_Term_toParserDescrAux___main___closed__105; -lean_inc(x_1583); -lean_inc(x_1623); -x_1626 = l_Lean_addMacroScope(x_1623, x_1625, x_1583); -x_1627 = l_Lean_SourceInfo_inhabited___closed__1; -x_1628 = l_Lean_Elab_Term_toParserDescrAux___main___closed__103; -x_1629 = l_Lean_Elab_Term_toParserDescrAux___main___closed__108; -x_1630 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1630, 0, x_1627); -lean_ctor_set(x_1630, 1, x_1628); -lean_ctor_set(x_1630, 2, x_1626); -lean_ctor_set(x_1630, 3, x_1629); -x_1631 = l_Array_empty___closed__1; -x_1632 = lean_array_push(x_1631, x_1630); -x_1633 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1634 = lean_array_push(x_1632, x_1633); -x_1635 = l_Lean_mkTermIdFromIdent___closed__2; -x_1636 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1636, 0, x_1635); -lean_ctor_set(x_1636, 1, x_1634); -x_1637 = lean_array_push(x_1631, x_1636); -x_1638 = l_Lean_mkStxStrLit(x_1353, x_1627); -x_1639 = l_Lean_mkOptionalNode___closed__2; -x_1640 = lean_array_push(x_1639, x_1638); -x_1641 = l_Lean_String_HasQuote___closed__2; -x_1642 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1642, 0, x_1641); -lean_ctor_set(x_1642, 1, x_1640); -x_1643 = lean_array_push(x_1631, x_1642); -x_1644 = l_Lean_Elab_Term_toParserDescrAux___main___closed__111; -x_1645 = l_Lean_addMacroScope(x_1623, x_1644, x_1583); -x_1646 = l_Lean_Elab_Term_toParserDescrAux___main___closed__110; -x_1647 = l_Lean_Elab_Term_toParserDescrAux___main___closed__115; -x_1648 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1648, 0, x_1627); -lean_ctor_set(x_1648, 1, x_1646); -lean_ctor_set(x_1648, 2, x_1645); -lean_ctor_set(x_1648, 3, x_1647); -x_1649 = lean_array_push(x_1631, x_1648); -x_1650 = lean_array_push(x_1649, x_1633); -x_1651 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1651, 0, x_1635); -lean_ctor_set(x_1651, 1, x_1650); -x_1652 = lean_array_push(x_1643, x_1651); -x_1653 = l_Lean_nullKind___closed__2; -x_1654 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1654, 0, x_1653); -lean_ctor_set(x_1654, 1, x_1652); -x_1655 = lean_array_push(x_1637, x_1654); -x_1656 = l_Lean_mkAppStx___closed__8; -x_1657 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1657, 0, x_1656); -lean_ctor_set(x_1657, 1, x_1655); -x_1658 = lean_box(x_3); -x_1659 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1659, 0, x_1657); -lean_ctor_set(x_1659, 1, x_1658); -x_1660 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1660, 0, x_1659); -lean_ctor_set(x_1660, 1, x_1624); -return x_1660; +x_1601 = l___private_Lean_Syntax_7__quoteName___main(x_1540); +x_1602 = lean_array_push(x_1594, x_1601); +x_1603 = l_Nat_repr(x_1550); +x_1604 = l_Lean_numLitKind; +x_1605 = l_Lean_mkStxLit(x_1604, x_1603, x_1590); +x_1606 = l_Lean_mkOptionalNode___closed__2; +x_1607 = lean_array_push(x_1606, x_1605); +x_1608 = l_Lean_Nat_HasQuote___closed__2; +x_1609 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1609, 0, x_1608); +lean_ctor_set(x_1609, 1, x_1607); +x_1610 = lean_array_push(x_1602, x_1609); +x_1611 = l_Lean_nullKind___closed__2; +x_1612 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1612, 0, x_1611); +lean_ctor_set(x_1612, 1, x_1610); +x_1613 = lean_array_push(x_1600, x_1612); +x_1614 = l_Lean_mkAppStx___closed__8; +x_1615 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1615, 0, x_1614); +lean_ctor_set(x_1615, 1, x_1613); +lean_ctor_set(x_1551, 0, x_1615); +x_1616 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1616, 0, x_1551); +lean_ctor_set(x_1616, 1, x_1587); +return x_1616; } } else { -lean_object* x_1661; -x_1661 = lean_box(0); -x_1357 = x_1661; -goto block_1579; +lean_object* x_1617; lean_object* x_1618; lean_object* x_1619; lean_object* x_1620; lean_object* x_1621; lean_object* x_1622; lean_object* x_1623; lean_object* x_1624; lean_object* x_1625; lean_object* x_1626; lean_object* x_1627; lean_object* x_1628; lean_object* x_1629; lean_object* x_1630; lean_object* x_1631; lean_object* x_1632; lean_object* x_1633; lean_object* x_1634; lean_object* x_1635; lean_object* x_1636; lean_object* x_1637; lean_object* x_1638; lean_object* x_1639; lean_object* x_1640; lean_object* x_1641; lean_object* x_1642; lean_object* x_1643; lean_object* x_1644; lean_object* x_1645; lean_object* x_1646; lean_object* x_1647; lean_object* x_1648; lean_object* x_1649; lean_object* x_1650; lean_object* x_1651; lean_object* x_1652; +x_1617 = lean_ctor_get(x_1551, 0); +x_1618 = lean_ctor_get(x_1551, 1); +lean_inc(x_1618); +lean_inc(x_1617); +lean_dec(x_1551); +x_1619 = l_Lean_Elab_Term_getMainModule___rarg(x_1552); +x_1620 = lean_ctor_get(x_1619, 0); +lean_inc(x_1620); +x_1621 = lean_ctor_get(x_1619, 1); +lean_inc(x_1621); +if (lean_is_exclusive(x_1619)) { + lean_ctor_release(x_1619, 0); + lean_ctor_release(x_1619, 1); + x_1622 = x_1619; +} else { + lean_dec_ref(x_1619); + x_1622 = lean_box(0); } +x_1623 = l_Lean_Elab_Term_toParserDescrAux___main___closed__113; +x_1624 = l_Lean_addMacroScope(x_1620, x_1623, x_1617); +x_1625 = l_Lean_SourceInfo_inhabited___closed__1; +x_1626 = l_Lean_Elab_Term_toParserDescrAux___main___closed__112; +x_1627 = l_Lean_Elab_Term_toParserDescrAux___main___closed__116; +x_1628 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_1628, 0, x_1625); +lean_ctor_set(x_1628, 1, x_1626); +lean_ctor_set(x_1628, 2, x_1624); +lean_ctor_set(x_1628, 3, x_1627); +x_1629 = l_Array_empty___closed__1; +x_1630 = lean_array_push(x_1629, x_1628); +x_1631 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_1632 = lean_array_push(x_1630, x_1631); +x_1633 = l_Lean_mkTermIdFromIdent___closed__2; +x_1634 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1634, 0, x_1633); +lean_ctor_set(x_1634, 1, x_1632); +x_1635 = lean_array_push(x_1629, x_1634); +x_1636 = l___private_Lean_Syntax_7__quoteName___main(x_1540); +x_1637 = lean_array_push(x_1629, x_1636); +x_1638 = l_Nat_repr(x_1550); +x_1639 = l_Lean_numLitKind; +x_1640 = l_Lean_mkStxLit(x_1639, x_1638, x_1625); +x_1641 = l_Lean_mkOptionalNode___closed__2; +x_1642 = lean_array_push(x_1641, x_1640); +x_1643 = l_Lean_Nat_HasQuote___closed__2; +x_1644 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1644, 0, x_1643); +lean_ctor_set(x_1644, 1, x_1642); +x_1645 = lean_array_push(x_1637, x_1644); +x_1646 = l_Lean_nullKind___closed__2; +x_1647 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1647, 0, x_1646); +lean_ctor_set(x_1647, 1, x_1645); +x_1648 = lean_array_push(x_1635, x_1647); +x_1649 = l_Lean_mkAppStx___closed__8; +x_1650 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1650, 0, x_1649); +lean_ctor_set(x_1650, 1, x_1648); +x_1651 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1651, 0, x_1650); +lean_ctor_set(x_1651, 1, x_1618); +if (lean_is_scalar(x_1622)) { + x_1652 = lean_alloc_ctor(0, 2, 0); +} else { + x_1652 = x_1622; } -block_1579: -{ -lean_dec(x_1357); -if (lean_obj_tag(x_1356) == 0) -{ -lean_object* x_1358; lean_object* x_1359; lean_object* x_1360; lean_object* x_1361; -x_1358 = l_Lean_Elab_Term_getEnv___rarg(x_5); -x_1359 = lean_ctor_get(x_1358, 0); -lean_inc(x_1359); -x_1360 = lean_ctor_get(x_1358, 1); -lean_inc(x_1360); -lean_dec(x_1358); -x_1361 = l_Lean_Parser_getTokenLbp_x3f(x_1359, x_1353); -lean_dec(x_1359); -if (lean_obj_tag(x_1361) == 0) -{ -lean_object* x_1362; lean_object* x_1363; lean_object* x_1364; lean_object* x_1365; uint8_t x_1366; -x_1362 = l_Lean_Elab_Term_getCurrMacroScope(x_4, x_1360); -lean_dec(x_4); -x_1363 = lean_ctor_get(x_1362, 0); -lean_inc(x_1363); -x_1364 = lean_ctor_get(x_1362, 1); -lean_inc(x_1364); -lean_dec(x_1362); -x_1365 = l_Lean_Elab_Term_getMainModule___rarg(x_1364); -x_1366 = !lean_is_exclusive(x_1365); -if (x_1366 == 0) -{ -lean_object* x_1367; lean_object* x_1368; lean_object* x_1369; lean_object* x_1370; lean_object* x_1371; lean_object* x_1372; lean_object* x_1373; lean_object* x_1374; lean_object* x_1375; lean_object* x_1376; lean_object* x_1377; lean_object* x_1378; lean_object* x_1379; lean_object* x_1380; lean_object* x_1381; lean_object* x_1382; lean_object* x_1383; lean_object* x_1384; lean_object* x_1385; lean_object* x_1386; lean_object* x_1387; lean_object* x_1388; lean_object* x_1389; lean_object* x_1390; lean_object* x_1391; lean_object* x_1392; lean_object* x_1393; lean_object* x_1394; lean_object* x_1395; -x_1367 = lean_ctor_get(x_1365, 0); -x_1368 = l_Lean_Elab_Term_toParserDescrAux___main___closed__91; -x_1369 = l_Lean_addMacroScope(x_1367, x_1368, x_1363); -x_1370 = l_Lean_SourceInfo_inhabited___closed__1; -x_1371 = l_Lean_Elab_Term_toParserDescrAux___main___closed__90; -x_1372 = l_Lean_Elab_Term_toParserDescrAux___main___closed__94; -x_1373 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1373, 0, x_1370); -lean_ctor_set(x_1373, 1, x_1371); -lean_ctor_set(x_1373, 2, x_1369); -lean_ctor_set(x_1373, 3, x_1372); -x_1374 = l_Array_empty___closed__1; -x_1375 = lean_array_push(x_1374, x_1373); -x_1376 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1377 = lean_array_push(x_1375, x_1376); -x_1378 = l_Lean_mkTermIdFromIdent___closed__2; -x_1379 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1379, 0, x_1378); -lean_ctor_set(x_1379, 1, x_1377); -x_1380 = lean_array_push(x_1374, x_1379); -x_1381 = l_Lean_mkStxStrLit(x_1353, x_1370); -x_1382 = l_Lean_mkOptionalNode___closed__2; -x_1383 = lean_array_push(x_1382, x_1381); -x_1384 = l_Lean_String_HasQuote___closed__2; -x_1385 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1385, 0, x_1384); -lean_ctor_set(x_1385, 1, x_1383); -x_1386 = lean_array_push(x_1374, x_1385); -x_1387 = l_Lean_Elab_Term_toParserDescrAux___main___closed__100; -x_1388 = lean_array_push(x_1386, x_1387); -x_1389 = l_Lean_nullKind___closed__2; -x_1390 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1390, 0, x_1389); -lean_ctor_set(x_1390, 1, x_1388); -x_1391 = lean_array_push(x_1380, x_1390); -x_1392 = l_Lean_mkAppStx___closed__8; -x_1393 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1393, 0, x_1392); -lean_ctor_set(x_1393, 1, x_1391); -x_1394 = lean_box(x_3); -x_1395 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1395, 0, x_1393); -lean_ctor_set(x_1395, 1, x_1394); -lean_ctor_set(x_1365, 0, x_1395); -return x_1365; +lean_ctor_set(x_1652, 0, x_1651); +lean_ctor_set(x_1652, 1, x_1621); +return x_1652; } -else -{ -lean_object* x_1396; lean_object* x_1397; lean_object* x_1398; lean_object* x_1399; lean_object* x_1400; lean_object* x_1401; lean_object* x_1402; lean_object* x_1403; lean_object* x_1404; lean_object* x_1405; lean_object* x_1406; lean_object* x_1407; lean_object* x_1408; lean_object* x_1409; lean_object* x_1410; lean_object* x_1411; lean_object* x_1412; lean_object* x_1413; lean_object* x_1414; lean_object* x_1415; lean_object* x_1416; lean_object* x_1417; lean_object* x_1418; lean_object* x_1419; lean_object* x_1420; lean_object* x_1421; lean_object* x_1422; lean_object* x_1423; lean_object* x_1424; lean_object* x_1425; lean_object* x_1426; -x_1396 = lean_ctor_get(x_1365, 0); -x_1397 = lean_ctor_get(x_1365, 1); -lean_inc(x_1397); -lean_inc(x_1396); -lean_dec(x_1365); -x_1398 = l_Lean_Elab_Term_toParserDescrAux___main___closed__91; -x_1399 = l_Lean_addMacroScope(x_1396, x_1398, x_1363); -x_1400 = l_Lean_SourceInfo_inhabited___closed__1; -x_1401 = l_Lean_Elab_Term_toParserDescrAux___main___closed__90; -x_1402 = l_Lean_Elab_Term_toParserDescrAux___main___closed__94; -x_1403 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1403, 0, x_1400); -lean_ctor_set(x_1403, 1, x_1401); -lean_ctor_set(x_1403, 2, x_1399); -lean_ctor_set(x_1403, 3, x_1402); -x_1404 = l_Array_empty___closed__1; -x_1405 = lean_array_push(x_1404, x_1403); -x_1406 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1407 = lean_array_push(x_1405, x_1406); -x_1408 = l_Lean_mkTermIdFromIdent___closed__2; -x_1409 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1409, 0, x_1408); -lean_ctor_set(x_1409, 1, x_1407); -x_1410 = lean_array_push(x_1404, x_1409); -x_1411 = l_Lean_mkStxStrLit(x_1353, x_1400); -x_1412 = l_Lean_mkOptionalNode___closed__2; -x_1413 = lean_array_push(x_1412, x_1411); -x_1414 = l_Lean_String_HasQuote___closed__2; -x_1415 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1415, 0, x_1414); -lean_ctor_set(x_1415, 1, x_1413); -x_1416 = lean_array_push(x_1404, x_1415); -x_1417 = l_Lean_Elab_Term_toParserDescrAux___main___closed__100; -x_1418 = lean_array_push(x_1416, x_1417); -x_1419 = l_Lean_nullKind___closed__2; -x_1420 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1420, 0, x_1419); -lean_ctor_set(x_1420, 1, x_1418); -x_1421 = lean_array_push(x_1410, x_1420); -x_1422 = l_Lean_mkAppStx___closed__8; -x_1423 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1423, 0, x_1422); -lean_ctor_set(x_1423, 1, x_1421); -x_1424 = lean_box(x_3); -x_1425 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1425, 0, x_1423); -lean_ctor_set(x_1425, 1, x_1424); -x_1426 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1426, 0, x_1425); -lean_ctor_set(x_1426, 1, x_1397); -return x_1426; -} -} -else -{ -lean_object* x_1427; lean_object* x_1428; lean_object* x_1429; lean_object* x_1430; lean_object* x_1431; uint8_t x_1432; -x_1427 = lean_ctor_get(x_1361, 0); -lean_inc(x_1427); -lean_dec(x_1361); -x_1428 = l_Lean_Elab_Term_getCurrMacroScope(x_4, x_1360); -lean_dec(x_4); -x_1429 = lean_ctor_get(x_1428, 0); -lean_inc(x_1429); -x_1430 = lean_ctor_get(x_1428, 1); -lean_inc(x_1430); -lean_dec(x_1428); -x_1431 = l_Lean_Elab_Term_getMainModule___rarg(x_1430); -x_1432 = !lean_is_exclusive(x_1431); -if (x_1432 == 0) -{ -lean_object* x_1433; lean_object* x_1434; lean_object* x_1435; lean_object* x_1436; lean_object* x_1437; lean_object* x_1438; lean_object* x_1439; lean_object* x_1440; lean_object* x_1441; lean_object* x_1442; lean_object* x_1443; lean_object* x_1444; lean_object* x_1445; lean_object* x_1446; lean_object* x_1447; lean_object* x_1448; lean_object* x_1449; lean_object* x_1450; lean_object* x_1451; lean_object* x_1452; lean_object* x_1453; lean_object* x_1454; lean_object* x_1455; lean_object* x_1456; lean_object* x_1457; lean_object* x_1458; lean_object* x_1459; lean_object* x_1460; lean_object* x_1461; lean_object* x_1462; lean_object* x_1463; lean_object* x_1464; lean_object* x_1465; lean_object* x_1466; -x_1433 = lean_ctor_get(x_1431, 0); -x_1434 = l_Lean_Elab_Term_toParserDescrAux___main___closed__91; -x_1435 = l_Lean_addMacroScope(x_1433, x_1434, x_1429); -x_1436 = l_Lean_SourceInfo_inhabited___closed__1; -x_1437 = l_Lean_Elab_Term_toParserDescrAux___main___closed__90; -x_1438 = l_Lean_Elab_Term_toParserDescrAux___main___closed__94; -x_1439 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1439, 0, x_1436); -lean_ctor_set(x_1439, 1, x_1437); -lean_ctor_set(x_1439, 2, x_1435); -lean_ctor_set(x_1439, 3, x_1438); -x_1440 = l_Array_empty___closed__1; -x_1441 = lean_array_push(x_1440, x_1439); -x_1442 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1443 = lean_array_push(x_1441, x_1442); -x_1444 = l_Lean_mkTermIdFromIdent___closed__2; -x_1445 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1445, 0, x_1444); -lean_ctor_set(x_1445, 1, x_1443); -x_1446 = lean_array_push(x_1440, x_1445); -x_1447 = l_Lean_mkStxStrLit(x_1353, x_1436); -x_1448 = l_Lean_mkOptionalNode___closed__2; -x_1449 = lean_array_push(x_1448, x_1447); -x_1450 = l_Lean_String_HasQuote___closed__2; -x_1451 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1451, 0, x_1450); -lean_ctor_set(x_1451, 1, x_1449); -x_1452 = lean_array_push(x_1440, x_1451); -x_1453 = l_Nat_repr(x_1427); -x_1454 = l_Lean_numLitKind; -x_1455 = l_Lean_mkStxLit(x_1454, x_1453, x_1436); -x_1456 = lean_array_push(x_1448, x_1455); -x_1457 = l_Lean_Nat_HasQuote___closed__2; -x_1458 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1458, 0, x_1457); -lean_ctor_set(x_1458, 1, x_1456); -x_1459 = lean_array_push(x_1452, x_1458); -x_1460 = l_Lean_nullKind___closed__2; -x_1461 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1461, 0, x_1460); -lean_ctor_set(x_1461, 1, x_1459); -x_1462 = lean_array_push(x_1446, x_1461); -x_1463 = l_Lean_mkAppStx___closed__8; -x_1464 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1464, 0, x_1463); -lean_ctor_set(x_1464, 1, x_1462); -x_1465 = lean_box(x_3); -x_1466 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1466, 0, x_1464); -lean_ctor_set(x_1466, 1, x_1465); -lean_ctor_set(x_1431, 0, x_1466); -return x_1431; -} -else -{ -lean_object* x_1467; lean_object* x_1468; lean_object* x_1469; lean_object* x_1470; lean_object* x_1471; lean_object* x_1472; lean_object* x_1473; lean_object* x_1474; lean_object* x_1475; lean_object* x_1476; lean_object* x_1477; lean_object* x_1478; lean_object* x_1479; lean_object* x_1480; lean_object* x_1481; lean_object* x_1482; lean_object* x_1483; lean_object* x_1484; lean_object* x_1485; lean_object* x_1486; lean_object* x_1487; lean_object* x_1488; lean_object* x_1489; lean_object* x_1490; lean_object* x_1491; lean_object* x_1492; lean_object* x_1493; lean_object* x_1494; lean_object* x_1495; lean_object* x_1496; lean_object* x_1497; lean_object* x_1498; lean_object* x_1499; lean_object* x_1500; lean_object* x_1501; lean_object* x_1502; -x_1467 = lean_ctor_get(x_1431, 0); -x_1468 = lean_ctor_get(x_1431, 1); -lean_inc(x_1468); -lean_inc(x_1467); -lean_dec(x_1431); -x_1469 = l_Lean_Elab_Term_toParserDescrAux___main___closed__91; -x_1470 = l_Lean_addMacroScope(x_1467, x_1469, x_1429); -x_1471 = l_Lean_SourceInfo_inhabited___closed__1; -x_1472 = l_Lean_Elab_Term_toParserDescrAux___main___closed__90; -x_1473 = l_Lean_Elab_Term_toParserDescrAux___main___closed__94; -x_1474 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1474, 0, x_1471); -lean_ctor_set(x_1474, 1, x_1472); -lean_ctor_set(x_1474, 2, x_1470); -lean_ctor_set(x_1474, 3, x_1473); -x_1475 = l_Array_empty___closed__1; -x_1476 = lean_array_push(x_1475, x_1474); -x_1477 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1478 = lean_array_push(x_1476, x_1477); -x_1479 = l_Lean_mkTermIdFromIdent___closed__2; -x_1480 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1480, 0, x_1479); -lean_ctor_set(x_1480, 1, x_1478); -x_1481 = lean_array_push(x_1475, x_1480); -x_1482 = l_Lean_mkStxStrLit(x_1353, x_1471); -x_1483 = l_Lean_mkOptionalNode___closed__2; -x_1484 = lean_array_push(x_1483, x_1482); -x_1485 = l_Lean_String_HasQuote___closed__2; -x_1486 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1486, 0, x_1485); -lean_ctor_set(x_1486, 1, x_1484); -x_1487 = lean_array_push(x_1475, x_1486); -x_1488 = l_Nat_repr(x_1427); -x_1489 = l_Lean_numLitKind; -x_1490 = l_Lean_mkStxLit(x_1489, x_1488, x_1471); -x_1491 = lean_array_push(x_1483, x_1490); -x_1492 = l_Lean_Nat_HasQuote___closed__2; -x_1493 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1493, 0, x_1492); -lean_ctor_set(x_1493, 1, x_1491); -x_1494 = lean_array_push(x_1487, x_1493); -x_1495 = l_Lean_nullKind___closed__2; -x_1496 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1496, 0, x_1495); -lean_ctor_set(x_1496, 1, x_1494); -x_1497 = lean_array_push(x_1481, x_1496); -x_1498 = l_Lean_mkAppStx___closed__8; -x_1499 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1499, 0, x_1498); -lean_ctor_set(x_1499, 1, x_1497); -x_1500 = lean_box(x_3); -x_1501 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1501, 0, x_1499); -lean_ctor_set(x_1501, 1, x_1500); -x_1502 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1502, 0, x_1501); -lean_ctor_set(x_1502, 1, x_1468); -return x_1502; -} -} -} -else -{ -lean_object* x_1503; lean_object* x_1504; lean_object* x_1505; lean_object* x_1506; lean_object* x_1507; uint8_t x_1508; -x_1503 = lean_ctor_get(x_1356, 0); -lean_inc(x_1503); -lean_dec(x_1356); -x_1504 = l_Lean_Elab_Term_getCurrMacroScope(x_4, x_5); -lean_dec(x_4); -x_1505 = lean_ctor_get(x_1504, 0); -lean_inc(x_1505); -x_1506 = lean_ctor_get(x_1504, 1); -lean_inc(x_1506); -lean_dec(x_1504); -x_1507 = l_Lean_Elab_Term_getMainModule___rarg(x_1506); -x_1508 = !lean_is_exclusive(x_1507); -if (x_1508 == 0) -{ -lean_object* x_1509; lean_object* x_1510; lean_object* x_1511; lean_object* x_1512; lean_object* x_1513; lean_object* x_1514; lean_object* x_1515; lean_object* x_1516; lean_object* x_1517; lean_object* x_1518; lean_object* x_1519; lean_object* x_1520; lean_object* x_1521; lean_object* x_1522; lean_object* x_1523; lean_object* x_1524; lean_object* x_1525; lean_object* x_1526; lean_object* x_1527; lean_object* x_1528; lean_object* x_1529; lean_object* x_1530; lean_object* x_1531; lean_object* x_1532; lean_object* x_1533; lean_object* x_1534; lean_object* x_1535; lean_object* x_1536; lean_object* x_1537; lean_object* x_1538; lean_object* x_1539; lean_object* x_1540; lean_object* x_1541; lean_object* x_1542; -x_1509 = lean_ctor_get(x_1507, 0); -x_1510 = l_Lean_Elab_Term_toParserDescrAux___main___closed__91; -x_1511 = l_Lean_addMacroScope(x_1509, x_1510, x_1505); -x_1512 = l_Lean_SourceInfo_inhabited___closed__1; -x_1513 = l_Lean_Elab_Term_toParserDescrAux___main___closed__90; -x_1514 = l_Lean_Elab_Term_toParserDescrAux___main___closed__94; -x_1515 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1515, 0, x_1512); -lean_ctor_set(x_1515, 1, x_1513); -lean_ctor_set(x_1515, 2, x_1511); -lean_ctor_set(x_1515, 3, x_1514); -x_1516 = l_Array_empty___closed__1; -x_1517 = lean_array_push(x_1516, x_1515); -x_1518 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1519 = lean_array_push(x_1517, x_1518); -x_1520 = l_Lean_mkTermIdFromIdent___closed__2; -x_1521 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1521, 0, x_1520); -lean_ctor_set(x_1521, 1, x_1519); -x_1522 = lean_array_push(x_1516, x_1521); -x_1523 = l_Lean_mkStxStrLit(x_1353, x_1512); -x_1524 = l_Lean_mkOptionalNode___closed__2; -x_1525 = lean_array_push(x_1524, x_1523); -x_1526 = l_Lean_String_HasQuote___closed__2; -x_1527 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1527, 0, x_1526); -lean_ctor_set(x_1527, 1, x_1525); -x_1528 = lean_array_push(x_1516, x_1527); -x_1529 = l_Nat_repr(x_1503); -x_1530 = l_Lean_numLitKind; -x_1531 = l_Lean_mkStxLit(x_1530, x_1529, x_1512); -x_1532 = lean_array_push(x_1524, x_1531); -x_1533 = l_Lean_Nat_HasQuote___closed__2; -x_1534 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1534, 0, x_1533); -lean_ctor_set(x_1534, 1, x_1532); -x_1535 = lean_array_push(x_1528, x_1534); -x_1536 = l_Lean_nullKind___closed__2; -x_1537 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1537, 0, x_1536); -lean_ctor_set(x_1537, 1, x_1535); -x_1538 = lean_array_push(x_1522, x_1537); -x_1539 = l_Lean_mkAppStx___closed__8; -x_1540 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1540, 0, x_1539); -lean_ctor_set(x_1540, 1, x_1538); -x_1541 = lean_box(x_3); -x_1542 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1542, 0, x_1540); -lean_ctor_set(x_1542, 1, x_1541); -lean_ctor_set(x_1507, 0, x_1542); -return x_1507; -} -else -{ -lean_object* x_1543; lean_object* x_1544; lean_object* x_1545; lean_object* x_1546; lean_object* x_1547; lean_object* x_1548; lean_object* x_1549; lean_object* x_1550; lean_object* x_1551; lean_object* x_1552; lean_object* x_1553; lean_object* x_1554; lean_object* x_1555; lean_object* x_1556; lean_object* x_1557; lean_object* x_1558; lean_object* x_1559; lean_object* x_1560; lean_object* x_1561; lean_object* x_1562; lean_object* x_1563; lean_object* x_1564; lean_object* x_1565; lean_object* x_1566; lean_object* x_1567; lean_object* x_1568; lean_object* x_1569; lean_object* x_1570; lean_object* x_1571; lean_object* x_1572; lean_object* x_1573; lean_object* x_1574; lean_object* x_1575; lean_object* x_1576; lean_object* x_1577; lean_object* x_1578; -x_1543 = lean_ctor_get(x_1507, 0); -x_1544 = lean_ctor_get(x_1507, 1); -lean_inc(x_1544); -lean_inc(x_1543); -lean_dec(x_1507); -x_1545 = l_Lean_Elab_Term_toParserDescrAux___main___closed__91; -x_1546 = l_Lean_addMacroScope(x_1543, x_1545, x_1505); -x_1547 = l_Lean_SourceInfo_inhabited___closed__1; -x_1548 = l_Lean_Elab_Term_toParserDescrAux___main___closed__90; -x_1549 = l_Lean_Elab_Term_toParserDescrAux___main___closed__94; -x_1550 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1550, 0, x_1547); -lean_ctor_set(x_1550, 1, x_1548); -lean_ctor_set(x_1550, 2, x_1546); -lean_ctor_set(x_1550, 3, x_1549); -x_1551 = l_Array_empty___closed__1; -x_1552 = lean_array_push(x_1551, x_1550); -x_1553 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1554 = lean_array_push(x_1552, x_1553); -x_1555 = l_Lean_mkTermIdFromIdent___closed__2; -x_1556 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1556, 0, x_1555); -lean_ctor_set(x_1556, 1, x_1554); -x_1557 = lean_array_push(x_1551, x_1556); -x_1558 = l_Lean_mkStxStrLit(x_1353, x_1547); -x_1559 = l_Lean_mkOptionalNode___closed__2; -x_1560 = lean_array_push(x_1559, x_1558); -x_1561 = l_Lean_String_HasQuote___closed__2; -x_1562 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1562, 0, x_1561); -lean_ctor_set(x_1562, 1, x_1560); -x_1563 = lean_array_push(x_1551, x_1562); -x_1564 = l_Nat_repr(x_1503); -x_1565 = l_Lean_numLitKind; -x_1566 = l_Lean_mkStxLit(x_1565, x_1564, x_1547); -x_1567 = lean_array_push(x_1559, x_1566); -x_1568 = l_Lean_Nat_HasQuote___closed__2; -x_1569 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1569, 0, x_1568); -lean_ctor_set(x_1569, 1, x_1567); -x_1570 = lean_array_push(x_1563, x_1569); -x_1571 = l_Lean_nullKind___closed__2; -x_1572 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1572, 0, x_1571); -lean_ctor_set(x_1572, 1, x_1570); -x_1573 = lean_array_push(x_1557, x_1572); -x_1574 = l_Lean_mkAppStx___closed__8; -x_1575 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1575, 0, x_1574); -lean_ctor_set(x_1575, 1, x_1573); -x_1576 = lean_box(x_3); -x_1577 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1577, 0, x_1575); -lean_ctor_set(x_1577, 1, x_1576); -x_1578 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1578, 0, x_1577); -lean_ctor_set(x_1578, 1, x_1544); -return x_1578; } } } @@ -6918,831 +7013,473 @@ return x_1578; } else { -lean_object* x_1662; lean_object* x_1663; lean_object* x_1664; lean_object* x_1665; uint8_t x_1801; +lean_object* x_1688; lean_object* x_1689; lean_dec(x_6); -x_1662 = lean_unsigned_to_nat(0u); -x_1663 = l_Lean_Syntax_getIdAt(x_1, x_1662); -x_1664 = l_Lean_Name_eraseMacroScopes(x_1663); -lean_dec(x_1663); -x_1801 = lean_ctor_get_uint8(x_2, sizeof(void*)*1); -if (x_1801 == 0) -{ -lean_object* x_1802; -lean_dec(x_2); -x_1802 = lean_box(0); -x_1665 = x_1802; -goto block_1800; -} -else -{ -lean_object* x_1803; uint8_t x_1804; -x_1803 = lean_ctor_get(x_2, 0); -lean_inc(x_1803); -lean_dec(x_2); -x_1804 = lean_name_eq(x_1664, x_1803); -lean_dec(x_1803); -if (x_1804 == 0) -{ -lean_object* x_1805; -x_1805 = lean_box(0); -x_1665 = x_1805; -goto block_1800; -} -else -{ -lean_object* x_1806; lean_object* x_1807; uint8_t x_1808; -lean_dec(x_1664); -x_1806 = l_Lean_Elab_Term_toParserDescrAux___main___closed__128; -x_1807 = l_Lean_Elab_Term_throwError___rarg(x_1, x_1806, x_4, x_5); +x_1688 = lean_unsigned_to_nat(1u); +x_1689 = l_Lean_Syntax_getArg(x_1, x_1688); lean_dec(x_1); -x_1808 = !lean_is_exclusive(x_1807); -if (x_1808 == 0) -{ -return x_1807; +x_1 = x_1689; +goto _start; +} } else { -lean_object* x_1809; lean_object* x_1810; lean_object* x_1811; -x_1809 = lean_ctor_get(x_1807, 0); -x_1810 = lean_ctor_get(x_1807, 1); -lean_inc(x_1810); -lean_inc(x_1809); -lean_dec(x_1807); -x_1811 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1811, 0, x_1809); -lean_ctor_set(x_1811, 1, x_1810); -return x_1811; -} -} -} -block_1800: -{ -lean_object* x_1666; lean_object* x_1667; lean_object* x_1668; lean_object* x_1669; lean_object* x_1670; lean_object* x_1671; uint8_t x_1672; uint8_t x_1673; -lean_dec(x_1665); -x_1666 = lean_unsigned_to_nat(1u); -x_1667 = l_Lean_Syntax_getArg(x_1, x_1666); -x_1668 = l___private_Lean_Elab_Syntax_1__expandOptPrecedence(x_1667); -lean_dec(x_1667); -x_1669 = l_Lean_Elab_Term_getEnv___rarg(x_5); -x_1670 = lean_ctor_get(x_1669, 0); -lean_inc(x_1670); -x_1671 = lean_ctor_get(x_1669, 1); -lean_inc(x_1671); -lean_dec(x_1669); -x_1672 = l_Lean_Parser_isParserCategory(x_1670, x_1664); -lean_dec(x_1670); -if (x_1672 == 0) -{ -uint8_t x_1798; -x_1798 = 0; -x_1673 = x_1798; -goto block_1797; -} -else -{ -uint8_t x_1799; -x_1799 = 1; -x_1673 = x_1799; -goto block_1797; -} -block_1797: -{ -lean_object* x_1674; -if (lean_obj_tag(x_1668) == 0) -{ -x_1674 = x_1662; -goto block_1795; -} -else -{ -lean_object* x_1796; -x_1796 = lean_ctor_get(x_1668, 0); -lean_inc(x_1796); -lean_dec(x_1668); -x_1674 = x_1796; -goto block_1795; -} -block_1795: -{ -lean_object* x_1675; lean_object* x_1676; -if (x_1673 == 0) -{ -lean_object* x_1778; lean_object* x_1779; lean_object* x_1780; lean_object* x_1781; lean_object* x_1782; lean_object* x_1783; lean_object* x_1784; lean_object* x_1785; uint8_t x_1786; -lean_dec(x_1674); -x_1778 = lean_unsigned_to_nat(3u); -x_1779 = l_Lean_Syntax_getArg(x_1, x_1778); +lean_object* x_1691; lean_object* x_1692; +lean_dec(x_6); +x_1691 = lean_unsigned_to_nat(0u); +x_1692 = l_Lean_Syntax_getArg(x_1, x_1691); lean_dec(x_1); -x_1780 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_1780, 0, x_1664); -x_1781 = l_Lean_Elab_Term_toParserDescrAux___main___closed__125; -x_1782 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_1782, 0, x_1781); -lean_ctor_set(x_1782, 1, x_1780); -x_1783 = l_Array_forMAux___main___at_Lean_Meta_clear___spec__5___closed__8; -x_1784 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_1784, 0, x_1782); -lean_ctor_set(x_1784, 1, x_1783); -x_1785 = l_Lean_Elab_Term_throwError___rarg(x_1779, x_1784, x_4, x_1671); -lean_dec(x_1779); -x_1786 = !lean_is_exclusive(x_1785); -if (x_1786 == 0) +x_1 = x_1692; +goto _start; +} +} +else { +lean_object* x_1694; lean_object* x_1695; lean_object* x_1696; lean_object* x_1697; +lean_dec(x_6); +x_1694 = l_Lean_Syntax_getArgs(x_1); +x_1695 = lean_unsigned_to_nat(0u); +x_1696 = l_Lean_Syntax_getArg(x_1, x_1695); +lean_inc(x_4); +x_1697 = l_Lean_Elab_Term_checkLeftRec(x_1696, x_2, x_3, x_4, x_5); +if (lean_obj_tag(x_1697) == 0) +{ +lean_object* x_1698; lean_object* x_1699; uint8_t x_1700; +x_1698 = lean_ctor_get(x_1697, 0); +lean_inc(x_1698); +x_1699 = lean_ctor_get(x_1698, 0); +lean_inc(x_1699); +x_1700 = lean_unbox(x_1699); +lean_dec(x_1699); +if (x_1700 == 0) +{ +lean_object* x_1701; lean_object* x_1702; lean_object* x_1703; lean_object* x_1704; lean_object* x_1705; lean_object* x_1706; +lean_dec(x_1); +x_1701 = lean_ctor_get(x_1697, 1); +lean_inc(x_1701); +lean_dec(x_1697); +x_1702 = lean_ctor_get(x_1698, 1); +lean_inc(x_1702); +lean_dec(x_1698); +x_1703 = x_1694; +x_1704 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at_Lean_Elab_Term_toParserDescrAux___main___spec__1___boxed), 6, 2); +lean_closure_set(x_1704, 0, x_1695); +lean_closure_set(x_1704, 1, x_1703); +x_1705 = x_1704; +lean_inc(x_4); +x_1706 = lean_apply_4(x_1705, x_2, x_1702, x_4, x_1701); +if (lean_obj_tag(x_1706) == 0) +{ +lean_object* x_1707; lean_object* x_1708; uint8_t x_1709; +x_1707 = lean_ctor_get(x_1706, 0); +lean_inc(x_1707); +x_1708 = lean_ctor_get(x_1706, 1); +lean_inc(x_1708); +lean_dec(x_1706); +x_1709 = !lean_is_exclusive(x_1707); +if (x_1709 == 0) +{ +lean_object* x_1710; lean_object* x_1711; lean_object* x_1712; +x_1710 = lean_ctor_get(x_1707, 0); +x_1711 = lean_ctor_get(x_1707, 1); +x_1712 = l___private_Lean_Elab_Syntax_2__mkParserSeq(x_1710, x_4, x_1708); +lean_dec(x_4); +lean_dec(x_1710); +if (lean_obj_tag(x_1712) == 0) +{ +uint8_t x_1713; +x_1713 = !lean_is_exclusive(x_1712); +if (x_1713 == 0) +{ +lean_object* x_1714; +x_1714 = lean_ctor_get(x_1712, 0); +lean_ctor_set(x_1707, 0, x_1714); +lean_ctor_set(x_1712, 0, x_1707); +return x_1712; +} +else +{ +lean_object* x_1715; lean_object* x_1716; lean_object* x_1717; +x_1715 = lean_ctor_get(x_1712, 0); +x_1716 = lean_ctor_get(x_1712, 1); +lean_inc(x_1716); +lean_inc(x_1715); +lean_dec(x_1712); +lean_ctor_set(x_1707, 0, x_1715); +x_1717 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1717, 0, x_1707); +lean_ctor_set(x_1717, 1, x_1716); +return x_1717; +} +} +else +{ +uint8_t x_1718; +lean_free_object(x_1707); +lean_dec(x_1711); +x_1718 = !lean_is_exclusive(x_1712); +if (x_1718 == 0) +{ +return x_1712; +} +else +{ +lean_object* x_1719; lean_object* x_1720; lean_object* x_1721; +x_1719 = lean_ctor_get(x_1712, 0); +x_1720 = lean_ctor_get(x_1712, 1); +lean_inc(x_1720); +lean_inc(x_1719); +lean_dec(x_1712); +x_1721 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1721, 0, x_1719); +lean_ctor_set(x_1721, 1, x_1720); +return x_1721; +} +} +} +else +{ +lean_object* x_1722; lean_object* x_1723; lean_object* x_1724; +x_1722 = lean_ctor_get(x_1707, 0); +x_1723 = lean_ctor_get(x_1707, 1); +lean_inc(x_1723); +lean_inc(x_1722); +lean_dec(x_1707); +x_1724 = l___private_Lean_Elab_Syntax_2__mkParserSeq(x_1722, x_4, x_1708); +lean_dec(x_4); +lean_dec(x_1722); +if (lean_obj_tag(x_1724) == 0) +{ +lean_object* x_1725; lean_object* x_1726; lean_object* x_1727; lean_object* x_1728; lean_object* x_1729; +x_1725 = lean_ctor_get(x_1724, 0); +lean_inc(x_1725); +x_1726 = lean_ctor_get(x_1724, 1); +lean_inc(x_1726); +if (lean_is_exclusive(x_1724)) { + lean_ctor_release(x_1724, 0); + lean_ctor_release(x_1724, 1); + x_1727 = x_1724; +} else { + lean_dec_ref(x_1724); + x_1727 = lean_box(0); +} +x_1728 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1728, 0, x_1725); +lean_ctor_set(x_1728, 1, x_1723); +if (lean_is_scalar(x_1727)) { + x_1729 = lean_alloc_ctor(0, 2, 0); +} else { + x_1729 = x_1727; +} +lean_ctor_set(x_1729, 0, x_1728); +lean_ctor_set(x_1729, 1, x_1726); +return x_1729; +} +else +{ +lean_object* x_1730; lean_object* x_1731; lean_object* x_1732; lean_object* x_1733; +lean_dec(x_1723); +x_1730 = lean_ctor_get(x_1724, 0); +lean_inc(x_1730); +x_1731 = lean_ctor_get(x_1724, 1); +lean_inc(x_1731); +if (lean_is_exclusive(x_1724)) { + lean_ctor_release(x_1724, 0); + lean_ctor_release(x_1724, 1); + x_1732 = x_1724; +} else { + lean_dec_ref(x_1724); + x_1732 = lean_box(0); +} +if (lean_is_scalar(x_1732)) { + x_1733 = lean_alloc_ctor(1, 2, 0); +} else { + x_1733 = x_1732; +} +lean_ctor_set(x_1733, 0, x_1730); +lean_ctor_set(x_1733, 1, x_1731); +return x_1733; +} +} +} +else +{ +uint8_t x_1734; +lean_dec(x_4); +x_1734 = !lean_is_exclusive(x_1706); +if (x_1734 == 0) +{ +return x_1706; +} +else +{ +lean_object* x_1735; lean_object* x_1736; lean_object* x_1737; +x_1735 = lean_ctor_get(x_1706, 0); +x_1736 = lean_ctor_get(x_1706, 1); +lean_inc(x_1736); +lean_inc(x_1735); +lean_dec(x_1706); +x_1737 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1737, 0, x_1735); +lean_ctor_set(x_1737, 1, x_1736); +return x_1737; +} +} +} +else +{ +lean_object* x_1738; lean_object* x_1739; lean_object* x_1740; lean_object* x_1741; uint8_t x_1742; lean_object* x_1743; lean_object* x_1744; lean_object* x_1745; uint8_t x_1746; +x_1738 = lean_ctor_get(x_1697, 1); +lean_inc(x_1738); +lean_dec(x_1697); +x_1739 = lean_ctor_get(x_1698, 1); +lean_inc(x_1739); +lean_dec(x_1698); +x_1740 = lean_array_get_size(x_1694); +x_1741 = lean_unsigned_to_nat(1u); +x_1742 = lean_nat_dec_eq(x_1740, x_1741); +lean_dec(x_1740); +x_1743 = l_Array_eraseIdx___rarg(x_1694, x_1695); +x_1744 = x_1743; +x_1745 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at_Lean_Elab_Term_toParserDescrAux___main___spec__1___boxed), 6, 2); +lean_closure_set(x_1745, 0, x_1695); +lean_closure_set(x_1745, 1, x_1744); +if (x_1742 == 0) +{ +uint8_t x_1787; +x_1787 = 0; +x_1746 = x_1787; +goto block_1786; +} +else +{ +uint8_t x_1788; +x_1788 = 1; +x_1746 = x_1788; +goto block_1786; +} +block_1786: +{ +if (x_1746 == 0) +{ +lean_object* x_1747; lean_object* x_1748; +lean_dec(x_1); +x_1747 = x_1745; +lean_inc(x_4); +x_1748 = lean_apply_4(x_1747, x_2, x_1739, x_4, x_1738); +if (lean_obj_tag(x_1748) == 0) +{ +lean_object* x_1749; lean_object* x_1750; uint8_t x_1751; +x_1749 = lean_ctor_get(x_1748, 0); +lean_inc(x_1749); +x_1750 = lean_ctor_get(x_1748, 1); +lean_inc(x_1750); +lean_dec(x_1748); +x_1751 = !lean_is_exclusive(x_1749); +if (x_1751 == 0) +{ +lean_object* x_1752; lean_object* x_1753; lean_object* x_1754; +x_1752 = lean_ctor_get(x_1749, 0); +x_1753 = lean_ctor_get(x_1749, 1); +x_1754 = l___private_Lean_Elab_Syntax_2__mkParserSeq(x_1752, x_4, x_1750); +lean_dec(x_4); +lean_dec(x_1752); +if (lean_obj_tag(x_1754) == 0) +{ +uint8_t x_1755; +x_1755 = !lean_is_exclusive(x_1754); +if (x_1755 == 0) +{ +lean_object* x_1756; +x_1756 = lean_ctor_get(x_1754, 0); +lean_ctor_set(x_1749, 0, x_1756); +lean_ctor_set(x_1754, 0, x_1749); +return x_1754; +} +else +{ +lean_object* x_1757; lean_object* x_1758; lean_object* x_1759; +x_1757 = lean_ctor_get(x_1754, 0); +x_1758 = lean_ctor_get(x_1754, 1); +lean_inc(x_1758); +lean_inc(x_1757); +lean_dec(x_1754); +lean_ctor_set(x_1749, 0, x_1757); +x_1759 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1759, 0, x_1749); +lean_ctor_set(x_1759, 1, x_1758); +return x_1759; +} +} +else +{ +uint8_t x_1760; +lean_free_object(x_1749); +lean_dec(x_1753); +x_1760 = !lean_is_exclusive(x_1754); +if (x_1760 == 0) +{ +return x_1754; +} +else +{ +lean_object* x_1761; lean_object* x_1762; lean_object* x_1763; +x_1761 = lean_ctor_get(x_1754, 0); +x_1762 = lean_ctor_get(x_1754, 1); +lean_inc(x_1762); +lean_inc(x_1761); +lean_dec(x_1754); +x_1763 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1763, 0, x_1761); +lean_ctor_set(x_1763, 1, x_1762); +return x_1763; +} +} +} +else +{ +lean_object* x_1764; lean_object* x_1765; lean_object* x_1766; +x_1764 = lean_ctor_get(x_1749, 0); +x_1765 = lean_ctor_get(x_1749, 1); +lean_inc(x_1765); +lean_inc(x_1764); +lean_dec(x_1749); +x_1766 = l___private_Lean_Elab_Syntax_2__mkParserSeq(x_1764, x_4, x_1750); +lean_dec(x_4); +lean_dec(x_1764); +if (lean_obj_tag(x_1766) == 0) +{ +lean_object* x_1767; lean_object* x_1768; lean_object* x_1769; lean_object* x_1770; lean_object* x_1771; +x_1767 = lean_ctor_get(x_1766, 0); +lean_inc(x_1767); +x_1768 = lean_ctor_get(x_1766, 1); +lean_inc(x_1768); +if (lean_is_exclusive(x_1766)) { + lean_ctor_release(x_1766, 0); + lean_ctor_release(x_1766, 1); + x_1769 = x_1766; +} else { + lean_dec_ref(x_1766); + x_1769 = lean_box(0); +} +x_1770 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_1770, 0, x_1767); +lean_ctor_set(x_1770, 1, x_1765); +if (lean_is_scalar(x_1769)) { + x_1771 = lean_alloc_ctor(0, 2, 0); +} else { + x_1771 = x_1769; +} +lean_ctor_set(x_1771, 0, x_1770); +lean_ctor_set(x_1771, 1, x_1768); +return x_1771; +} +else +{ +lean_object* x_1772; lean_object* x_1773; lean_object* x_1774; lean_object* x_1775; +lean_dec(x_1765); +x_1772 = lean_ctor_get(x_1766, 0); +lean_inc(x_1772); +x_1773 = lean_ctor_get(x_1766, 1); +lean_inc(x_1773); +if (lean_is_exclusive(x_1766)) { + lean_ctor_release(x_1766, 0); + lean_ctor_release(x_1766, 1); + x_1774 = x_1766; +} else { + lean_dec_ref(x_1766); + x_1774 = lean_box(0); +} +if (lean_is_scalar(x_1774)) { + x_1775 = lean_alloc_ctor(1, 2, 0); +} else { + x_1775 = x_1774; +} +lean_ctor_set(x_1775, 0, x_1772); +lean_ctor_set(x_1775, 1, x_1773); +return x_1775; +} +} +} +else +{ +uint8_t x_1776; +lean_dec(x_4); +x_1776 = !lean_is_exclusive(x_1748); +if (x_1776 == 0) +{ +return x_1748; +} +else +{ +lean_object* x_1777; lean_object* x_1778; lean_object* x_1779; +x_1777 = lean_ctor_get(x_1748, 0); +x_1778 = lean_ctor_get(x_1748, 1); +lean_inc(x_1778); +lean_inc(x_1777); +lean_dec(x_1748); +x_1779 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1779, 0, x_1777); +lean_ctor_set(x_1779, 1, x_1778); +return x_1779; +} +} +} +else +{ +lean_object* x_1780; lean_object* x_1781; uint8_t x_1782; +lean_dec(x_1745); +lean_dec(x_1739); +lean_dec(x_2); +x_1780 = l_Lean_Elab_Term_toParserDescrAux___main___closed__122; +x_1781 = l_Lean_Elab_Term_throwError___rarg(x_1, x_1780, x_4, x_1738); +lean_dec(x_1); +x_1782 = !lean_is_exclusive(x_1781); +if (x_1782 == 0) +{ +return x_1781; +} +else +{ +lean_object* x_1783; lean_object* x_1784; lean_object* x_1785; +x_1783 = lean_ctor_get(x_1781, 0); +x_1784 = lean_ctor_get(x_1781, 1); +lean_inc(x_1784); +lean_inc(x_1783); +lean_dec(x_1781); +x_1785 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1785, 0, x_1783); +lean_ctor_set(x_1785, 1, x_1784); return x_1785; } -else -{ -lean_object* x_1787; lean_object* x_1788; lean_object* x_1789; -x_1787 = lean_ctor_get(x_1785, 0); -x_1788 = lean_ctor_get(x_1785, 1); -lean_inc(x_1788); -lean_inc(x_1787); -lean_dec(x_1785); -x_1789 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1789, 0, x_1787); -lean_ctor_set(x_1789, 1, x_1788); -return x_1789; +} +} } } else { -lean_object* x_1790; lean_object* x_1791; lean_object* x_1792; lean_object* x_1793; lean_object* x_1794; -lean_dec(x_1); -x_1790 = l_Lean_Elab_Term_getCurrMacroScope(x_4, x_1671); +uint8_t x_1789; +lean_dec(x_1694); lean_dec(x_4); -x_1791 = lean_ctor_get(x_1790, 0); +lean_dec(x_2); +lean_dec(x_1); +x_1789 = !lean_is_exclusive(x_1697); +if (x_1789 == 0) +{ +return x_1697; +} +else +{ +lean_object* x_1790; lean_object* x_1791; lean_object* x_1792; +x_1790 = lean_ctor_get(x_1697, 0); +x_1791 = lean_ctor_get(x_1697, 1); lean_inc(x_1791); -x_1792 = lean_ctor_get(x_1790, 1); -lean_inc(x_1792); -lean_dec(x_1790); -x_1793 = lean_box(x_3); -x_1794 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1794, 0, x_1791); -lean_ctor_set(x_1794, 1, x_1793); -x_1675 = x_1794; -x_1676 = x_1792; -goto block_1777; -} -block_1777: -{ -uint8_t x_1677; -x_1677 = !lean_is_exclusive(x_1675); -if (x_1677 == 0) -{ -lean_object* x_1678; lean_object* x_1679; uint8_t x_1680; -x_1678 = lean_ctor_get(x_1675, 0); -x_1679 = l_Lean_Elab_Term_getMainModule___rarg(x_1676); -x_1680 = !lean_is_exclusive(x_1679); -if (x_1680 == 0) -{ -lean_object* x_1681; lean_object* x_1682; lean_object* x_1683; lean_object* x_1684; lean_object* x_1685; lean_object* x_1686; lean_object* x_1687; lean_object* x_1688; lean_object* x_1689; lean_object* x_1690; lean_object* x_1691; lean_object* x_1692; lean_object* x_1693; lean_object* x_1694; lean_object* x_1695; lean_object* x_1696; lean_object* x_1697; lean_object* x_1698; lean_object* x_1699; lean_object* x_1700; lean_object* x_1701; lean_object* x_1702; lean_object* x_1703; lean_object* x_1704; lean_object* x_1705; lean_object* x_1706; lean_object* x_1707; lean_object* x_1708; lean_object* x_1709; -x_1681 = lean_ctor_get(x_1679, 0); -x_1682 = l_Lean_Elab_Term_toParserDescrAux___main___closed__119; -x_1683 = l_Lean_addMacroScope(x_1681, x_1682, x_1678); -x_1684 = l_Lean_SourceInfo_inhabited___closed__1; -x_1685 = l_Lean_Elab_Term_toParserDescrAux___main___closed__118; -x_1686 = l_Lean_Elab_Term_toParserDescrAux___main___closed__122; -x_1687 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1687, 0, x_1684); -lean_ctor_set(x_1687, 1, x_1685); -lean_ctor_set(x_1687, 2, x_1683); -lean_ctor_set(x_1687, 3, x_1686); -x_1688 = l_Array_empty___closed__1; -x_1689 = lean_array_push(x_1688, x_1687); -x_1690 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1691 = lean_array_push(x_1689, x_1690); -x_1692 = l_Lean_mkTermIdFromIdent___closed__2; -x_1693 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1693, 0, x_1692); -lean_ctor_set(x_1693, 1, x_1691); -x_1694 = lean_array_push(x_1688, x_1693); -x_1695 = l___private_Lean_Syntax_7__quoteName___main(x_1664); -x_1696 = lean_array_push(x_1688, x_1695); -x_1697 = l_Nat_repr(x_1674); -x_1698 = l_Lean_numLitKind; -x_1699 = l_Lean_mkStxLit(x_1698, x_1697, x_1684); -x_1700 = l_Lean_mkOptionalNode___closed__2; -x_1701 = lean_array_push(x_1700, x_1699); -x_1702 = l_Lean_Nat_HasQuote___closed__2; -x_1703 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1703, 0, x_1702); -lean_ctor_set(x_1703, 1, x_1701); -x_1704 = lean_array_push(x_1696, x_1703); -x_1705 = l_Lean_nullKind___closed__2; -x_1706 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1706, 0, x_1705); -lean_ctor_set(x_1706, 1, x_1704); -x_1707 = lean_array_push(x_1694, x_1706); -x_1708 = l_Lean_mkAppStx___closed__8; -x_1709 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1709, 0, x_1708); -lean_ctor_set(x_1709, 1, x_1707); -lean_ctor_set(x_1675, 0, x_1709); -lean_ctor_set(x_1679, 0, x_1675); -return x_1679; -} -else -{ -lean_object* x_1710; lean_object* x_1711; lean_object* x_1712; lean_object* x_1713; lean_object* x_1714; lean_object* x_1715; lean_object* x_1716; lean_object* x_1717; lean_object* x_1718; lean_object* x_1719; lean_object* x_1720; lean_object* x_1721; lean_object* x_1722; lean_object* x_1723; lean_object* x_1724; lean_object* x_1725; lean_object* x_1726; lean_object* x_1727; lean_object* x_1728; lean_object* x_1729; lean_object* x_1730; lean_object* x_1731; lean_object* x_1732; lean_object* x_1733; lean_object* x_1734; lean_object* x_1735; lean_object* x_1736; lean_object* x_1737; lean_object* x_1738; lean_object* x_1739; lean_object* x_1740; -x_1710 = lean_ctor_get(x_1679, 0); -x_1711 = lean_ctor_get(x_1679, 1); -lean_inc(x_1711); -lean_inc(x_1710); -lean_dec(x_1679); -x_1712 = l_Lean_Elab_Term_toParserDescrAux___main___closed__119; -x_1713 = l_Lean_addMacroScope(x_1710, x_1712, x_1678); -x_1714 = l_Lean_SourceInfo_inhabited___closed__1; -x_1715 = l_Lean_Elab_Term_toParserDescrAux___main___closed__118; -x_1716 = l_Lean_Elab_Term_toParserDescrAux___main___closed__122; -x_1717 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1717, 0, x_1714); -lean_ctor_set(x_1717, 1, x_1715); -lean_ctor_set(x_1717, 2, x_1713); -lean_ctor_set(x_1717, 3, x_1716); -x_1718 = l_Array_empty___closed__1; -x_1719 = lean_array_push(x_1718, x_1717); -x_1720 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1721 = lean_array_push(x_1719, x_1720); -x_1722 = l_Lean_mkTermIdFromIdent___closed__2; -x_1723 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1723, 0, x_1722); -lean_ctor_set(x_1723, 1, x_1721); -x_1724 = lean_array_push(x_1718, x_1723); -x_1725 = l___private_Lean_Syntax_7__quoteName___main(x_1664); -x_1726 = lean_array_push(x_1718, x_1725); -x_1727 = l_Nat_repr(x_1674); -x_1728 = l_Lean_numLitKind; -x_1729 = l_Lean_mkStxLit(x_1728, x_1727, x_1714); -x_1730 = l_Lean_mkOptionalNode___closed__2; -x_1731 = lean_array_push(x_1730, x_1729); -x_1732 = l_Lean_Nat_HasQuote___closed__2; -x_1733 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1733, 0, x_1732); -lean_ctor_set(x_1733, 1, x_1731); -x_1734 = lean_array_push(x_1726, x_1733); -x_1735 = l_Lean_nullKind___closed__2; -x_1736 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1736, 0, x_1735); -lean_ctor_set(x_1736, 1, x_1734); -x_1737 = lean_array_push(x_1724, x_1736); -x_1738 = l_Lean_mkAppStx___closed__8; -x_1739 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1739, 0, x_1738); -lean_ctor_set(x_1739, 1, x_1737); -lean_ctor_set(x_1675, 0, x_1739); -x_1740 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1740, 0, x_1675); -lean_ctor_set(x_1740, 1, x_1711); -return x_1740; -} -} -else -{ -lean_object* x_1741; lean_object* x_1742; lean_object* x_1743; lean_object* x_1744; lean_object* x_1745; lean_object* x_1746; lean_object* x_1747; lean_object* x_1748; lean_object* x_1749; lean_object* x_1750; lean_object* x_1751; lean_object* x_1752; lean_object* x_1753; lean_object* x_1754; lean_object* x_1755; lean_object* x_1756; lean_object* x_1757; lean_object* x_1758; lean_object* x_1759; lean_object* x_1760; lean_object* x_1761; lean_object* x_1762; lean_object* x_1763; lean_object* x_1764; lean_object* x_1765; lean_object* x_1766; lean_object* x_1767; lean_object* x_1768; lean_object* x_1769; lean_object* x_1770; lean_object* x_1771; lean_object* x_1772; lean_object* x_1773; lean_object* x_1774; lean_object* x_1775; lean_object* x_1776; -x_1741 = lean_ctor_get(x_1675, 0); -x_1742 = lean_ctor_get(x_1675, 1); -lean_inc(x_1742); -lean_inc(x_1741); -lean_dec(x_1675); -x_1743 = l_Lean_Elab_Term_getMainModule___rarg(x_1676); -x_1744 = lean_ctor_get(x_1743, 0); -lean_inc(x_1744); -x_1745 = lean_ctor_get(x_1743, 1); -lean_inc(x_1745); -if (lean_is_exclusive(x_1743)) { - lean_ctor_release(x_1743, 0); - lean_ctor_release(x_1743, 1); - x_1746 = x_1743; -} else { - lean_dec_ref(x_1743); - x_1746 = lean_box(0); -} -x_1747 = l_Lean_Elab_Term_toParserDescrAux___main___closed__119; -x_1748 = l_Lean_addMacroScope(x_1744, x_1747, x_1741); -x_1749 = l_Lean_SourceInfo_inhabited___closed__1; -x_1750 = l_Lean_Elab_Term_toParserDescrAux___main___closed__118; -x_1751 = l_Lean_Elab_Term_toParserDescrAux___main___closed__122; -x_1752 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_1752, 0, x_1749); -lean_ctor_set(x_1752, 1, x_1750); -lean_ctor_set(x_1752, 2, x_1748); -lean_ctor_set(x_1752, 3, x_1751); -x_1753 = l_Array_empty___closed__1; -x_1754 = lean_array_push(x_1753, x_1752); -x_1755 = l___private_Lean_Elab_Term_5__expandCDot___main___closed__4; -x_1756 = lean_array_push(x_1754, x_1755); -x_1757 = l_Lean_mkTermIdFromIdent___closed__2; -x_1758 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1758, 0, x_1757); -lean_ctor_set(x_1758, 1, x_1756); -x_1759 = lean_array_push(x_1753, x_1758); -x_1760 = l___private_Lean_Syntax_7__quoteName___main(x_1664); -x_1761 = lean_array_push(x_1753, x_1760); -x_1762 = l_Nat_repr(x_1674); -x_1763 = l_Lean_numLitKind; -x_1764 = l_Lean_mkStxLit(x_1763, x_1762, x_1749); -x_1765 = l_Lean_mkOptionalNode___closed__2; -x_1766 = lean_array_push(x_1765, x_1764); -x_1767 = l_Lean_Nat_HasQuote___closed__2; -x_1768 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1768, 0, x_1767); -lean_ctor_set(x_1768, 1, x_1766); -x_1769 = lean_array_push(x_1761, x_1768); -x_1770 = l_Lean_nullKind___closed__2; -x_1771 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1771, 0, x_1770); -lean_ctor_set(x_1771, 1, x_1769); -x_1772 = lean_array_push(x_1759, x_1771); -x_1773 = l_Lean_mkAppStx___closed__8; -x_1774 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1774, 0, x_1773); -lean_ctor_set(x_1774, 1, x_1772); -x_1775 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1775, 0, x_1774); -lean_ctor_set(x_1775, 1, x_1742); -if (lean_is_scalar(x_1746)) { - x_1776 = lean_alloc_ctor(0, 2, 0); -} else { - x_1776 = x_1746; -} -lean_ctor_set(x_1776, 0, x_1775); -lean_ctor_set(x_1776, 1, x_1745); -return x_1776; -} -} -} -} -} -} -} -else -{ -lean_object* x_1812; lean_object* x_1813; -lean_dec(x_6); -x_1812 = lean_unsigned_to_nat(1u); -x_1813 = l_Lean_Syntax_getArg(x_1, x_1812); -lean_dec(x_1); -x_1 = x_1813; -goto _start; -} -} -else -{ -lean_object* x_1815; lean_object* x_1816; -lean_dec(x_6); -x_1815 = lean_unsigned_to_nat(0u); -x_1816 = l_Lean_Syntax_getArg(x_1, x_1815); -lean_dec(x_1); -x_1 = x_1816; -goto _start; -} -} -else -{ -lean_object* x_1818; lean_object* x_1819; lean_object* x_1820; lean_object* x_1821; -lean_dec(x_6); -x_1818 = l_Lean_Syntax_getArgs(x_1); -x_1819 = lean_unsigned_to_nat(0u); -x_1820 = l_Lean_Syntax_getArg(x_1, x_1819); -lean_inc(x_4); -x_1821 = l_Lean_Elab_Term_checkLeftRec(x_1820, x_2, x_3, x_4, x_5); -if (lean_obj_tag(x_1821) == 0) -{ -lean_object* x_1822; lean_object* x_1823; uint8_t x_1824; -x_1822 = lean_ctor_get(x_1821, 0); -lean_inc(x_1822); -x_1823 = lean_ctor_get(x_1822, 0); -lean_inc(x_1823); -x_1824 = lean_unbox(x_1823); -lean_dec(x_1823); -if (x_1824 == 0) -{ -lean_object* x_1825; lean_object* x_1826; lean_object* x_1827; lean_object* x_1828; lean_object* x_1829; lean_object* x_1830; -lean_dec(x_1); -x_1825 = lean_ctor_get(x_1821, 1); -lean_inc(x_1825); -lean_dec(x_1821); -x_1826 = lean_ctor_get(x_1822, 1); -lean_inc(x_1826); -lean_dec(x_1822); -x_1827 = x_1818; -x_1828 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at_Lean_Elab_Term_toParserDescrAux___main___spec__1___boxed), 6, 2); -lean_closure_set(x_1828, 0, x_1819); -lean_closure_set(x_1828, 1, x_1827); -x_1829 = x_1828; -lean_inc(x_4); -x_1830 = lean_apply_4(x_1829, x_2, x_1826, x_4, x_1825); -if (lean_obj_tag(x_1830) == 0) -{ -lean_object* x_1831; lean_object* x_1832; uint8_t x_1833; -x_1831 = lean_ctor_get(x_1830, 0); -lean_inc(x_1831); -x_1832 = lean_ctor_get(x_1830, 1); -lean_inc(x_1832); -lean_dec(x_1830); -x_1833 = !lean_is_exclusive(x_1831); -if (x_1833 == 0) -{ -lean_object* x_1834; lean_object* x_1835; lean_object* x_1836; -x_1834 = lean_ctor_get(x_1831, 0); -x_1835 = lean_ctor_get(x_1831, 1); -x_1836 = l___private_Lean_Elab_Syntax_2__mkParserSeq(x_1834, x_4, x_1832); -lean_dec(x_4); -lean_dec(x_1834); -if (lean_obj_tag(x_1836) == 0) -{ -uint8_t x_1837; -x_1837 = !lean_is_exclusive(x_1836); -if (x_1837 == 0) -{ -lean_object* x_1838; -x_1838 = lean_ctor_get(x_1836, 0); -lean_ctor_set(x_1831, 0, x_1838); -lean_ctor_set(x_1836, 0, x_1831); -return x_1836; -} -else -{ -lean_object* x_1839; lean_object* x_1840; lean_object* x_1841; -x_1839 = lean_ctor_get(x_1836, 0); -x_1840 = lean_ctor_get(x_1836, 1); -lean_inc(x_1840); -lean_inc(x_1839); -lean_dec(x_1836); -lean_ctor_set(x_1831, 0, x_1839); -x_1841 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1841, 0, x_1831); -lean_ctor_set(x_1841, 1, x_1840); -return x_1841; -} -} -else -{ -uint8_t x_1842; -lean_free_object(x_1831); -lean_dec(x_1835); -x_1842 = !lean_is_exclusive(x_1836); -if (x_1842 == 0) -{ -return x_1836; -} -else -{ -lean_object* x_1843; lean_object* x_1844; lean_object* x_1845; -x_1843 = lean_ctor_get(x_1836, 0); -x_1844 = lean_ctor_get(x_1836, 1); -lean_inc(x_1844); -lean_inc(x_1843); -lean_dec(x_1836); -x_1845 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1845, 0, x_1843); -lean_ctor_set(x_1845, 1, x_1844); -return x_1845; -} -} -} -else -{ -lean_object* x_1846; lean_object* x_1847; lean_object* x_1848; -x_1846 = lean_ctor_get(x_1831, 0); -x_1847 = lean_ctor_get(x_1831, 1); -lean_inc(x_1847); -lean_inc(x_1846); -lean_dec(x_1831); -x_1848 = l___private_Lean_Elab_Syntax_2__mkParserSeq(x_1846, x_4, x_1832); -lean_dec(x_4); -lean_dec(x_1846); -if (lean_obj_tag(x_1848) == 0) -{ -lean_object* x_1849; lean_object* x_1850; lean_object* x_1851; lean_object* x_1852; lean_object* x_1853; -x_1849 = lean_ctor_get(x_1848, 0); -lean_inc(x_1849); -x_1850 = lean_ctor_get(x_1848, 1); -lean_inc(x_1850); -if (lean_is_exclusive(x_1848)) { - lean_ctor_release(x_1848, 0); - lean_ctor_release(x_1848, 1); - x_1851 = x_1848; -} else { - lean_dec_ref(x_1848); - x_1851 = lean_box(0); -} -x_1852 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1852, 0, x_1849); -lean_ctor_set(x_1852, 1, x_1847); -if (lean_is_scalar(x_1851)) { - x_1853 = lean_alloc_ctor(0, 2, 0); -} else { - x_1853 = x_1851; -} -lean_ctor_set(x_1853, 0, x_1852); -lean_ctor_set(x_1853, 1, x_1850); -return x_1853; -} -else -{ -lean_object* x_1854; lean_object* x_1855; lean_object* x_1856; lean_object* x_1857; -lean_dec(x_1847); -x_1854 = lean_ctor_get(x_1848, 0); -lean_inc(x_1854); -x_1855 = lean_ctor_get(x_1848, 1); -lean_inc(x_1855); -if (lean_is_exclusive(x_1848)) { - lean_ctor_release(x_1848, 0); - lean_ctor_release(x_1848, 1); - x_1856 = x_1848; -} else { - lean_dec_ref(x_1848); - x_1856 = lean_box(0); -} -if (lean_is_scalar(x_1856)) { - x_1857 = lean_alloc_ctor(1, 2, 0); -} else { - x_1857 = x_1856; -} -lean_ctor_set(x_1857, 0, x_1854); -lean_ctor_set(x_1857, 1, x_1855); -return x_1857; -} -} -} -else -{ -uint8_t x_1858; -lean_dec(x_4); -x_1858 = !lean_is_exclusive(x_1830); -if (x_1858 == 0) -{ -return x_1830; -} -else -{ -lean_object* x_1859; lean_object* x_1860; lean_object* x_1861; -x_1859 = lean_ctor_get(x_1830, 0); -x_1860 = lean_ctor_get(x_1830, 1); -lean_inc(x_1860); -lean_inc(x_1859); -lean_dec(x_1830); -x_1861 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1861, 0, x_1859); -lean_ctor_set(x_1861, 1, x_1860); -return x_1861; -} -} -} -else -{ -lean_object* x_1862; lean_object* x_1863; lean_object* x_1864; lean_object* x_1865; uint8_t x_1866; lean_object* x_1867; lean_object* x_1868; lean_object* x_1869; uint8_t x_1870; -x_1862 = lean_ctor_get(x_1821, 1); -lean_inc(x_1862); -lean_dec(x_1821); -x_1863 = lean_ctor_get(x_1822, 1); -lean_inc(x_1863); -lean_dec(x_1822); -x_1864 = lean_array_get_size(x_1818); -x_1865 = lean_unsigned_to_nat(1u); -x_1866 = lean_nat_dec_eq(x_1864, x_1865); -lean_dec(x_1864); -x_1867 = l_Array_eraseIdx___rarg(x_1818, x_1819); -x_1868 = x_1867; -x_1869 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at_Lean_Elab_Term_toParserDescrAux___main___spec__1___boxed), 6, 2); -lean_closure_set(x_1869, 0, x_1819); -lean_closure_set(x_1869, 1, x_1868); -if (x_1866 == 0) -{ -uint8_t x_1911; -x_1911 = 0; -x_1870 = x_1911; -goto block_1910; -} -else -{ -uint8_t x_1912; -x_1912 = 1; -x_1870 = x_1912; -goto block_1910; -} -block_1910: -{ -if (x_1870 == 0) -{ -lean_object* x_1871; lean_object* x_1872; -lean_dec(x_1); -x_1871 = x_1869; -lean_inc(x_4); -x_1872 = lean_apply_4(x_1871, x_2, x_1863, x_4, x_1862); -if (lean_obj_tag(x_1872) == 0) -{ -lean_object* x_1873; lean_object* x_1874; uint8_t x_1875; -x_1873 = lean_ctor_get(x_1872, 0); -lean_inc(x_1873); -x_1874 = lean_ctor_get(x_1872, 1); -lean_inc(x_1874); -lean_dec(x_1872); -x_1875 = !lean_is_exclusive(x_1873); -if (x_1875 == 0) -{ -lean_object* x_1876; lean_object* x_1877; lean_object* x_1878; -x_1876 = lean_ctor_get(x_1873, 0); -x_1877 = lean_ctor_get(x_1873, 1); -x_1878 = l___private_Lean_Elab_Syntax_2__mkParserSeq(x_1876, x_4, x_1874); -lean_dec(x_4); -lean_dec(x_1876); -if (lean_obj_tag(x_1878) == 0) -{ -uint8_t x_1879; -x_1879 = !lean_is_exclusive(x_1878); -if (x_1879 == 0) -{ -lean_object* x_1880; -x_1880 = lean_ctor_get(x_1878, 0); -lean_ctor_set(x_1873, 0, x_1880); -lean_ctor_set(x_1878, 0, x_1873); -return x_1878; -} -else -{ -lean_object* x_1881; lean_object* x_1882; lean_object* x_1883; -x_1881 = lean_ctor_get(x_1878, 0); -x_1882 = lean_ctor_get(x_1878, 1); -lean_inc(x_1882); -lean_inc(x_1881); -lean_dec(x_1878); -lean_ctor_set(x_1873, 0, x_1881); -x_1883 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1883, 0, x_1873); -lean_ctor_set(x_1883, 1, x_1882); -return x_1883; -} -} -else -{ -uint8_t x_1884; -lean_free_object(x_1873); -lean_dec(x_1877); -x_1884 = !lean_is_exclusive(x_1878); -if (x_1884 == 0) -{ -return x_1878; -} -else -{ -lean_object* x_1885; lean_object* x_1886; lean_object* x_1887; -x_1885 = lean_ctor_get(x_1878, 0); -x_1886 = lean_ctor_get(x_1878, 1); -lean_inc(x_1886); -lean_inc(x_1885); -lean_dec(x_1878); -x_1887 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1887, 0, x_1885); -lean_ctor_set(x_1887, 1, x_1886); -return x_1887; -} -} -} -else -{ -lean_object* x_1888; lean_object* x_1889; lean_object* x_1890; -x_1888 = lean_ctor_get(x_1873, 0); -x_1889 = lean_ctor_get(x_1873, 1); -lean_inc(x_1889); -lean_inc(x_1888); -lean_dec(x_1873); -x_1890 = l___private_Lean_Elab_Syntax_2__mkParserSeq(x_1888, x_4, x_1874); -lean_dec(x_4); -lean_dec(x_1888); -if (lean_obj_tag(x_1890) == 0) -{ -lean_object* x_1891; lean_object* x_1892; lean_object* x_1893; lean_object* x_1894; lean_object* x_1895; -x_1891 = lean_ctor_get(x_1890, 0); -lean_inc(x_1891); -x_1892 = lean_ctor_get(x_1890, 1); -lean_inc(x_1892); -if (lean_is_exclusive(x_1890)) { - lean_ctor_release(x_1890, 0); - lean_ctor_release(x_1890, 1); - x_1893 = x_1890; -} else { - lean_dec_ref(x_1890); - x_1893 = lean_box(0); -} -x_1894 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_1894, 0, x_1891); -lean_ctor_set(x_1894, 1, x_1889); -if (lean_is_scalar(x_1893)) { - x_1895 = lean_alloc_ctor(0, 2, 0); -} else { - x_1895 = x_1893; -} -lean_ctor_set(x_1895, 0, x_1894); -lean_ctor_set(x_1895, 1, x_1892); -return x_1895; -} -else -{ -lean_object* x_1896; lean_object* x_1897; lean_object* x_1898; lean_object* x_1899; -lean_dec(x_1889); -x_1896 = lean_ctor_get(x_1890, 0); -lean_inc(x_1896); -x_1897 = lean_ctor_get(x_1890, 1); -lean_inc(x_1897); -if (lean_is_exclusive(x_1890)) { - lean_ctor_release(x_1890, 0); - lean_ctor_release(x_1890, 1); - x_1898 = x_1890; -} else { - lean_dec_ref(x_1890); - x_1898 = lean_box(0); -} -if (lean_is_scalar(x_1898)) { - x_1899 = lean_alloc_ctor(1, 2, 0); -} else { - x_1899 = x_1898; -} -lean_ctor_set(x_1899, 0, x_1896); -lean_ctor_set(x_1899, 1, x_1897); -return x_1899; -} -} -} -else -{ -uint8_t x_1900; -lean_dec(x_4); -x_1900 = !lean_is_exclusive(x_1872); -if (x_1900 == 0) -{ -return x_1872; -} -else -{ -lean_object* x_1901; lean_object* x_1902; lean_object* x_1903; -x_1901 = lean_ctor_get(x_1872, 0); -x_1902 = lean_ctor_get(x_1872, 1); -lean_inc(x_1902); -lean_inc(x_1901); -lean_dec(x_1872); -x_1903 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1903, 0, x_1901); -lean_ctor_set(x_1903, 1, x_1902); -return x_1903; -} -} -} -else -{ -lean_object* x_1904; lean_object* x_1905; uint8_t x_1906; -lean_dec(x_1869); -lean_dec(x_1863); -lean_dec(x_2); -x_1904 = l_Lean_Elab_Term_toParserDescrAux___main___closed__128; -x_1905 = l_Lean_Elab_Term_throwError___rarg(x_1, x_1904, x_4, x_1862); -lean_dec(x_1); -x_1906 = !lean_is_exclusive(x_1905); -if (x_1906 == 0) -{ -return x_1905; -} -else -{ -lean_object* x_1907; lean_object* x_1908; lean_object* x_1909; -x_1907 = lean_ctor_get(x_1905, 0); -x_1908 = lean_ctor_get(x_1905, 1); -lean_inc(x_1908); -lean_inc(x_1907); -lean_dec(x_1905); -x_1909 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1909, 0, x_1907); -lean_ctor_set(x_1909, 1, x_1908); -return x_1909; -} -} -} -} -} -else -{ -uint8_t x_1913; -lean_dec(x_1818); -lean_dec(x_4); -lean_dec(x_2); -lean_dec(x_1); -x_1913 = !lean_is_exclusive(x_1821); -if (x_1913 == 0) -{ -return x_1821; -} -else -{ -lean_object* x_1914; lean_object* x_1915; lean_object* x_1916; -x_1914 = lean_ctor_get(x_1821, 0); -x_1915 = lean_ctor_get(x_1821, 1); -lean_inc(x_1915); -lean_inc(x_1914); -lean_dec(x_1821); -x_1916 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_1916, 0, x_1914); -lean_ctor_set(x_1916, 1, x_1915); -return x_1916; +lean_inc(x_1790); +lean_dec(x_1697); +x_1792 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1792, 0, x_1790); +lean_ctor_set(x_1792, 1, x_1791); +return x_1792; } } } @@ -8550,7 +8287,7 @@ x_383 = l_Lean_Syntax_getArg(x_1, x_7); lean_dec(x_1); x_384 = lean_alloc_ctor(4, 1, 0); lean_ctor_set(x_384, 0, x_9); -x_385 = l_Lean_Elab_Term_toParserDescrAux___main___closed__125; +x_385 = l_Lean_Elab_Term_toParserDescrAux___main___closed__119; x_386 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_386, 0, x_385); lean_ctor_set(x_386, 1, x_384); @@ -12642,7 +12379,7 @@ lean_object* _init_l___private_Lean_Elab_Syntax_7__antiquote___main___closed__1( _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_currLbp___closed__1; +x_1 = l_Lean_Parser_dollarSymbol___elambda__1___closed__1; x_2 = l_Lean_mkAtom(x_1); return x_2; } @@ -15076,6 +14813,8 @@ lean_dec_ref(res); res = initialize_Lean_Elab_Quotation(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); +l___private_Lean_Elab_Syntax_1__expandOptPrecedence___closed__1 = _init_l___private_Lean_Elab_Syntax_1__expandOptPrecedence___closed__1(); +lean_mark_persistent(l___private_Lean_Elab_Syntax_1__expandOptPrecedence___closed__1); l_Array_iterateMAux___main___at___private_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__1 = _init_l_Array_iterateMAux___main___at___private_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__1(); lean_mark_persistent(l_Array_iterateMAux___main___at___private_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__1); l_Array_iterateMAux___main___at___private_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__2 = _init_l_Array_iterateMAux___main___at___private_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__2(); @@ -15358,18 +15097,6 @@ l_Lean_Elab_Term_toParserDescrAux___main___closed__121 = _init_l_Lean_Elab_Term_ lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___main___closed__121); l_Lean_Elab_Term_toParserDescrAux___main___closed__122 = _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__122(); lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___main___closed__122); -l_Lean_Elab_Term_toParserDescrAux___main___closed__123 = _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__123(); -lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___main___closed__123); -l_Lean_Elab_Term_toParserDescrAux___main___closed__124 = _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__124(); -lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___main___closed__124); -l_Lean_Elab_Term_toParserDescrAux___main___closed__125 = _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__125(); -lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___main___closed__125); -l_Lean_Elab_Term_toParserDescrAux___main___closed__126 = _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__126(); -lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___main___closed__126); -l_Lean_Elab_Term_toParserDescrAux___main___closed__127 = _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__127(); -lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___main___closed__127); -l_Lean_Elab_Term_toParserDescrAux___main___closed__128 = _init_l_Lean_Elab_Term_toParserDescrAux___main___closed__128(); -lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___main___closed__128); l___regBuiltin_Lean_Elab_Command_elabDeclareSyntaxCat___closed__1 = _init_l___regBuiltin_Lean_Elab_Command_elabDeclareSyntaxCat___closed__1(); lean_mark_persistent(l___regBuiltin_Lean_Elab_Command_elabDeclareSyntaxCat___closed__1); res = l___regBuiltin_Lean_Elab_Command_elabDeclareSyntaxCat(lean_io_mk_world()); diff --git a/stage0/stdlib/Lean/Parser/Command.c b/stage0/stdlib/Lean/Parser/Command.c index 31bc29d242..9ad39e1146 100644 --- a/stage0/stdlib/Lean/Parser/Command.c +++ b/stage0/stdlib/Lean/Parser/Command.c @@ -24,7 +24,6 @@ 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_structCtor___closed__8; 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; @@ -173,6 +172,7 @@ lean_object* l_Lean_Parser_Command_axiom___closed__6; lean_object* l_Lean_Parser_Command_declValEqns___elambda__1___closed__4; lean_object* l_Lean_Parser_Command_theorem___closed__5; lean_object* l_Lean_Parser_Command_inferMod___closed__2; +lean_object* l_Lean_Parser_checkRbpLtFn(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Command_abbrev___closed__5; lean_object* l_Lean_Parser_Command_section___closed__1; lean_object* l_Lean_Parser_Command_example___closed__6; @@ -413,6 +413,7 @@ lean_object* l_Lean_Parser_Command_declModifiers___closed__5; lean_object* l_Lean_Parser_Command_structureTk___closed__1; lean_object* l_Lean_Parser_Command_init__quot___closed__1; lean_object* l_Lean_Parser_Command_inductive___elambda__1___closed__6; +extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__7; lean_object* l_Lean_Parser_Command_universes___closed__1; lean_object* lean_nat_sub(lean_object*, lean_object*); lean_object* l_Lean_Parser_Command_docComment___elambda__1___closed__6; @@ -455,6 +456,7 @@ 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* l_Lean_Parser_Term_stxQuot___closed__10; lean_object* l_Lean_Parser_Command_universes___elambda__1___closed__6; lean_object* l_Lean_Parser_Command_structExplicitBinder; lean_object* l_Lean_Parser_Command_inferMod___elambda__1___closed__2; @@ -478,7 +480,6 @@ lean_object* l_Lean_Parser_Command_attrArg; extern lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; lean_object* l_Lean_Parser_Command_variables___closed__4; extern lean_object* l_Lean_Parser_Term_structInstArrayRef___closed__1; -extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__4; lean_object* l_Lean_Parser_Command_protected___elambda__1___closed__5; lean_object* l_Lean_Parser_Command_set__option___elambda__1___closed__15; lean_object* l_Lean_Parser_Command_openSimple___closed__3; @@ -780,6 +781,7 @@ lean_object* l_Lean_Parser_Command_structFields___closed__2; lean_object* l_Lean_Parser_Command_attribute___closed__2; lean_object* l_Lean_Parser_Command_synth___closed__4; lean_object* l_Lean_Parser_Command_exit___elambda__1___closed__7; +extern lean_object* l___private_Lean_Parser_Parser_10__precErrorMsg; lean_object* l_Lean_Parser_Command_resolve__name___closed__6; lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Command_attributes___elambda__1___closed__9; @@ -838,7 +840,7 @@ lean_object* l_Lean_Parser_Command_theorem___closed__4; lean_object* l_Lean_Parser_Command_unsafe___elambda__1___closed__6; lean_object* l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__10; lean_object* l_Lean_Parser_Command_openSimple___closed__2; -lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolInfo(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*); @@ -846,6 +848,7 @@ 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; lean_object* l_Lean_Parser_Command_structCtor___elambda__1___closed__7; +extern lean_object* l_Lean_Parser_epsilonInfo; lean_object* l_Lean_Parser_Command_introRule___closed__2; lean_object* l_Lean_Parser_Command_def___closed__1; lean_object* l_Lean_Parser_Command_attrInstance___closed__3; @@ -1032,14 +1035,13 @@ lean_object* l_Lean_Parser_manyAux___main___at_Lean_Parser_Command_structExplici 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; -lean_object* l_Lean_Parser_unicodeSymbolInfo(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Parser_unicodeSymbolInfo(lean_object*, lean_object*); lean_object* l_Lean_Parser_Command_init__quot; lean_object* l_Lean_Parser_Command_openRenaming___closed__6; lean_object* l_Lean_Parser_Command_axiom___elambda__1___closed__5; lean_object* l_Lean_Parser_Command_openHiding___elambda__1___closed__4; lean_object* l_Lean_Parser_Command_axiom; lean_object* l_Lean_Parser_Command_exit___closed__2; -extern lean_object* l_Lean_Syntax_decodeNatLitVal___closed__1; lean_object* l_Lean_Parser_Command_openOnly___closed__4; lean_object* l_Lean_Parser_Command_noncomputable___closed__2; lean_object* l_Lean_Parser_Command_theorem___elambda__1___closed__3; @@ -1386,623 +1388,656 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_35; lean_object* x_75; lean_object* x_76; lean_object* x_77; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_75 = lean_ctor_get(x_2, 1); -lean_inc(x_75); -lean_inc(x_1); -x_76 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_78 = lean_ctor_get(x_76, 0); -lean_inc(x_78); -x_79 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_Term_stxQuot___elambda__1___closed__4; -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_Term_stxQuot___elambda__1___closed__7; -x_84 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_83, x_75); -x_35 = x_84; -goto block_74; -} -else -{ -lean_dec(x_75); -x_35 = x_76; -goto block_74; -} -} -else -{ -lean_object* x_85; lean_object* x_86; -lean_dec(x_79); -x_85 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; -x_86 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_85, x_75); -x_35 = x_86; -goto block_74; -} -} -else -{ -lean_object* x_87; lean_object* x_88; -lean_dec(x_77); -x_87 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; -x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_87, x_75); -x_35 = x_88; -goto block_74; -} -block_34: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; -x_10 = lean_ctor_get(x_8, 1); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_39; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_10 = lean_ctor_get(x_8, 0); 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_Lean_Parser_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_Lean_Parser_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_7); -return x_21; -} -else -{ -lean_object* x_22; lean_object* x_23; +x_11 = lean_array_get_size(x_10); lean_dec(x_10); -x_22 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_11, x_22, x_7); -return x_23; +x_79 = lean_ctor_get(x_8, 1); +lean_inc(x_79); +lean_inc(x_1); +x_80 = l_Lean_Parser_tokenFn(x_1, x_8); +x_81 = lean_ctor_get(x_80, 3); +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_checkStackTopFn___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_Lean_Parser_Term_stxQuot___elambda__1___closed__4; +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_Term_stxQuot___elambda__1___closed__7; +x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_87, x_79); +x_39 = x_88; +goto block_78; +} +else +{ +lean_dec(x_79); +x_39 = x_80; +goto block_78; } } else { -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_object* x_89; lean_object* x_90; +lean_dec(x_83); +x_89 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; +x_90 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_89, x_79); +x_39 = x_90; +goto block_78; +} +} +else +{ +lean_object* x_91; lean_object* x_92; +lean_dec(x_81); +x_91 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; +x_92 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_91, x_79); +x_39 = x_92; +goto block_78; +} +block_38: +{ +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; +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +x_15 = l_Lean_Parser_tokenFn(x_1, 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_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); +lean_dec(x_18); +x_20 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; +x_21 = lean_string_dec_eq(x_19, x_20); +lean_dec(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); +x_24 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_11); +return x_25; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_dec(x_14); -x_24 = l_Lean_Parser_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_7); +x_27 = l_Lean_Parser_ParserState_mkNode(x_15, x_26, x_11); return x_27; } } else { lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_12); +lean_dec(x_18); x_28 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_28, x_10); +x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_28, x_14); x_30 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_7); +x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_11); return x_31; } } else { -lean_object* x_32; lean_object* x_33; -lean_dec(x_9); +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_dec(x_16); +x_32 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_32, x_14); +x_34 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_11); +return x_35; +} +} +else +{ +lean_object* x_36; lean_object* x_37; +lean_dec(x_13); lean_dec(x_1); -x_32 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_33 = l_Lean_Parser_ParserState_mkNode(x_8, x_32, x_7); -return x_33; +x_36 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_37 = l_Lean_Parser_ParserState_mkNode(x_12, x_36, x_11); +return x_37; } } -block_74: +block_78: { -lean_object* x_36; -x_36 = lean_ctor_get(x_35, 3); -lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) +lean_object* x_40; +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { -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; -x_37 = lean_ctor_get(x_35, 0); -lean_inc(x_37); -x_38 = lean_array_get_size(x_37); -lean_dec(x_37); -x_39 = lean_ctor_get(x_35, 1); -lean_inc(x_39); -x_40 = l_Lean_Parser_termParser___closed__2; -x_41 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_42 = l_Lean_Parser_categoryParser___elambda__1(x_40, x_41, x_1, x_35); -x_43 = lean_ctor_get(x_42, 3); +lean_object* x_41; 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_41 = lean_ctor_get(x_39, 0); +lean_inc(x_41); +x_42 = lean_array_get_size(x_41); +lean_dec(x_41); +x_43 = lean_ctor_get(x_39, 1); lean_inc(x_43); -if (lean_obj_tag(x_43) == 0) +x_44 = l_Lean_Parser_termParser___closed__2; +x_45 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_46 = l_Lean_Parser_categoryParser___elambda__1(x_44, x_45, x_1, x_39); +x_47 = lean_ctor_get(x_46, 3); +lean_inc(x_47); +if (lean_obj_tag(x_47) == 0) { -lean_dec(x_39); -lean_dec(x_38); -x_8 = x_42; -goto block_34; -} -else -{ -lean_object* x_44; lean_object* x_45; uint8_t x_46; -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); lean_dec(x_43); -x_45 = lean_ctor_get(x_42, 1); -lean_inc(x_45); -x_46 = lean_nat_dec_eq(x_45, x_39); -lean_dec(x_45); -if (x_46 == 0) -{ -lean_dec(x_44); -lean_dec(x_39); -lean_dec(x_38); -x_8 = x_42; -goto block_34; +lean_dec(x_42); +x_12 = x_46; +goto block_38; } else { -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_39); -x_47 = l_Lean_Parser_ParserState_restore(x_42, x_38, x_39); -lean_dec(x_38); +lean_object* x_48; lean_object* x_49; uint8_t x_50; x_48 = lean_ctor_get(x_47, 0); lean_inc(x_48); -x_49 = lean_array_get_size(x_48); +lean_dec(x_47); +x_49 = lean_ctor_get(x_46, 1); +lean_inc(x_49); +x_50 = lean_nat_dec_eq(x_49, x_43); +lean_dec(x_49); +if (x_50 == 0) +{ lean_dec(x_48); -x_50 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4; -lean_inc(x_1); -x_51 = l_Lean_Parser_categoryParser___elambda__1(x_50, x_41, x_1, x_47); -x_52 = lean_ctor_get(x_51, 3); +lean_dec(x_43); +lean_dec(x_42); +x_12 = x_46; +goto block_38; +} +else +{ +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_inc(x_43); +x_51 = l_Lean_Parser_ParserState_restore(x_46, x_42, x_43); +lean_dec(x_42); +x_52 = lean_ctor_get(x_51, 0); 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; uint8_t x_58; -lean_inc(x_1); -x_53 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(x_1, x_51); -x_54 = lean_ctor_get(x_53, 0); -lean_inc(x_54); -x_55 = lean_array_get_size(x_54); -lean_dec(x_54); -x_56 = lean_nat_sub(x_55, x_49); -lean_dec(x_55); -x_57 = lean_unsigned_to_nat(1u); -x_58 = lean_nat_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; -x_59 = l_Lean_nullKind; -x_60 = l_Lean_Parser_ParserState_mkNode(x_53, x_59, x_49); -x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_44, x_39); -lean_dec(x_39); -x_8 = x_61; -goto block_34; -} -else -{ -lean_object* x_62; -lean_dec(x_49); -x_62 = l_Lean_Parser_mergeOrElseErrors(x_53, x_44, x_39); -lean_dec(x_39); -x_8 = x_62; -goto block_34; -} -} -else -{ -lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; +x_53 = lean_array_get_size(x_52); lean_dec(x_52); -x_63 = lean_ctor_get(x_51, 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_49); -lean_dec(x_64); -x_66 = lean_unsigned_to_nat(1u); -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; lean_object* x_70; -x_68 = l_Lean_nullKind; -x_69 = l_Lean_Parser_ParserState_mkNode(x_51, x_68, x_49); -x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_44, x_39); -lean_dec(x_39); -x_8 = x_70; -goto block_34; -} -else -{ -lean_object* x_71; -lean_dec(x_49); -x_71 = l_Lean_Parser_mergeOrElseErrors(x_51, x_44, x_39); -lean_dec(x_39); -x_8 = x_71; -goto block_34; -} -} -} -} -} -else -{ -lean_object* x_72; lean_object* x_73; -lean_dec(x_36); -lean_dec(x_1); -x_72 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_73 = l_Lean_Parser_ParserState_mkNode(x_35, x_72, x_7); -return x_73; -} -} -} -else -{ -lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; -x_89 = lean_ctor_get(x_2, 0); -lean_inc(x_89); -x_90 = lean_array_get_size(x_89); -lean_dec(x_89); -x_91 = lean_ctor_get(x_2, 1); -lean_inc(x_91); +x_54 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4; lean_inc(x_1); -x_92 = lean_apply_2(x_4, x_1, x_2); -x_93 = lean_ctor_get(x_92, 3); +x_55 = l_Lean_Parser_categoryParser___elambda__1(x_54, x_45, x_1, x_51); +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_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; +lean_inc(x_1); +x_57 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(x_1, x_55); +x_58 = lean_ctor_get(x_57, 0); +lean_inc(x_58); +x_59 = lean_array_get_size(x_58); +lean_dec(x_58); +x_60 = lean_nat_sub(x_59, x_53); +lean_dec(x_59); +x_61 = lean_unsigned_to_nat(1u); +x_62 = lean_nat_dec_eq(x_60, x_61); +lean_dec(x_60); +if (x_62 == 0) +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = l_Lean_nullKind; +x_64 = l_Lean_Parser_ParserState_mkNode(x_57, x_63, x_53); +x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_48, x_43); +lean_dec(x_43); +x_12 = x_65; +goto block_38; +} +else +{ +lean_object* x_66; +lean_dec(x_53); +x_66 = l_Lean_Parser_mergeOrElseErrors(x_57, x_48, x_43); +lean_dec(x_43); +x_12 = x_66; +goto block_38; +} +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; +lean_dec(x_56); +x_67 = lean_ctor_get(x_55, 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_53); +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_55, x_72, x_53); +x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_48, x_43); +lean_dec(x_43); +x_12 = x_74; +goto block_38; +} +else +{ +lean_object* x_75; +lean_dec(x_53); +x_75 = l_Lean_Parser_mergeOrElseErrors(x_55, x_48, x_43); +lean_dec(x_43); +x_12 = x_75; +goto block_38; +} +} +} +} +} +else +{ +lean_object* x_76; lean_object* x_77; +lean_dec(x_40); +lean_dec(x_1); +x_76 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_77 = l_Lean_Parser_ParserState_mkNode(x_39, x_76, x_11); +return x_77; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_93 = lean_ctor_get(x_2, 0); lean_inc(x_93); -if (lean_obj_tag(x_93) == 0) -{ -lean_dec(x_91); -lean_dec(x_90); -lean_dec(x_1); -return x_92; -} -else -{ -lean_object* x_94; lean_object* x_95; uint8_t x_96; -x_94 = lean_ctor_get(x_93, 0); -lean_inc(x_94); +x_94 = lean_array_get_size(x_93); lean_dec(x_93); -x_95 = lean_ctor_get(x_92, 1); +x_95 = lean_ctor_get(x_2, 1); lean_inc(x_95); -x_96 = lean_nat_dec_eq(x_95, x_91); -lean_dec(x_95); -if (x_96 == 0) +lean_inc(x_1); +x_96 = lean_apply_2(x_4, x_1, x_2); +x_97 = lean_ctor_get(x_96, 3); +lean_inc(x_97); +if (lean_obj_tag(x_97) == 0) { +lean_dec(x_95); lean_dec(x_94); -lean_dec(x_91); -lean_dec(x_90); lean_dec(x_1); -return x_92; +return x_96; } else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_132; lean_object* x_173; lean_object* x_174; -lean_inc(x_91); -x_97 = l_Lean_Parser_ParserState_restore(x_92, x_90, x_91); -lean_dec(x_90); +lean_object* x_98; lean_object* x_99; uint8_t x_100; x_98 = lean_ctor_get(x_97, 0); lean_inc(x_98); -x_99 = lean_array_get_size(x_98); +lean_dec(x_97); +x_99 = lean_ctor_get(x_96, 1); +lean_inc(x_99); +x_100 = lean_nat_dec_eq(x_99, x_95); +lean_dec(x_99); +if (x_100 == 0) +{ lean_dec(x_98); +lean_dec(x_95); +lean_dec(x_94); +lean_dec(x_1); +return x_96; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; +lean_inc(x_95); +x_101 = l_Lean_Parser_ParserState_restore(x_96, x_94, x_95); +lean_dec(x_94); +x_102 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_103 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_104 = l_Lean_Parser_checkRbpLtFn(x_102, x_103, x_1, x_101); +x_105 = lean_ctor_get(x_104, 3); +lean_inc(x_105); +if (lean_obj_tag(x_105) == 0) +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_140; lean_object* x_181; lean_object* x_182; lean_object* x_183; +x_106 = lean_ctor_get(x_104, 0); +lean_inc(x_106); +x_107 = lean_array_get_size(x_106); +lean_dec(x_106); +x_181 = lean_ctor_get(x_104, 1); +lean_inc(x_181); lean_inc(x_1); -x_173 = l_Lean_Parser_tokenFn(x_1, x_97); -x_174 = lean_ctor_get(x_173, 3); -lean_inc(x_174); -if (lean_obj_tag(x_174) == 0) -{ -lean_object* x_175; lean_object* x_176; -x_175 = lean_ctor_get(x_173, 0); -lean_inc(x_175); -x_176 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_175); -lean_dec(x_175); -if (lean_obj_tag(x_176) == 2) -{ -lean_object* x_177; lean_object* x_178; uint8_t x_179; -x_177 = lean_ctor_get(x_176, 1); -lean_inc(x_177); -lean_dec(x_176); -x_178 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__4; -x_179 = lean_string_dec_eq(x_177, x_178); -lean_dec(x_177); -if (x_179 == 0) -{ -lean_object* x_180; lean_object* x_181; -x_180 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; -lean_inc(x_91); -x_181 = l_Lean_Parser_ParserState_mkErrorsAt(x_173, x_180, x_91); -x_132 = x_181; -goto block_172; -} -else -{ -x_132 = x_173; -goto block_172; -} -} -else -{ -lean_object* x_182; lean_object* x_183; -lean_dec(x_176); -x_182 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; -lean_inc(x_91); -x_183 = l_Lean_Parser_ParserState_mkErrorsAt(x_173, x_182, x_91); -x_132 = x_183; -goto block_172; -} -} -else +x_182 = l_Lean_Parser_tokenFn(x_1, x_104); +x_183 = lean_ctor_get(x_182, 3); +lean_inc(x_183); +if (lean_obj_tag(x_183) == 0) { lean_object* x_184; lean_object* x_185; -lean_dec(x_174); -x_184 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; -lean_inc(x_91); -x_185 = l_Lean_Parser_ParserState_mkErrorsAt(x_173, x_184, x_91); -x_132 = x_185; -goto block_172; -} -block_131: +x_184 = lean_ctor_get(x_182, 0); +lean_inc(x_184); +x_185 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_184); +lean_dec(x_184); +if (lean_obj_tag(x_185) == 2) { -lean_object* x_101; -x_101 = lean_ctor_get(x_100, 3); -lean_inc(x_101); -if (lean_obj_tag(x_101) == 0) +lean_object* x_186; lean_object* x_187; uint8_t x_188; +x_186 = lean_ctor_get(x_185, 1); +lean_inc(x_186); +lean_dec(x_185); +x_187 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__4; +x_188 = lean_string_dec_eq(x_186, x_187); +lean_dec(x_186); +if (x_188 == 0) { -lean_object* x_102; lean_object* x_103; lean_object* x_104; -x_102 = lean_ctor_get(x_100, 1); -lean_inc(x_102); -x_103 = l_Lean_Parser_tokenFn(x_1, x_100); -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; -x_105 = lean_ctor_get(x_103, 0); -lean_inc(x_105); -x_106 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -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; lean_object* x_112; lean_object* x_113; lean_object* x_114; -x_110 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_110, x_102); -x_112 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_113 = l_Lean_Parser_ParserState_mkNode(x_111, x_112, x_99); -x_114 = l_Lean_Parser_mergeOrElseErrors(x_113, x_94, x_91); -lean_dec(x_91); -return x_114; +lean_object* x_189; lean_object* x_190; +x_189 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; +x_190 = l_Lean_Parser_ParserState_mkErrorsAt(x_182, x_189, x_181); +x_140 = x_190; +goto block_180; } else { -lean_object* x_115; lean_object* x_116; lean_object* x_117; -lean_dec(x_102); -x_115 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_116 = l_Lean_Parser_ParserState_mkNode(x_103, x_115, x_99); -x_117 = l_Lean_Parser_mergeOrElseErrors(x_116, x_94, x_91); -lean_dec(x_91); -return x_117; +lean_dec(x_181); +x_140 = x_182; +goto block_180; } } else { +lean_object* x_191; lean_object* x_192; +lean_dec(x_185); +x_191 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; +x_192 = l_Lean_Parser_ParserState_mkErrorsAt(x_182, x_191, x_181); +x_140 = x_192; +goto block_180; +} +} +else +{ +lean_object* x_193; lean_object* x_194; +lean_dec(x_183); +x_193 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__7; +x_194 = l_Lean_Parser_ParserState_mkErrorsAt(x_182, x_193, x_181); +x_140 = x_194; +goto block_180; +} +block_139: +{ +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_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_108, 1); +lean_inc(x_110); +x_111 = l_Lean_Parser_tokenFn(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; +x_113 = lean_ctor_get(x_111, 0); +lean_inc(x_113); +x_114 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_113); +lean_dec(x_113); +if (lean_obj_tag(x_114) == 2) +{ +lean_object* x_115; lean_object* x_116; uint8_t x_117; +x_115 = lean_ctor_get(x_114, 1); +lean_inc(x_115); +lean_dec(x_114); +x_116 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; +x_117 = lean_string_dec_eq(x_115, x_116); +lean_dec(x_115); +if (x_117 == 0) +{ lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; -lean_dec(x_106); x_118 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_119 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_118, x_102); +x_119 = l_Lean_Parser_ParserState_mkErrorsAt(x_111, x_118, x_110); x_120 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_121 = l_Lean_Parser_ParserState_mkNode(x_119, x_120, x_99); -x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_94, x_91); -lean_dec(x_91); +x_121 = l_Lean_Parser_ParserState_mkNode(x_119, x_120, x_107); +x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_98, x_95); +lean_dec(x_95); return x_122; } -} else { -lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; -lean_dec(x_104); -x_123 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_123, x_102); -x_125 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_126 = l_Lean_Parser_ParserState_mkNode(x_124, x_125, x_99); -x_127 = l_Lean_Parser_mergeOrElseErrors(x_126, x_94, x_91); -lean_dec(x_91); -return x_127; +lean_object* x_123; lean_object* x_124; lean_object* x_125; +lean_dec(x_110); +x_123 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_124 = l_Lean_Parser_ParserState_mkNode(x_111, x_123, x_107); +x_125 = l_Lean_Parser_mergeOrElseErrors(x_124, x_98, x_95); +lean_dec(x_95); +return x_125; } } else { -lean_object* x_128; lean_object* x_129; lean_object* x_130; -lean_dec(x_101); -lean_dec(x_1); +lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_114); +x_126 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_127 = l_Lean_Parser_ParserState_mkErrorsAt(x_111, x_126, x_110); x_128 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_129 = l_Lean_Parser_ParserState_mkNode(x_100, x_128, x_99); -x_130 = l_Lean_Parser_mergeOrElseErrors(x_129, x_94, x_91); -lean_dec(x_91); +x_129 = l_Lean_Parser_ParserState_mkNode(x_127, x_128, x_107); +x_130 = l_Lean_Parser_mergeOrElseErrors(x_129, x_98, x_95); +lean_dec(x_95); return x_130; } } -block_172: -{ -lean_object* x_133; -x_133 = lean_ctor_get(x_132, 3); -lean_inc(x_133); -if (lean_obj_tag(x_133) == 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_132, 0); -lean_inc(x_134); -x_135 = lean_array_get_size(x_134); -lean_dec(x_134); -x_136 = lean_ctor_get(x_132, 1); -lean_inc(x_136); -x_137 = l_Lean_Parser_termParser___closed__2; -x_138 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_139 = l_Lean_Parser_categoryParser___elambda__1(x_137, x_138, x_1, x_132); -x_140 = lean_ctor_get(x_139, 3); -lean_inc(x_140); -if (lean_obj_tag(x_140) == 0) -{ -lean_dec(x_136); -lean_dec(x_135); -x_100 = x_139; -goto block_131; -} else { -lean_object* x_141; lean_object* x_142; uint8_t x_143; -x_141 = lean_ctor_get(x_140, 0); -lean_inc(x_141); -lean_dec(x_140); -x_142 = lean_ctor_get(x_139, 1); -lean_inc(x_142); -x_143 = lean_nat_dec_eq(x_142, x_136); -lean_dec(x_142); -if (x_143 == 0) -{ -lean_dec(x_141); -lean_dec(x_136); -lean_dec(x_135); -x_100 = x_139; -goto block_131; -} -else -{ -lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; -lean_inc(x_136); -x_144 = l_Lean_Parser_ParserState_restore(x_139, x_135, x_136); -lean_dec(x_135); -x_145 = lean_ctor_get(x_144, 0); -lean_inc(x_145); -x_146 = lean_array_get_size(x_145); -lean_dec(x_145); -x_147 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4; -lean_inc(x_1); -x_148 = l_Lean_Parser_categoryParser___elambda__1(x_147, x_138, x_1, x_144); -x_149 = lean_ctor_get(x_148, 3); -lean_inc(x_149); -if (lean_obj_tag(x_149) == 0) -{ -lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; uint8_t x_155; -lean_inc(x_1); -x_150 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(x_1, x_148); -x_151 = lean_ctor_get(x_150, 0); -lean_inc(x_151); -x_152 = lean_array_get_size(x_151); -lean_dec(x_151); -x_153 = lean_nat_sub(x_152, x_146); -lean_dec(x_152); -x_154 = lean_unsigned_to_nat(1u); -x_155 = lean_nat_dec_eq(x_153, x_154); -lean_dec(x_153); -if (x_155 == 0) -{ -lean_object* x_156; lean_object* x_157; lean_object* x_158; -x_156 = l_Lean_nullKind; -x_157 = l_Lean_Parser_ParserState_mkNode(x_150, x_156, x_146); -x_158 = l_Lean_Parser_mergeOrElseErrors(x_157, x_141, x_136); -lean_dec(x_136); -x_100 = x_158; -goto block_131; -} -else -{ -lean_object* x_159; -lean_dec(x_146); -x_159 = l_Lean_Parser_mergeOrElseErrors(x_150, x_141, x_136); -lean_dec(x_136); -x_100 = x_159; -goto block_131; +lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; +lean_dec(x_112); +x_131 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_132 = l_Lean_Parser_ParserState_mkErrorsAt(x_111, x_131, x_110); +x_133 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_134 = l_Lean_Parser_ParserState_mkNode(x_132, x_133, x_107); +x_135 = l_Lean_Parser_mergeOrElseErrors(x_134, x_98, x_95); +lean_dec(x_95); +return x_135; } } else { -lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; uint8_t x_164; -lean_dec(x_149); -x_160 = lean_ctor_get(x_148, 0); -lean_inc(x_160); -x_161 = lean_array_get_size(x_160); -lean_dec(x_160); -x_162 = lean_nat_sub(x_161, x_146); -lean_dec(x_161); -x_163 = lean_unsigned_to_nat(1u); -x_164 = lean_nat_dec_eq(x_162, x_163); -lean_dec(x_162); -if (x_164 == 0) -{ -lean_object* x_165; lean_object* x_166; lean_object* x_167; -x_165 = l_Lean_nullKind; -x_166 = l_Lean_Parser_ParserState_mkNode(x_148, x_165, x_146); -x_167 = l_Lean_Parser_mergeOrElseErrors(x_166, x_141, x_136); -lean_dec(x_136); -x_100 = x_167; -goto block_131; -} -else -{ -lean_object* x_168; -lean_dec(x_146); -x_168 = l_Lean_Parser_mergeOrElseErrors(x_148, x_141, x_136); -lean_dec(x_136); -x_100 = x_168; -goto block_131; -} -} -} -} -} -else -{ -lean_object* x_169; lean_object* x_170; lean_object* x_171; -lean_dec(x_133); +lean_object* x_136; lean_object* x_137; lean_object* x_138; +lean_dec(x_109); lean_dec(x_1); -x_169 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_170 = l_Lean_Parser_ParserState_mkNode(x_132, x_169, x_99); -x_171 = l_Lean_Parser_mergeOrElseErrors(x_170, x_94, x_91); -lean_dec(x_91); -return x_171; +x_136 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_137 = l_Lean_Parser_ParserState_mkNode(x_108, x_136, x_107); +x_138 = l_Lean_Parser_mergeOrElseErrors(x_137, x_98, x_95); +lean_dec(x_95); +return x_138; } } +block_180: +{ +lean_object* x_141; +x_141 = lean_ctor_get(x_140, 3); +lean_inc(x_141); +if (lean_obj_tag(x_141) == 0) +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; +x_142 = lean_ctor_get(x_140, 0); +lean_inc(x_142); +x_143 = lean_array_get_size(x_142); +lean_dec(x_142); +x_144 = lean_ctor_get(x_140, 1); +lean_inc(x_144); +x_145 = l_Lean_Parser_termParser___closed__2; +x_146 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_147 = l_Lean_Parser_categoryParser___elambda__1(x_145, x_146, x_1, x_140); +x_148 = lean_ctor_get(x_147, 3); +lean_inc(x_148); +if (lean_obj_tag(x_148) == 0) +{ +lean_dec(x_144); +lean_dec(x_143); +x_108 = x_147; +goto block_139; +} +else +{ +lean_object* x_149; lean_object* x_150; uint8_t x_151; +x_149 = lean_ctor_get(x_148, 0); +lean_inc(x_149); +lean_dec(x_148); +x_150 = lean_ctor_get(x_147, 1); +lean_inc(x_150); +x_151 = lean_nat_dec_eq(x_150, x_144); +lean_dec(x_150); +if (x_151 == 0) +{ +lean_dec(x_149); +lean_dec(x_144); +lean_dec(x_143); +x_108 = x_147; +goto block_139; +} +else +{ +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_inc(x_144); +x_152 = l_Lean_Parser_ParserState_restore(x_147, x_143, x_144); +lean_dec(x_143); +x_153 = lean_ctor_get(x_152, 0); +lean_inc(x_153); +x_154 = lean_array_get_size(x_153); +lean_dec(x_153); +x_155 = l_Lean_Parser_regBuiltinCommandParserAttr___closed__4; +lean_inc(x_1); +x_156 = l_Lean_Parser_categoryParser___elambda__1(x_155, x_146, x_1, x_152); +x_157 = lean_ctor_get(x_156, 3); +lean_inc(x_157); +if (lean_obj_tag(x_157) == 0) +{ +lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; +lean_inc(x_1); +x_158 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_stxQuot___elambda__1___spec__1(x_1, x_156); +x_159 = lean_ctor_get(x_158, 0); +lean_inc(x_159); +x_160 = lean_array_get_size(x_159); +lean_dec(x_159); +x_161 = lean_nat_sub(x_160, x_154); +lean_dec(x_160); +x_162 = lean_unsigned_to_nat(1u); +x_163 = lean_nat_dec_eq(x_161, x_162); +lean_dec(x_161); +if (x_163 == 0) +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; +x_164 = l_Lean_nullKind; +x_165 = l_Lean_Parser_ParserState_mkNode(x_158, x_164, x_154); +x_166 = l_Lean_Parser_mergeOrElseErrors(x_165, x_149, x_144); +lean_dec(x_144); +x_108 = x_166; +goto block_139; +} +else +{ +lean_object* x_167; +lean_dec(x_154); +x_167 = l_Lean_Parser_mergeOrElseErrors(x_158, x_149, x_144); +lean_dec(x_144); +x_108 = x_167; +goto block_139; +} +} +else +{ +lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; +lean_dec(x_157); +x_168 = lean_ctor_get(x_156, 0); +lean_inc(x_168); +x_169 = lean_array_get_size(x_168); +lean_dec(x_168); +x_170 = lean_nat_sub(x_169, x_154); +lean_dec(x_169); +x_171 = lean_unsigned_to_nat(1u); +x_172 = lean_nat_dec_eq(x_170, x_171); +lean_dec(x_170); +if (x_172 == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; +x_173 = l_Lean_nullKind; +x_174 = l_Lean_Parser_ParserState_mkNode(x_156, x_173, x_154); +x_175 = l_Lean_Parser_mergeOrElseErrors(x_174, x_149, x_144); +lean_dec(x_144); +x_108 = x_175; +goto block_139; +} +else +{ +lean_object* x_176; +lean_dec(x_154); +x_176 = l_Lean_Parser_mergeOrElseErrors(x_156, x_149, x_144); +lean_dec(x_144); +x_108 = x_176; +goto block_139; +} +} +} +} +} +else +{ +lean_object* x_177; lean_object* x_178; lean_object* x_179; +lean_dec(x_141); +lean_dec(x_1); +x_177 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_178 = l_Lean_Parser_ParserState_mkNode(x_140, x_177, x_107); +x_179 = l_Lean_Parser_mergeOrElseErrors(x_178, x_98, x_95); +lean_dec(x_95); +return x_179; +} +} +} +else +{ +lean_object* x_195; +lean_dec(x_105); +lean_dec(x_1); +x_195 = l_Lean_Parser_mergeOrElseErrors(x_104, x_98, x_95); +lean_dec(x_95); +return x_195; +} } } } @@ -2011,11 +2046,10 @@ return x_171; lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__1() { _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_stxQuot___elambda__1___closed__4; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__2() { @@ -2035,7 +2069,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_antiquotNestedExpr___closed__3; +x_3 = l_Lean_Parser_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); @@ -2047,7 +2081,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_Lean_Parser_antiquotNestedExpr___closed__4; +x_2 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } @@ -2075,16 +2109,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__7() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_stxQuot___closed__6; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__8() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_stxQuot___elambda__1___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_stxQuot___closed__6; +x_3 = l_Lean_Parser_Term_stxQuot___closed__7; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__8() { +lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__9() { _start: { lean_object* x_1; @@ -2092,12 +2136,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_stxQuot___elambda__1), 2, 0) return x_1; } } -lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__9() { +lean_object* _init_l_Lean_Parser_Term_stxQuot___closed__10() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_stxQuot___closed__7; -x_2 = l_Lean_Parser_Term_stxQuot___closed__8; +x_1 = l_Lean_Parser_Term_stxQuot___closed__8; +x_2 = l_Lean_Parser_Term_stxQuot___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); @@ -2108,7 +2152,7 @@ lean_object* _init_l_Lean_Parser_Term_stxQuot() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_stxQuot___closed__9; +x_1 = l_Lean_Parser_Term_stxQuot___closed__10; return x_1; } } @@ -2531,11 +2575,10 @@ return x_49; lean_object* _init_l_Lean_Parser_Command_docComment___closed__1() { _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_Command_docComment___elambda__1___closed__8; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_docComment___closed__2() { @@ -3762,11 +3805,10 @@ return x_101; lean_object* _init_l_Lean_Parser_Command_attributes___closed__1() { _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_Command_attributes___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_attributes___closed__2() { @@ -4168,11 +4210,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_private___closed__1() { _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_Command_private___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_private___closed__2() { @@ -4516,11 +4557,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_protected___closed__1() { _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_Command_protected___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_protected___closed__2() { @@ -4959,11 +4999,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_noncomputable___closed__1() { _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_Command_noncomputable___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_noncomputable___closed__2() { @@ -5307,11 +5346,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_unsafe___closed__1() { _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_Command_unsafe___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_unsafe___closed__2() { @@ -5655,11 +5693,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_partial___closed__1() { _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_Command_partial___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_partial___closed__2() { @@ -9087,11 +9124,10 @@ return x_67; lean_object* _init_l_Lean_Parser_Command_abbrev___closed__1() { _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_Command_abbrev___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_abbrev___closed__2() { @@ -9577,11 +9613,10 @@ return x_67; lean_object* _init_l_Lean_Parser_Command_def___closed__1() { _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_Command_def___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_def___closed__2() { @@ -10041,11 +10076,10 @@ return x_67; lean_object* _init_l_Lean_Parser_Command_theorem___closed__1() { _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_Command_theorem___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_theorem___closed__2() { @@ -10623,11 +10657,10 @@ return x_103; lean_object* _init_l_Lean_Parser_Command_constant___closed__1() { _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_Command_constant___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_constant___closed__2() { @@ -11354,11 +11387,10 @@ return x_139; lean_object* _init_l_Lean_Parser_Command_instance___closed__1() { _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_Command_instance___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_instance___closed__2() { @@ -11803,11 +11835,10 @@ return x_58; lean_object* _init_l_Lean_Parser_Command_axiom___closed__1() { _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_Command_axiom___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_axiom___closed__2() { @@ -12245,11 +12276,10 @@ return x_58; lean_object* _init_l_Lean_Parser_Command_example___closed__1() { _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_Command_example___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_example___closed__2() { @@ -13982,11 +14012,10 @@ return x_75; lean_object* _init_l_Lean_Parser_Command_inductive___closed__1() { _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_Command_inductive___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_inductive___closed__2() { @@ -14795,11 +14824,10 @@ goto block_124; lean_object* _init_l_Lean_Parser_Command_classInductive___closed__1() { _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_Command_classInductive___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_classInductive___closed__2() { @@ -15694,7 +15722,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_Lean_Parser_antiquotNestedExpr___closed__4; +x_2 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } @@ -15735,7 +15763,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_Lean_Parser_antiquotNestedExpr___closed__2; +x_1 = l_Lean_Parser_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; @@ -17986,9 +18014,8 @@ lean_object* _init_l_Lean_Parser_Command_structCtor___closed__1() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = lean_unsigned_to_nat(67u); -x_2 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_2, 0, x_1); +x_1 = l_Lean_Parser_Command_structCtor___elambda__1___closed__5; +x_2 = l_Lean_Parser_symbolInfo(x_1); return x_2; } } @@ -17996,57 +18023,47 @@ lean_object* _init_l_Lean_Parser_Command_structCtor___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Command_structCtor___elambda__1___closed__5; +x_1 = l_Lean_Parser_Command_introRule___closed__1; x_2 = l_Lean_Parser_Command_structCtor___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } } lean_object* _init_l_Lean_Parser_Command_structCtor___closed__3() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Command_introRule___closed__1; -x_2 = l_Lean_Parser_Command_structCtor___closed__2; -x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_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; +x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); +return x_4; } } lean_object* _init_l_Lean_Parser_Command_structCtor___closed__4() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_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__3; -x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); -return x_4; -} -} -lean_object* _init_l_Lean_Parser_Command_structCtor___closed__5() { -_start: -{ lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Command_structCtor___elambda__1___closed__2; -x_2 = l_Lean_Parser_Command_structCtor___closed__4; +x_2 = l_Lean_Parser_Command_structCtor___closed__3; x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Parser_Command_structCtor___closed__6() { +lean_object* _init_l_Lean_Parser_Command_structCtor___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Command_structCtor___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Command_structCtor___closed__5; +x_3 = l_Lean_Parser_Command_structCtor___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Command_structCtor___closed__7() { +lean_object* _init_l_Lean_Parser_Command_structCtor___closed__6() { _start: { lean_object* x_1; @@ -18054,12 +18071,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Command_structCtor___elambda__1), return x_1; } } -lean_object* _init_l_Lean_Parser_Command_structCtor___closed__8() { +lean_object* _init_l_Lean_Parser_Command_structCtor___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Command_structCtor___closed__6; -x_2 = l_Lean_Parser_Command_structCtor___closed__7; +x_1 = l_Lean_Parser_Command_structCtor___closed__5; +x_2 = l_Lean_Parser_Command_structCtor___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); @@ -18070,7 +18087,7 @@ lean_object* _init_l_Lean_Parser_Command_structCtor() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Command_structCtor___closed__8; +x_1 = l_Lean_Parser_Command_structCtor___closed__7; return x_1; } } @@ -18365,11 +18382,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_structureTk___closed__1() { _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_Command_structureTk___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_structureTk___closed__2() { @@ -19038,11 +19054,10 @@ return x_51; lean_object* _init_l_Lean_Parser_Command_extends___closed__1() { _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_Command_extends___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_extends___closed__2() { @@ -21918,11 +21933,10 @@ return x_85; lean_object* _init_l_Lean_Parser_Command_section___closed__1() { _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_Command_section___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_section___closed__2() { @@ -22333,11 +22347,10 @@ return x_49; lean_object* _init_l_Lean_Parser_Command_namespace___closed__1() { _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_Command_namespace___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_namespace___closed__2() { @@ -22823,11 +22836,10 @@ return x_85; lean_object* _init_l_Lean_Parser_Command_end___closed__1() { _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_Command_end___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_end___closed__2() { @@ -23234,11 +23246,10 @@ return x_51; lean_object* _init_l_Lean_Parser_Command_variable___closed__1() { _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_Command_variable___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_variable___closed__2() { @@ -23703,11 +23714,10 @@ return x_72; lean_object* _init_l_Lean_Parser_Command_variables___closed__1() { _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_Command_variables___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_variables___closed__2() { @@ -24109,11 +24119,10 @@ return x_49; lean_object* _init_l_Lean_Parser_Command_universe___closed__1() { _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_Command_universe___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_universe___closed__2() { @@ -24567,11 +24576,10 @@ return x_70; lean_object* _init_l_Lean_Parser_Command_universes___closed__1() { _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_Command_universes___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_universes___closed__2() { @@ -24977,18 +24985,17 @@ return x_53; lean_object* _init_l_Lean_Parser_Command_check___closed__1() { _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_Command_check___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Command_check___closed__1; @@ -25387,18 +25394,17 @@ return x_53; lean_object* _init_l_Lean_Parser_Command_check__failure___closed__1() { _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_Command_check__failure___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_check__failure___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Command_check__failure___closed__1; @@ -25797,18 +25803,17 @@ return x_53; lean_object* _init_l_Lean_Parser_Command_synth___closed__1() { _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_Command_synth___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Command_synth___closed__1; @@ -26169,11 +26174,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_exit___closed__1() { _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_Command_exit___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_exit___closed__2() { @@ -26563,11 +26567,10 @@ return x_49; lean_object* _init_l_Lean_Parser_Command_resolve__name___closed__1() { _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_Command_resolve__name___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_resolve__name___closed__2() { @@ -26927,11 +26930,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_init__quot___closed__1() { _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_Command_init__quot___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_init__quot___closed__2() { @@ -27741,11 +27743,10 @@ return x_164; lean_object* _init_l_Lean_Parser_Command_set__option___closed__1() { _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_Command_set__option___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_set__option___closed__2() { @@ -28883,11 +28884,10 @@ goto block_211; lean_object* _init_l_Lean_Parser_Command_attribute___closed__1() { _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_Command_attribute___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_attribute___closed__2() { @@ -28902,11 +28902,10 @@ return x_2; lean_object* _init_l_Lean_Parser_Command_attribute___closed__3() { _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_Command_attribute___elambda__1___closed__8; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_attribute___closed__4() { @@ -29748,11 +29747,10 @@ return x_167; lean_object* _init_l_Lean_Parser_Command_export___closed__1() { _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_Command_export___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_export___closed__2() { @@ -29762,7 +29760,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_ident; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_antiquotNestedExpr___closed__4; +x_3 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } @@ -29771,7 +29769,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_Lean_Parser_antiquotNestedExpr___closed__2; +x_1 = l_Lean_Parser_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; @@ -30424,11 +30422,10 @@ return x_104; lean_object* _init_l_Lean_Parser_Command_openHiding___closed__1() { _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_Command_openHiding___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_openHiding___closed__2() { @@ -30793,12 +30790,11 @@ return x_49; lean_object* _init_l_Lean_Parser_Command_openRenamingItem___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_Command_openRenamingItem___elambda__1___closed__6; -x_3 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__8; -x_4 = l_Lean_Parser_unicodeSymbolInfo(x_2, x_3, x_1); -return x_4; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__6; +x_2 = l_Lean_Parser_Command_openRenamingItem___elambda__1___closed__8; +x_3 = l_Lean_Parser_unicodeSymbolInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Command_openRenamingItem___closed__2() { @@ -31612,11 +31608,10 @@ return x_85; lean_object* _init_l_Lean_Parser_Command_openRenaming___closed__1() { _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_Command_openRenaming___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_openRenaming___closed__2() { @@ -32407,7 +32402,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_ident; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_antiquotNestedExpr___closed__2; +x_3 = l_Lean_Parser_antiquotNestedExpr___closed__1; x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } @@ -33336,11 +33331,10 @@ return x_147; lean_object* _init_l_Lean_Parser_Command_open___closed__1() { _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_Command_open___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_open___closed__2() { @@ -33512,6 +33506,8 @@ l_Lean_Parser_Term_stxQuot___closed__8 = _init_l_Lean_Parser_Term_stxQuot___clos lean_mark_persistent(l_Lean_Parser_Term_stxQuot___closed__8); l_Lean_Parser_Term_stxQuot___closed__9 = _init_l_Lean_Parser_Term_stxQuot___closed__9(); lean_mark_persistent(l_Lean_Parser_Term_stxQuot___closed__9); +l_Lean_Parser_Term_stxQuot___closed__10 = _init_l_Lean_Parser_Term_stxQuot___closed__10(); +lean_mark_persistent(l_Lean_Parser_Term_stxQuot___closed__10); l_Lean_Parser_Term_stxQuot = _init_l_Lean_Parser_Term_stxQuot(); lean_mark_persistent(l_Lean_Parser_Term_stxQuot); res = l___regBuiltinParser_Lean_Parser_Term_stxQuot(lean_io_mk_world()); @@ -34435,8 +34431,6 @@ l_Lean_Parser_Command_structCtor___closed__6 = _init_l_Lean_Parser_Command_struc lean_mark_persistent(l_Lean_Parser_Command_structCtor___closed__6); l_Lean_Parser_Command_structCtor___closed__7 = _init_l_Lean_Parser_Command_structCtor___closed__7(); lean_mark_persistent(l_Lean_Parser_Command_structCtor___closed__7); -l_Lean_Parser_Command_structCtor___closed__8 = _init_l_Lean_Parser_Command_structCtor___closed__8(); -lean_mark_persistent(l_Lean_Parser_Command_structCtor___closed__8); l_Lean_Parser_Command_structCtor = _init_l_Lean_Parser_Command_structCtor(); lean_mark_persistent(l_Lean_Parser_Command_structCtor); l_Lean_Parser_Command_structureTk___elambda__1___closed__1 = _init_l_Lean_Parser_Command_structureTk___elambda__1___closed__1(); diff --git a/stage0/stdlib/Lean/Parser/Level.c b/stage0/stdlib/Lean/Parser/Level.c index 41c9f088f4..4d105fec27 100644 --- a/stage0/stdlib/Lean/Parser/Level.c +++ b/stage0/stdlib/Lean/Parser/Level.c @@ -36,6 +36,8 @@ lean_object* l___regBuiltinParser_Lean_Parser_Level_num(lean_object*); extern lean_object* l_Lean_Level_LevelToFormat_Result_format___main___closed__1; extern lean_object* l_Lean_Parser_ident; lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__1; +lean_object* l_Lean_Parser_checkRbpLtFn(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Parser_Level_imax___closed__7; lean_object* l___regBuiltinParser_Lean_Parser_Level_max(lean_object*); lean_object* l_Lean_Parser_ParserState_mkNode(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Level_max___elambda__1___closed__1; @@ -61,6 +63,7 @@ lean_object* l_Lean_Parser_ParserState_mkErrorsAt(lean_object*, lean_object*, le lean_object* l_Lean_Parser_Level_imax___closed__3; lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__6; lean_object* l_Lean_Parser_Level_max___elambda__1___closed__2; +lean_object* lean_nat_add(lean_object*, lean_object*); extern lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; lean_object* l_Lean_Parser_Level_max___closed__3; lean_object* l_Lean_Parser_Level_max___elambda__1___closed__4; @@ -76,16 +79,16 @@ lean_object* l_Lean_Parser_nonReservedSymbolFnAux(lean_object*, lean_object*, le extern lean_object* l_Lean_Nat_HasQuote___closed__1; 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* l_Lean_Parser_Level_ident___closed__5; lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__2; +lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__7; extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__1; -extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__2; 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*); uint8_t l_Lean_Parser_tryAnti(lean_object*, lean_object*); lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__4; -extern lean_object* l_Lean_Parser_antiquotNestedExpr___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; @@ -105,6 +108,7 @@ 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_ParserState_restore(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__3; 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; @@ -119,16 +123,21 @@ 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; extern lean_object* l_Lean_Parser_numLit; +lean_object* l_Lean_Parser_Level_max___closed__8; 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_Level_num___closed__5; +lean_object* l_Lean_Parser_Level_hole___closed__6; +extern lean_object* l___private_Lean_Parser_Parser_10__precErrorMsg; 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(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_symbolInfo(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolInfo(lean_object*); +extern lean_object* l_Lean_Parser_epsilonInfo; lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__6; extern lean_object* l_Lean_mkHole___closed__1; lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*); @@ -159,6 +168,7 @@ lean_object* l_Lean_Parser_Level_paren___closed__6; lean_object* l___regBuiltinParser_Lean_Parser_Level_imax(lean_object*); lean_object* l_Lean_Parser_Level_imax___closed__4; 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_Lean_Parser_Level_addLit___closed__1; @@ -281,6 +291,16 @@ 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__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_appPrec; +x_2 = lean_unsigned_to_nat(1u); +x_3 = lean_nat_add(x_1, x_2); +return x_3; +} +} lean_object* l_Lean_Parser_Level_paren___elambda__1(lean_object* x_1, lean_object* x_2) { _start: { @@ -293,381 +313,414 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_41 = lean_ctor_get(x_2, 1); -lean_inc(x_41); -lean_inc(x_1); -x_42 = l_Lean_Parser_tokenFn(x_1, x_2); -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_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); -lean_dec(x_45); -x_47 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; -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_antiquotNestedExpr___elambda__1___closed__10; -x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_49, x_41); -x_8 = x_50; -goto block_40; -} -else -{ -lean_dec(x_41); -x_8 = x_42; -goto block_40; -} -} -else -{ -lean_object* x_51; lean_object* x_52; -lean_dec(x_45); -x_51 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_51, x_41); -x_8 = x_52; -goto block_40; -} -} -else -{ -lean_object* x_53; lean_object* x_54; -lean_dec(x_43); -x_53 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_53, x_41); -x_8 = x_54; -goto block_40; -} -block_40: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; -x_10 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_11 = lean_unsigned_to_nat(0u); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_45; lean_object* x_46; lean_object* x_47; +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_45 = lean_ctor_get(x_8, 1); +lean_inc(x_45); lean_inc(x_1); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); +x_46 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +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); +lean_dec(x_49); +x_51 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; +x_52 = lean_string_dec_eq(x_50, x_51); +lean_dec(x_50); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; +x_53 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_46, x_53, x_45); +x_12 = x_54; +goto block_44; +} +else +{ +lean_dec(x_45); +x_12 = x_46; +goto block_44; +} +} +else +{ +lean_object* x_55; lean_object* x_56; +lean_dec(x_49); +x_55 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_46, x_55, x_45); +x_12 = x_56; +goto block_44; +} +} +else +{ +lean_object* x_57; lean_object* x_58; +lean_dec(x_47); +x_57 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_46, x_57, x_45); +x_12 = x_58; +goto block_44; +} +block_44: +{ +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; -x_14 = lean_ctor_get(x_12, 1); -lean_inc(x_14); -x_15 = l_Lean_Parser_tokenFn(x_1, 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_object* x_18; -x_17 = lean_ctor_get(x_15, 0); +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_15 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = lean_ctor_get(x_16, 3); 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) +if (lean_obj_tag(x_17) == 0) { -lean_object* x_19; lean_object* x_20; uint8_t x_21; -x_19 = lean_ctor_get(x_18, 1); -lean_inc(x_19); -lean_dec(x_18); -x_20 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -x_21 = lean_string_dec_eq(x_19, x_20); -lean_dec(x_19); -if (x_21 == 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_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; -x_22 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); -x_24 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); -return x_25; +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_19, 0); +lean_inc(x_21); +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); +lean_dec(x_22); +x_24 = l_Lean_Parser_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; +x_26 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); +x_28 = l_Lean_Parser_Level_paren___elambda__1___closed__4; +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); +return x_29; } else { -lean_object* x_26; lean_object* x_27; -lean_dec(x_14); -x_26 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_27 = l_Lean_Parser_ParserState_mkNode(x_15, x_26, 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_30; lean_object* x_31; lean_dec(x_18); -x_28 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_28, x_14); x_30 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_7); +x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_11); return x_31; } } else { lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; -lean_dec(x_16); +lean_dec(x_22); x_32 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_32, x_14); +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_32, x_18); x_34 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_7); +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_11); return x_35; } } else { -lean_object* x_36; lean_object* x_37; -lean_dec(x_13); -lean_dec(x_1); -x_36 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_37 = l_Lean_Parser_ParserState_mkNode(x_12, x_36, x_7); -return x_37; -} -} -else -{ -lean_object* x_38; lean_object* x_39; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +lean_dec(x_20); +x_36 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_36, x_18); x_38 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_39 = l_Lean_Parser_ParserState_mkNode(x_8, x_38, x_7); +x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_11); return x_39; } } +else +{ +lean_object* x_40; lean_object* x_41; +lean_dec(x_17); +lean_dec(x_1); +x_40 = l_Lean_Parser_Level_paren___elambda__1___closed__4; +x_41 = l_Lean_Parser_ParserState_mkNode(x_16, x_40, x_11); +return x_41; +} } else { -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_2, 0); -lean_inc(x_55); -x_56 = lean_array_get_size(x_55); -lean_dec(x_55); -x_57 = lean_ctor_get(x_2, 1); -lean_inc(x_57); -lean_inc(x_1); -x_58 = lean_apply_2(x_4, x_1, x_2); -x_59 = lean_ctor_get(x_58, 3); +lean_object* x_42; lean_object* x_43; +lean_dec(x_13); +lean_dec(x_1); +x_42 = l_Lean_Parser_Level_paren___elambda__1___closed__4; +x_43 = l_Lean_Parser_ParserState_mkNode(x_12, x_42, x_11); +return x_43; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_59); -if (lean_obj_tag(x_59) == 0) -{ -lean_dec(x_57); -lean_dec(x_56); -lean_dec(x_1); -return x_58; -} -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); +x_60 = lean_array_get_size(x_59); lean_dec(x_59); -x_61 = lean_ctor_get(x_58, 1); +x_61 = lean_ctor_get(x_2, 1); lean_inc(x_61); -x_62 = lean_nat_dec_eq(x_61, x_57); -lean_dec(x_61); -if (x_62 == 0) +lean_inc(x_1); +x_62 = lean_apply_2(x_4, x_1, x_2); +x_63 = lean_ctor_get(x_62, 3); +lean_inc(x_63); +if (lean_obj_tag(x_63) == 0) { +lean_dec(x_61); lean_dec(x_60); -lean_dec(x_57); -lean_dec(x_56); lean_dec(x_1); -return x_58; +return x_62; } else { -lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_105; lean_object* x_106; -lean_inc(x_57); -x_63 = l_Lean_Parser_ParserState_restore(x_58, x_56, x_57); -lean_dec(x_56); +lean_object* x_64; lean_object* x_65; uint8_t x_66; x_64 = lean_ctor_get(x_63, 0); lean_inc(x_64); -x_65 = lean_array_get_size(x_64); +lean_dec(x_63); +x_65 = lean_ctor_get(x_62, 1); +lean_inc(x_65); +x_66 = lean_nat_dec_eq(x_65, x_61); +lean_dec(x_65); +if (x_66 == 0) +{ lean_dec(x_64); -lean_inc(x_1); -x_105 = l_Lean_Parser_tokenFn(x_1, x_63); -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; -x_107 = lean_ctor_get(x_105, 0); -lean_inc(x_107); -x_108 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_107); -lean_dec(x_107); -if (lean_obj_tag(x_108) == 2) -{ -lean_object* x_109; lean_object* x_110; uint8_t x_111; -x_109 = lean_ctor_get(x_108, 1); -lean_inc(x_109); -lean_dec(x_108); -x_110 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; -x_111 = lean_string_dec_eq(x_109, x_110); -lean_dec(x_109); -if (x_111 == 0) -{ -lean_object* x_112; lean_object* x_113; -x_112 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_57); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_105, x_112, x_57); -x_66 = x_113; -goto block_104; +lean_dec(x_61); +lean_dec(x_60); +lean_dec(x_1); +return x_62; } else { -x_66 = x_105; -goto block_104; -} -} -else -{ -lean_object* x_114; lean_object* x_115; -lean_dec(x_108); -x_114 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_57); -x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_105, x_114, x_57); -x_66 = x_115; -goto block_104; -} -} -else -{ -lean_object* x_116; lean_object* x_117; -lean_dec(x_106); -x_116 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_57); -x_117 = l_Lean_Parser_ParserState_mkErrorsAt(x_105, x_116, x_57); -x_66 = x_117; -goto block_104; -} -block_104: -{ -lean_object* x_67; -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; lean_object* x_70; lean_object* x_71; -x_68 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_69 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_70 = l_Lean_Parser_categoryParser___elambda__1(x_68, x_69, x_1, x_66); +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_inc(x_61); +x_67 = l_Lean_Parser_ParserState_restore(x_62, x_60, x_61); +lean_dec(x_60); +x_68 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_69 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_70 = l_Lean_Parser_checkRbpLtFn(x_68, x_69, x_1, 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; -x_72 = lean_ctor_get(x_70, 1); +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_72 = lean_ctor_get(x_70, 0); lean_inc(x_72); -x_73 = l_Lean_Parser_tokenFn(x_1, x_70); -x_74 = lean_ctor_get(x_73, 3); -lean_inc(x_74); -if (lean_obj_tag(x_74) == 0) -{ -lean_object* x_75; lean_object* x_76; -x_75 = lean_ctor_get(x_73, 0); -lean_inc(x_75); -x_76 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_75); -lean_dec(x_75); -if (lean_obj_tag(x_76) == 2) -{ -lean_object* x_77; lean_object* x_78; uint8_t x_79; -x_77 = lean_ctor_get(x_76, 1); -lean_inc(x_77); -lean_dec(x_76); -x_78 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -x_79 = lean_string_dec_eq(x_77, x_78); -lean_dec(x_77); -if (x_79 == 0) -{ -lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; -x_80 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_81 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_80, x_72); -x_82 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_83 = l_Lean_Parser_ParserState_mkNode(x_81, x_82, x_65); -x_84 = l_Lean_Parser_mergeOrElseErrors(x_83, x_60, x_57); -lean_dec(x_57); -return x_84; -} -else -{ -lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_73 = lean_array_get_size(x_72); lean_dec(x_72); -x_85 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_86 = l_Lean_Parser_ParserState_mkNode(x_73, x_85, x_65); -x_87 = l_Lean_Parser_mergeOrElseErrors(x_86, x_60, x_57); -lean_dec(x_57); -return x_87; +x_113 = lean_ctor_get(x_70, 1); +lean_inc(x_113); +lean_inc(x_1); +x_114 = l_Lean_Parser_tokenFn(x_1, x_70); +x_115 = lean_ctor_get(x_114, 3); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; +x_116 = lean_ctor_get(x_114, 0); +lean_inc(x_116); +x_117 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_116); +lean_dec(x_116); +if (lean_obj_tag(x_117) == 2) +{ +lean_object* x_118; lean_object* x_119; uint8_t x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +x_119 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; +x_120 = lean_string_dec_eq(x_118, x_119); +lean_dec(x_118); +if (x_120 == 0) +{ +lean_object* x_121; lean_object* x_122; +x_121 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_114, x_121, x_113); +x_74 = x_122; +goto block_112; +} +else +{ +lean_dec(x_113); +x_74 = x_114; +goto block_112; } } else { +lean_object* x_123; lean_object* x_124; +lean_dec(x_117); +x_123 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_114, x_123, x_113); +x_74 = x_124; +goto block_112; +} +} +else +{ +lean_object* x_125; lean_object* x_126; +lean_dec(x_115); +x_125 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_126 = l_Lean_Parser_ParserState_mkErrorsAt(x_114, x_125, x_113); +x_74 = x_126; +goto block_112; +} +block_112: +{ +lean_object* x_75; +x_75 = lean_ctor_get(x_74, 3); +lean_inc(x_75); +if (lean_obj_tag(x_75) == 0) +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_76 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_77 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_78 = l_Lean_Parser_categoryParser___elambda__1(x_76, x_77, x_1, x_74); +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; lean_object* x_82; +x_80 = lean_ctor_get(x_78, 1); +lean_inc(x_80); +x_81 = l_Lean_Parser_tokenFn(x_1, x_78); +x_82 = lean_ctor_get(x_81, 3); +lean_inc(x_82); +if (lean_obj_tag(x_82) == 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); +lean_dec(x_84); +x_86 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; +x_87 = lean_string_dec_eq(x_85, x_86); +lean_dec(x_85); +if (x_87 == 0) +{ lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; -lean_dec(x_76); x_88 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_88, x_72); +x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_81, x_88, x_80); x_90 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_91 = l_Lean_Parser_ParserState_mkNode(x_89, x_90, x_65); -x_92 = l_Lean_Parser_mergeOrElseErrors(x_91, x_60, x_57); -lean_dec(x_57); +x_91 = l_Lean_Parser_ParserState_mkNode(x_89, x_90, x_73); +x_92 = l_Lean_Parser_mergeOrElseErrors(x_91, x_64, x_61); +lean_dec(x_61); 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_74); -x_93 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_94 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_93, x_72); -x_95 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_65); -x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_60, x_57); -lean_dec(x_57); -return x_97; +lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_80); +x_93 = l_Lean_Parser_Level_paren___elambda__1___closed__4; +x_94 = l_Lean_Parser_ParserState_mkNode(x_81, x_93, x_73); +x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_64, x_61); +lean_dec(x_61); +return x_95; } } else { -lean_object* x_98; lean_object* x_99; lean_object* x_100; -lean_dec(x_71); -lean_dec(x_1); +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; +lean_dec(x_84); +x_96 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_97 = l_Lean_Parser_ParserState_mkErrorsAt(x_81, x_96, x_80); x_98 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_99 = l_Lean_Parser_ParserState_mkNode(x_70, x_98, x_65); -x_100 = l_Lean_Parser_mergeOrElseErrors(x_99, x_60, x_57); -lean_dec(x_57); +x_99 = l_Lean_Parser_ParserState_mkNode(x_97, x_98, x_73); +x_100 = l_Lean_Parser_mergeOrElseErrors(x_99, x_64, x_61); +lean_dec(x_61); return x_100; } } else { -lean_object* x_101; lean_object* x_102; lean_object* x_103; -lean_dec(x_67); -lean_dec(x_1); -x_101 = l_Lean_Parser_Level_paren___elambda__1___closed__4; -x_102 = l_Lean_Parser_ParserState_mkNode(x_66, x_101, x_65); -x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_60, x_57); -lean_dec(x_57); -return x_103; +lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; +lean_dec(x_82); +x_101 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_102 = l_Lean_Parser_ParserState_mkErrorsAt(x_81, x_101, x_80); +x_103 = l_Lean_Parser_Level_paren___elambda__1___closed__4; +x_104 = l_Lean_Parser_ParserState_mkNode(x_102, x_103, x_73); +x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_64, x_61); +lean_dec(x_61); +return x_105; } } +else +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_79); +lean_dec(x_1); +x_106 = l_Lean_Parser_Level_paren___elambda__1___closed__4; +x_107 = l_Lean_Parser_ParserState_mkNode(x_78, x_106, x_73); +x_108 = l_Lean_Parser_mergeOrElseErrors(x_107, x_64, x_61); +lean_dec(x_61); +return x_108; +} +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +lean_dec(x_75); +lean_dec(x_1); +x_109 = l_Lean_Parser_Level_paren___elambda__1___closed__4; +x_110 = l_Lean_Parser_ParserState_mkNode(x_74, x_109, x_73); +x_111 = l_Lean_Parser_mergeOrElseErrors(x_110, x_64, x_61); +lean_dec(x_61); +return x_111; +} +} +} +else +{ +lean_object* x_127; +lean_dec(x_71); +lean_dec(x_1); +x_127 = l_Lean_Parser_mergeOrElseErrors(x_70, x_64, x_61); +lean_dec(x_61); +return x_127; +} } } } @@ -690,7 +743,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__1; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_antiquotNestedExpr___closed__4; +x_3 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } @@ -699,7 +752,7 @@ lean_object* _init_l_Lean_Parser_Level_paren___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__1; x_2 = l_Lean_Parser_Level_paren___closed__2; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; @@ -718,16 +771,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Level_paren___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Level_paren___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Level_paren___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_paren___elambda__1___closed__6; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Level_paren___closed__4; +x_3 = l_Lean_Parser_Level_paren___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Level_paren___closed__6() { +lean_object* _init_l_Lean_Parser_Level_paren___closed__7() { _start: { lean_object* x_1; @@ -735,12 +798,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_paren___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Level_paren___closed__7() { +lean_object* _init_l_Lean_Parser_Level_paren___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Level_paren___closed__5; -x_2 = l_Lean_Parser_Level_paren___closed__6; +x_1 = l_Lean_Parser_Level_paren___closed__6; +x_2 = l_Lean_Parser_Level_paren___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); @@ -751,7 +814,7 @@ lean_object* _init_l_Lean_Parser_Level_paren() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Level_paren___closed__7; +x_1 = l_Lean_Parser_Level_paren___closed__8; return x_1; } } @@ -911,167 +974,200 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 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_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = l_Lean_Parser_Level_max___elambda__1___closed__5; -x_9 = l_Lean_Parser_Level_max___elambda__1___closed__7; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_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); +x_12 = l_Lean_Parser_Level_max___elambda__1___closed__5; +x_13 = l_Lean_Parser_Level_max___elambda__1___closed__7; lean_inc(x_1); -x_10 = l_Lean_Parser_nonReservedSymbolFnAux(x_8, x_9, x_1, x_2); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 0) +x_14 = l_Lean_Parser_nonReservedSymbolFnAux(x_12, x_13, x_1, x_8); +x_15 = lean_ctor_get(x_14, 3); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 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; -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 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_15 = l_Lean_Parser_appPrec; +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_16 = lean_ctor_get(x_14, 0); +lean_inc(x_16); +x_17 = lean_array_get_size(x_16); +lean_dec(x_16); +x_18 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_19 = l_Lean_Parser_appPrec; lean_inc(x_1); -x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_10); -x_17 = lean_ctor_get(x_16, 3); -lean_inc(x_17); -if (lean_obj_tag(x_17) == 0) +x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_14); +x_21 = lean_ctor_get(x_20, 3); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) { -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_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_1, x_16); -x_19 = l_Lean_nullKind; -x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_13); -x_21 = l_Lean_Parser_Level_max___elambda__1___closed__1; -x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_7); -return x_22; -} -else -{ -lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; -lean_dec(x_17); -lean_dec(x_1); +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_22 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_1, x_20); x_23 = l_Lean_nullKind; -x_24 = l_Lean_Parser_ParserState_mkNode(x_16, x_23, x_13); +x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_17); x_25 = l_Lean_Parser_Level_max___elambda__1___closed__1; -x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_7); +x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_11); return x_26; } -} else { -lean_object* x_27; lean_object* x_28; -lean_dec(x_11); +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_dec(x_21); lean_dec(x_1); -x_27 = l_Lean_Parser_Level_max___elambda__1___closed__1; -x_28 = l_Lean_Parser_ParserState_mkNode(x_10, x_27, x_7); -return x_28; +x_27 = l_Lean_nullKind; +x_28 = l_Lean_Parser_ParserState_mkNode(x_20, x_27, x_17); +x_29 = l_Lean_Parser_Level_max___elambda__1___closed__1; +x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_11); +return x_30; } } else { -lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; -x_29 = lean_ctor_get(x_2, 0); -lean_inc(x_29); -x_30 = lean_array_get_size(x_29); -lean_dec(x_29); -x_31 = lean_ctor_get(x_2, 1); -lean_inc(x_31); -lean_inc(x_1); -x_32 = lean_apply_2(x_4, x_1, x_2); -x_33 = lean_ctor_get(x_32, 3); +lean_object* x_31; lean_object* x_32; +lean_dec(x_15); +lean_dec(x_1); +x_31 = l_Lean_Parser_Level_max___elambda__1___closed__1; +x_32 = l_Lean_Parser_ParserState_mkNode(x_14, x_31, x_11); +return x_32; +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_33 = lean_ctor_get(x_2, 0); lean_inc(x_33); -if (lean_obj_tag(x_33) == 0) -{ -lean_dec(x_31); -lean_dec(x_30); -lean_dec(x_1); -return x_32; -} -else -{ -lean_object* x_34; lean_object* x_35; uint8_t x_36; -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); +x_34 = lean_array_get_size(x_33); lean_dec(x_33); -x_35 = lean_ctor_get(x_32, 1); +x_35 = lean_ctor_get(x_2, 1); lean_inc(x_35); -x_36 = lean_nat_dec_eq(x_35, x_31); -lean_dec(x_35); -if (x_36 == 0) +lean_inc(x_1); +x_36 = lean_apply_2(x_4, x_1, x_2); +x_37 = lean_ctor_get(x_36, 3); +lean_inc(x_37); +if (lean_obj_tag(x_37) == 0) { +lean_dec(x_35); lean_dec(x_34); -lean_dec(x_31); -lean_dec(x_30); lean_dec(x_1); -return x_32; +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; lean_object* x_43; -lean_inc(x_31); -x_37 = l_Lean_Parser_ParserState_restore(x_32, x_30, x_31); -lean_dec(x_30); +lean_object* x_38; lean_object* x_39; uint8_t x_40; x_38 = lean_ctor_get(x_37, 0); lean_inc(x_38); -x_39 = lean_array_get_size(x_38); +lean_dec(x_37); +x_39 = lean_ctor_get(x_36, 1); +lean_inc(x_39); +x_40 = lean_nat_dec_eq(x_39, x_35); +lean_dec(x_39); +if (x_40 == 0) +{ lean_dec(x_38); -x_40 = l_Lean_Parser_Level_max___elambda__1___closed__5; -x_41 = l_Lean_Parser_Level_max___elambda__1___closed__7; -lean_inc(x_1); -x_42 = l_Lean_Parser_nonReservedSymbolFnAux(x_40, x_41, x_1, x_37); -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_object* x_48; lean_object* x_49; -x_44 = lean_ctor_get(x_42, 0); -lean_inc(x_44); -x_45 = lean_array_get_size(x_44); -lean_dec(x_44); -x_46 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_47 = l_Lean_Parser_appPrec; -lean_inc(x_1); -x_48 = l_Lean_Parser_categoryParser___elambda__1(x_46, x_47, x_1, x_42); -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 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_1, x_48); -x_51 = l_Lean_nullKind; -x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_45); -x_53 = l_Lean_Parser_Level_max___elambda__1___closed__1; -x_54 = l_Lean_Parser_ParserState_mkNode(x_52, x_53, x_39); -x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_34, x_31); -lean_dec(x_31); -return x_55; +lean_dec(x_35); +lean_dec(x_34); +lean_dec(x_1); +return x_36; } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -lean_dec(x_49); -lean_dec(x_1); -x_56 = l_Lean_nullKind; -x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_45); -x_58 = l_Lean_Parser_Level_max___elambda__1___closed__1; -x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_39); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_34, x_31); -lean_dec(x_31); -return x_60; -} -} -else +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +lean_inc(x_35); +x_41 = l_Lean_Parser_ParserState_restore(x_36, x_34, x_35); +lean_dec(x_34); +x_42 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_43 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_44 = l_Lean_Parser_checkRbpLtFn(x_42, x_43, x_1, x_41); +x_45 = lean_ctor_get(x_44, 3); +lean_inc(x_45); +if (lean_obj_tag(x_45) == 0) { -lean_object* x_61; lean_object* x_62; lean_object* x_63; -lean_dec(x_43); -lean_dec(x_1); +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_46 = lean_ctor_get(x_44, 0); +lean_inc(x_46); +x_47 = lean_array_get_size(x_46); +lean_dec(x_46); +x_48 = l_Lean_Parser_Level_max___elambda__1___closed__5; +x_49 = l_Lean_Parser_Level_max___elambda__1___closed__7; +lean_inc(x_1); +x_50 = l_Lean_Parser_nonReservedSymbolFnAux(x_48, x_49, x_1, x_44); +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; lean_object* x_57; +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 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_55 = l_Lean_Parser_appPrec; +lean_inc(x_1); +x_56 = l_Lean_Parser_categoryParser___elambda__1(x_54, x_55, x_1, x_50); +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; lean_object* x_63; +x_58 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___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_53); x_61 = l_Lean_Parser_Level_max___elambda__1___closed__1; -x_62 = l_Lean_Parser_ParserState_mkNode(x_42, x_61, x_39); -x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_34, x_31); -lean_dec(x_31); +x_62 = l_Lean_Parser_ParserState_mkNode(x_60, x_61, x_47); +x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_38, x_35); +lean_dec(x_35); return x_63; } +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; +lean_dec(x_57); +lean_dec(x_1); +x_64 = l_Lean_nullKind; +x_65 = l_Lean_Parser_ParserState_mkNode(x_56, x_64, x_53); +x_66 = l_Lean_Parser_Level_max___elambda__1___closed__1; +x_67 = l_Lean_Parser_ParserState_mkNode(x_65, x_66, x_47); +x_68 = l_Lean_Parser_mergeOrElseErrors(x_67, x_38, x_35); +lean_dec(x_35); +return x_68; +} +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_51); +lean_dec(x_1); +x_69 = l_Lean_Parser_Level_max___elambda__1___closed__1; +x_70 = l_Lean_Parser_ParserState_mkNode(x_50, x_69, x_47); +x_71 = l_Lean_Parser_mergeOrElseErrors(x_70, x_38, x_35); +lean_dec(x_35); +return x_71; +} +} +else +{ +lean_object* x_72; +lean_dec(x_45); +lean_dec(x_1); +x_72 = l_Lean_Parser_mergeOrElseErrors(x_44, x_38, x_35); +lean_dec(x_35); +return x_72; +} } } } @@ -1122,16 +1218,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Level_max___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Level_max___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Level_max___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_max___elambda__1___closed__3; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Level_max___closed__4; +x_3 = l_Lean_Parser_Level_max___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Level_max___closed__6() { +lean_object* _init_l_Lean_Parser_Level_max___closed__7() { _start: { lean_object* x_1; @@ -1139,12 +1245,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_max___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Level_max___closed__7() { +lean_object* _init_l_Lean_Parser_Level_max___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Level_max___closed__5; -x_2 = l_Lean_Parser_Level_max___closed__6; +x_1 = l_Lean_Parser_Level_max___closed__6; +x_2 = l_Lean_Parser_Level_max___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); @@ -1155,7 +1261,7 @@ lean_object* _init_l_Lean_Parser_Level_max() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Level_max___closed__7; +x_1 = l_Lean_Parser_Level_max___closed__8; return x_1; } } @@ -1251,167 +1357,200 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 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_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = l_Lean_Parser_Level_imax___elambda__1___closed__5; -x_9 = l_Lean_Parser_Level_imax___elambda__1___closed__7; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_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); +x_12 = l_Lean_Parser_Level_imax___elambda__1___closed__5; +x_13 = l_Lean_Parser_Level_imax___elambda__1___closed__7; lean_inc(x_1); -x_10 = l_Lean_Parser_nonReservedSymbolFnAux(x_8, x_9, x_1, x_2); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 0) +x_14 = l_Lean_Parser_nonReservedSymbolFnAux(x_12, x_13, x_1, x_8); +x_15 = lean_ctor_get(x_14, 3); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 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; -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 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_15 = l_Lean_Parser_appPrec; +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_16 = lean_ctor_get(x_14, 0); +lean_inc(x_16); +x_17 = lean_array_get_size(x_16); +lean_dec(x_16); +x_18 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_19 = l_Lean_Parser_appPrec; lean_inc(x_1); -x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_10); -x_17 = lean_ctor_get(x_16, 3); -lean_inc(x_17); -if (lean_obj_tag(x_17) == 0) +x_20 = l_Lean_Parser_categoryParser___elambda__1(x_18, x_19, x_1, x_14); +x_21 = lean_ctor_get(x_20, 3); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) { -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_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_1, x_16); -x_19 = l_Lean_nullKind; -x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_13); -x_21 = l_Lean_Parser_Level_imax___elambda__1___closed__1; -x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_7); -return x_22; -} -else -{ -lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; -lean_dec(x_17); -lean_dec(x_1); +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_22 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_1, x_20); x_23 = l_Lean_nullKind; -x_24 = l_Lean_Parser_ParserState_mkNode(x_16, x_23, x_13); +x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_17); x_25 = l_Lean_Parser_Level_imax___elambda__1___closed__1; -x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_7); +x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_11); return x_26; } -} else { -lean_object* x_27; lean_object* x_28; -lean_dec(x_11); +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_dec(x_21); lean_dec(x_1); -x_27 = l_Lean_Parser_Level_imax___elambda__1___closed__1; -x_28 = l_Lean_Parser_ParserState_mkNode(x_10, x_27, x_7); -return x_28; +x_27 = l_Lean_nullKind; +x_28 = l_Lean_Parser_ParserState_mkNode(x_20, x_27, x_17); +x_29 = l_Lean_Parser_Level_imax___elambda__1___closed__1; +x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_11); +return x_30; } } else { -lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; -x_29 = lean_ctor_get(x_2, 0); -lean_inc(x_29); -x_30 = lean_array_get_size(x_29); -lean_dec(x_29); -x_31 = lean_ctor_get(x_2, 1); -lean_inc(x_31); -lean_inc(x_1); -x_32 = lean_apply_2(x_4, x_1, x_2); -x_33 = lean_ctor_get(x_32, 3); +lean_object* x_31; lean_object* x_32; +lean_dec(x_15); +lean_dec(x_1); +x_31 = l_Lean_Parser_Level_imax___elambda__1___closed__1; +x_32 = l_Lean_Parser_ParserState_mkNode(x_14, x_31, x_11); +return x_32; +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_33 = lean_ctor_get(x_2, 0); lean_inc(x_33); -if (lean_obj_tag(x_33) == 0) -{ -lean_dec(x_31); -lean_dec(x_30); -lean_dec(x_1); -return x_32; -} -else -{ -lean_object* x_34; lean_object* x_35; uint8_t x_36; -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); +x_34 = lean_array_get_size(x_33); lean_dec(x_33); -x_35 = lean_ctor_get(x_32, 1); +x_35 = lean_ctor_get(x_2, 1); lean_inc(x_35); -x_36 = lean_nat_dec_eq(x_35, x_31); -lean_dec(x_35); -if (x_36 == 0) +lean_inc(x_1); +x_36 = lean_apply_2(x_4, x_1, x_2); +x_37 = lean_ctor_get(x_36, 3); +lean_inc(x_37); +if (lean_obj_tag(x_37) == 0) { +lean_dec(x_35); lean_dec(x_34); -lean_dec(x_31); -lean_dec(x_30); lean_dec(x_1); -return x_32; +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; lean_object* x_43; -lean_inc(x_31); -x_37 = l_Lean_Parser_ParserState_restore(x_32, x_30, x_31); -lean_dec(x_30); +lean_object* x_38; lean_object* x_39; uint8_t x_40; x_38 = lean_ctor_get(x_37, 0); lean_inc(x_38); -x_39 = lean_array_get_size(x_38); +lean_dec(x_37); +x_39 = lean_ctor_get(x_36, 1); +lean_inc(x_39); +x_40 = lean_nat_dec_eq(x_39, x_35); +lean_dec(x_39); +if (x_40 == 0) +{ lean_dec(x_38); -x_40 = l_Lean_Parser_Level_imax___elambda__1___closed__5; -x_41 = l_Lean_Parser_Level_imax___elambda__1___closed__7; -lean_inc(x_1); -x_42 = l_Lean_Parser_nonReservedSymbolFnAux(x_40, x_41, x_1, x_37); -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_object* x_48; lean_object* x_49; -x_44 = lean_ctor_get(x_42, 0); -lean_inc(x_44); -x_45 = lean_array_get_size(x_44); -lean_dec(x_44); -x_46 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_47 = l_Lean_Parser_appPrec; -lean_inc(x_1); -x_48 = l_Lean_Parser_categoryParser___elambda__1(x_46, x_47, x_1, x_42); -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 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___elambda__1___spec__1(x_1, x_48); -x_51 = l_Lean_nullKind; -x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_45); -x_53 = l_Lean_Parser_Level_imax___elambda__1___closed__1; -x_54 = l_Lean_Parser_ParserState_mkNode(x_52, x_53, x_39); -x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_34, x_31); -lean_dec(x_31); -return x_55; +lean_dec(x_35); +lean_dec(x_34); +lean_dec(x_1); +return x_36; } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -lean_dec(x_49); -lean_dec(x_1); -x_56 = l_Lean_nullKind; -x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_45); -x_58 = l_Lean_Parser_Level_imax___elambda__1___closed__1; -x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_39); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_34, x_31); -lean_dec(x_31); -return x_60; -} -} -else +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +lean_inc(x_35); +x_41 = l_Lean_Parser_ParserState_restore(x_36, x_34, x_35); +lean_dec(x_34); +x_42 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_43 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_44 = l_Lean_Parser_checkRbpLtFn(x_42, x_43, x_1, x_41); +x_45 = lean_ctor_get(x_44, 3); +lean_inc(x_45); +if (lean_obj_tag(x_45) == 0) { -lean_object* x_61; lean_object* x_62; lean_object* x_63; -lean_dec(x_43); -lean_dec(x_1); +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_46 = lean_ctor_get(x_44, 0); +lean_inc(x_46); +x_47 = lean_array_get_size(x_46); +lean_dec(x_46); +x_48 = l_Lean_Parser_Level_imax___elambda__1___closed__5; +x_49 = l_Lean_Parser_Level_imax___elambda__1___closed__7; +lean_inc(x_1); +x_50 = l_Lean_Parser_nonReservedSymbolFnAux(x_48, x_49, x_1, x_44); +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; lean_object* x_57; +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 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_55 = l_Lean_Parser_appPrec; +lean_inc(x_1); +x_56 = l_Lean_Parser_categoryParser___elambda__1(x_54, x_55, x_1, x_50); +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; lean_object* x_63; +x_58 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Level_max___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_53); x_61 = l_Lean_Parser_Level_imax___elambda__1___closed__1; -x_62 = l_Lean_Parser_ParserState_mkNode(x_42, x_61, x_39); -x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_34, x_31); -lean_dec(x_31); +x_62 = l_Lean_Parser_ParserState_mkNode(x_60, x_61, x_47); +x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_38, x_35); +lean_dec(x_35); return x_63; } +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; +lean_dec(x_57); +lean_dec(x_1); +x_64 = l_Lean_nullKind; +x_65 = l_Lean_Parser_ParserState_mkNode(x_56, x_64, x_53); +x_66 = l_Lean_Parser_Level_imax___elambda__1___closed__1; +x_67 = l_Lean_Parser_ParserState_mkNode(x_65, x_66, x_47); +x_68 = l_Lean_Parser_mergeOrElseErrors(x_67, x_38, x_35); +lean_dec(x_35); +return x_68; +} +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_51); +lean_dec(x_1); +x_69 = l_Lean_Parser_Level_imax___elambda__1___closed__1; +x_70 = l_Lean_Parser_ParserState_mkNode(x_50, x_69, x_47); +x_71 = l_Lean_Parser_mergeOrElseErrors(x_70, x_38, x_35); +lean_dec(x_35); +return x_71; +} +} +else +{ +lean_object* x_72; +lean_dec(x_45); +lean_dec(x_1); +x_72 = l_Lean_Parser_mergeOrElseErrors(x_44, x_38, x_35); +lean_dec(x_35); +return x_72; +} } } } @@ -1452,16 +1591,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Level_imax___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Level_imax___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Level_imax___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_imax___elambda__1___closed__3; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Level_imax___closed__3; +x_3 = l_Lean_Parser_Level_imax___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Level_imax___closed__5() { +lean_object* _init_l_Lean_Parser_Level_imax___closed__6() { _start: { lean_object* x_1; @@ -1469,12 +1618,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_imax___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Level_imax___closed__6() { +lean_object* _init_l_Lean_Parser_Level_imax___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Level_imax___closed__4; -x_2 = l_Lean_Parser_Level_imax___closed__5; +x_1 = l_Lean_Parser_Level_imax___closed__5; +x_2 = l_Lean_Parser_Level_imax___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); @@ -1485,7 +1634,7 @@ lean_object* _init_l_Lean_Parser_Level_imax() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Level_imax___closed__6; +x_1 = l_Lean_Parser_Level_imax___closed__7; return x_1; } } @@ -1585,188 +1734,221 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = lean_ctor_get(x_2, 1); -lean_inc(x_8); -x_9 = l_Lean_Parser_tokenFn(x_1, x_2); -x_10 = lean_ctor_get(x_9, 3); +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = lean_ctor_get(x_8, 0); lean_inc(x_10); -if (lean_obj_tag(x_10) == 0) +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_13 = l_Lean_Parser_tokenFn(x_1, x_8); +x_14 = lean_ctor_get(x_13, 3); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 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_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_checkStackTopFn___spec__1(x_15); +lean_dec(x_15); +if (lean_obj_tag(x_16) == 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_Lean_Parser_Level_hole___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_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_Lean_Parser_Level_hole___elambda__1___closed__4; +x_19 = lean_string_dec_eq(x_17, x_18); +lean_dec(x_17); +if (x_19 == 0) { -lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_16 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_16, x_8); -x_18 = l_Lean_Parser_Level_hole___elambda__1___closed__1; -x_19 = l_Lean_Parser_ParserState_mkNode(x_17, x_18, x_7); -return x_19; +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_20 = l_Lean_Parser_Level_hole___elambda__1___closed__7; +x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); +x_22 = l_Lean_Parser_Level_hole___elambda__1___closed__1; +x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_11); +return x_23; } else { -lean_object* x_20; lean_object* x_21; -lean_dec(x_8); -x_20 = l_Lean_Parser_Level_hole___elambda__1___closed__1; -x_21 = l_Lean_Parser_ParserState_mkNode(x_9, x_20, x_7); -return x_21; -} -} -else -{ -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_object* x_24; lean_object* x_25; lean_dec(x_12); -x_22 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_22, x_8); x_24 = l_Lean_Parser_Level_hole___elambda__1___closed__1; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); +x_25 = l_Lean_Parser_ParserState_mkNode(x_13, x_24, x_11); return x_25; } } else { lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -lean_dec(x_10); +lean_dec(x_16); x_26 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_26, x_8); +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_Parser_Level_hole___elambda__1___closed__1; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); return x_29; } } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_30 = lean_ctor_get(x_2, 0); -lean_inc(x_30); -x_31 = lean_array_get_size(x_30); -lean_dec(x_30); -x_32 = lean_ctor_get(x_2, 1); -lean_inc(x_32); -lean_inc(x_1); -x_33 = lean_apply_2(x_4, x_1, x_2); -x_34 = lean_ctor_get(x_33, 3); +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_Level_hole___elambda__1___closed__7; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_32 = l_Lean_Parser_Level_hole___elambda__1___closed__1; +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); +return x_33; +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_2, 0); lean_inc(x_34); -if (lean_obj_tag(x_34) == 0) -{ -lean_dec(x_32); -lean_dec(x_31); -lean_dec(x_1); -return x_33; -} -else -{ -lean_object* x_35; lean_object* x_36; uint8_t x_37; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); +x_35 = lean_array_get_size(x_34); lean_dec(x_34); -x_36 = lean_ctor_get(x_33, 1); +x_36 = lean_ctor_get(x_2, 1); lean_inc(x_36); -x_37 = lean_nat_dec_eq(x_36, x_32); -lean_dec(x_36); -if (x_37 == 0) +lean_inc(x_1); +x_37 = lean_apply_2(x_4, x_1, x_2); +x_38 = lean_ctor_get(x_37, 3); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) { +lean_dec(x_36); lean_dec(x_35); -lean_dec(x_32); -lean_dec(x_31); lean_dec(x_1); -return x_33; +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_inc(x_32); -x_38 = l_Lean_Parser_ParserState_restore(x_33, x_31, x_32); -lean_dec(x_31); +lean_object* x_39; lean_object* x_40; uint8_t x_41; x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -x_40 = lean_array_get_size(x_39); +lean_dec(x_38); +x_40 = lean_ctor_get(x_37, 1); +lean_inc(x_40); +x_41 = lean_nat_dec_eq(x_40, x_36); +lean_dec(x_40); +if (x_41 == 0) +{ lean_dec(x_39); -x_41 = l_Lean_Parser_tokenFn(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_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_Lean_Parser_Level_hole___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_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_48 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -lean_inc(x_32); -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_32); -x_50 = l_Lean_Parser_Level_hole___elambda__1___closed__1; -x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_40); -x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_35, x_32); -lean_dec(x_32); -return x_52; +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_1); +return x_37; } else { -lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_53 = l_Lean_Parser_Level_hole___elambda__1___closed__1; -x_54 = l_Lean_Parser_ParserState_mkNode(x_41, x_53, x_40); -x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_35, x_32); -lean_dec(x_32); -return x_55; +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_inc(x_36); +x_42 = l_Lean_Parser_ParserState_restore(x_37, x_35, x_36); +lean_dec(x_35); +x_43 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_44 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_45 = l_Lean_Parser_checkRbpLtFn(x_43, 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) +{ +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); +x_48 = lean_array_get_size(x_47); +lean_dec(x_47); +x_49 = lean_ctor_get(x_45, 1); +lean_inc(x_49); +x_50 = l_Lean_Parser_tokenFn(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_52; lean_object* x_53; +x_52 = lean_ctor_get(x_50, 0); +lean_inc(x_52); +x_53 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_52); +lean_dec(x_52); +if (lean_obj_tag(x_53) == 2) +{ +lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_54); +lean_dec(x_53); +x_55 = l_Lean_Parser_Level_hole___elambda__1___closed__4; +x_56 = lean_string_dec_eq(x_54, x_55); +lean_dec(x_54); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = l_Lean_Parser_Level_hole___elambda__1___closed__7; +x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_57, x_49); +x_59 = l_Lean_Parser_Level_hole___elambda__1___closed__1; +x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_48); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_39, x_36); +lean_dec(x_36); +return x_61; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_49); +x_62 = l_Lean_Parser_Level_hole___elambda__1___closed__1; +x_63 = l_Lean_Parser_ParserState_mkNode(x_50, x_62, x_48); +x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_39, x_36); +lean_dec(x_36); +return x_64; } } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -lean_dec(x_44); -x_56 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -lean_inc(x_32); -x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_56, x_32); -x_58 = l_Lean_Parser_Level_hole___elambda__1___closed__1; -x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_40); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_35, x_32); -lean_dec(x_32); -return x_60; +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_53); +x_65 = l_Lean_Parser_Level_hole___elambda__1___closed__7; +x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_65, x_49); +x_67 = l_Lean_Parser_Level_hole___elambda__1___closed__1; +x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_48); +x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_39, x_36); +lean_dec(x_36); +return x_69; } } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -lean_dec(x_42); -x_61 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -lean_inc(x_32); -x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_61, x_32); -x_63 = l_Lean_Parser_Level_hole___elambda__1___closed__1; -x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_40); -x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_35, x_32); -lean_dec(x_32); -return x_65; +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_51); +x_70 = l_Lean_Parser_Level_hole___elambda__1___closed__7; +x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_70, x_49); +x_72 = l_Lean_Parser_Level_hole___elambda__1___closed__1; +x_73 = l_Lean_Parser_ParserState_mkNode(x_71, x_72, x_48); +x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_39, x_36); +lean_dec(x_36); +return x_74; +} +} +else +{ +lean_object* x_75; +lean_dec(x_46); +lean_dec(x_1); +x_75 = l_Lean_Parser_mergeOrElseErrors(x_45, x_39, x_36); +lean_dec(x_36); +return x_75; } } } @@ -1776,11 +1958,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Level_hole___closed__1() { _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_Level_hole___elambda__1___closed__4; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Level_hole___closed__2() { @@ -1796,16 +1977,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Level_hole___closed__3() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Level_hole___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Level_hole___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_hole___elambda__1___closed__3; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Level_hole___closed__2; +x_3 = l_Lean_Parser_Level_hole___closed__3; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Level_hole___closed__4() { +lean_object* _init_l_Lean_Parser_Level_hole___closed__5() { _start: { lean_object* x_1; @@ -1813,12 +2004,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_hole___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Level_hole___closed__5() { +lean_object* _init_l_Lean_Parser_Level_hole___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Level_hole___closed__3; -x_2 = l_Lean_Parser_Level_hole___closed__4; +x_1 = l_Lean_Parser_Level_hole___closed__4; +x_2 = l_Lean_Parser_Level_hole___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); @@ -1829,7 +2020,7 @@ lean_object* _init_l_Lean_Parser_Level_hole() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Level_hole___closed__5; +x_1 = l_Lean_Parser_Level_hole___closed__6; return x_1; } } @@ -1888,71 +2079,104 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = l_Lean_Parser_numLit___elambda__1(x_1, x_2); -x_9 = l_Lean_Parser_Level_num___elambda__1___closed__1; -x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7); -return x_10; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +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 = l_Lean_Parser_numLit___elambda__1(x_1, x_8); +x_13 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_11); +return x_14; } 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_2, 0); -lean_inc(x_11); -x_12 = lean_array_get_size(x_11); -lean_dec(x_11); -x_13 = lean_ctor_get(x_2, 1); -lean_inc(x_13); -lean_inc(x_1); -x_14 = lean_apply_2(x_4, x_1, x_2); -x_15 = lean_ctor_get(x_14, 3); +lean_dec(x_9); +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; +x_15 = lean_ctor_get(x_2, 0); lean_inc(x_15); -if (lean_obj_tag(x_15) == 0) -{ -lean_dec(x_13); -lean_dec(x_12); -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); +x_16 = lean_array_get_size(x_15); lean_dec(x_15); -x_17 = lean_ctor_get(x_14, 1); +x_17 = lean_ctor_get(x_2, 1); lean_inc(x_17); -x_18 = lean_nat_dec_eq(x_17, x_13); -lean_dec(x_17); -if (x_18 == 0) +lean_inc(x_1); +x_18 = lean_apply_2(x_4, x_1, x_2); +x_19 = lean_ctor_get(x_18, 3); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) { +lean_dec(x_17); lean_dec(x_16); -lean_dec(x_13); -lean_dec(x_12); lean_dec(x_1); -return x_14; +return x_18; } else { -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(x_13); -x_19 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13); -lean_dec(x_12); +lean_object* x_20; lean_object* x_21; uint8_t x_22; x_20 = lean_ctor_get(x_19, 0); lean_inc(x_20); -x_21 = lean_array_get_size(x_20); +lean_dec(x_19); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +x_22 = lean_nat_dec_eq(x_21, x_17); +lean_dec(x_21); +if (x_22 == 0) +{ lean_dec(x_20); -x_22 = l_Lean_Parser_numLit___elambda__1(x_1, x_19); -x_23 = l_Lean_Parser_Level_num___elambda__1___closed__1; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_21); -x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_16, x_13); -lean_dec(x_13); -return x_25; +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_1); +return x_18; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_inc(x_17); +x_23 = l_Lean_Parser_ParserState_restore(x_18, x_16, x_17); +lean_dec(x_16); +x_24 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_25 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_26 = l_Lean_Parser_checkRbpLtFn(x_24, 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_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_26, 0); +lean_inc(x_28); +x_29 = lean_array_get_size(x_28); +lean_dec(x_28); +x_30 = l_Lean_Parser_numLit___elambda__1(x_1, x_26); +x_31 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_29); +x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_20, x_17); +lean_dec(x_17); +return x_33; +} +else +{ +lean_object* x_34; +lean_dec(x_27); +lean_dec(x_1); +x_34 = l_Lean_Parser_mergeOrElseErrors(x_26, x_20, x_17); +lean_dec(x_17); +return x_34; +} } } } @@ -1973,16 +2197,26 @@ return x_4; lean_object* _init_l_Lean_Parser_Level_num___closed__2() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Level_num___closed__1; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Level_num___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_num___elambda__1___closed__3; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Level_num___closed__1; +x_3 = l_Lean_Parser_Level_num___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Level_num___closed__3() { +lean_object* _init_l_Lean_Parser_Level_num___closed__4() { _start: { lean_object* x_1; @@ -1990,12 +2224,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_num___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Level_num___closed__4() { +lean_object* _init_l_Lean_Parser_Level_num___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Level_num___closed__2; -x_2 = l_Lean_Parser_Level_num___closed__3; +x_1 = l_Lean_Parser_Level_num___closed__3; +x_2 = l_Lean_Parser_Level_num___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); @@ -2006,7 +2240,7 @@ lean_object* _init_l_Lean_Parser_Level_num() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Level_num___closed__4; +x_1 = l_Lean_Parser_Level_num___closed__5; return x_1; } } @@ -2065,71 +2299,104 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = l_Lean_Parser_ident___elambda__1(x_1, x_2); -x_9 = l_Lean_Parser_Level_ident___elambda__1___closed__1; -x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7); -return x_10; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +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 = l_Lean_Parser_ident___elambda__1(x_1, x_8); +x_13 = l_Lean_Parser_Level_ident___elambda__1___closed__1; +x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_11); +return x_14; } 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_2, 0); -lean_inc(x_11); -x_12 = lean_array_get_size(x_11); -lean_dec(x_11); -x_13 = lean_ctor_get(x_2, 1); -lean_inc(x_13); -lean_inc(x_1); -x_14 = lean_apply_2(x_4, x_1, x_2); -x_15 = lean_ctor_get(x_14, 3); +lean_dec(x_9); +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; +x_15 = lean_ctor_get(x_2, 0); lean_inc(x_15); -if (lean_obj_tag(x_15) == 0) -{ -lean_dec(x_13); -lean_dec(x_12); -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); +x_16 = lean_array_get_size(x_15); lean_dec(x_15); -x_17 = lean_ctor_get(x_14, 1); +x_17 = lean_ctor_get(x_2, 1); lean_inc(x_17); -x_18 = lean_nat_dec_eq(x_17, x_13); -lean_dec(x_17); -if (x_18 == 0) +lean_inc(x_1); +x_18 = lean_apply_2(x_4, x_1, x_2); +x_19 = lean_ctor_get(x_18, 3); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) { +lean_dec(x_17); lean_dec(x_16); -lean_dec(x_13); -lean_dec(x_12); lean_dec(x_1); -return x_14; +return x_18; } else { -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(x_13); -x_19 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13); -lean_dec(x_12); +lean_object* x_20; lean_object* x_21; uint8_t x_22; x_20 = lean_ctor_get(x_19, 0); lean_inc(x_20); -x_21 = lean_array_get_size(x_20); +lean_dec(x_19); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +x_22 = lean_nat_dec_eq(x_21, x_17); +lean_dec(x_21); +if (x_22 == 0) +{ lean_dec(x_20); -x_22 = l_Lean_Parser_ident___elambda__1(x_1, x_19); -x_23 = l_Lean_Parser_Level_ident___elambda__1___closed__1; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_21); -x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_16, x_13); -lean_dec(x_13); -return x_25; +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_1); +return x_18; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_inc(x_17); +x_23 = l_Lean_Parser_ParserState_restore(x_18, x_16, x_17); +lean_dec(x_16); +x_24 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_25 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_26 = l_Lean_Parser_checkRbpLtFn(x_24, 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_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_26, 0); +lean_inc(x_28); +x_29 = lean_array_get_size(x_28); +lean_dec(x_28); +x_30 = l_Lean_Parser_ident___elambda__1(x_1, x_26); +x_31 = l_Lean_Parser_Level_ident___elambda__1___closed__1; +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_29); +x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_20, x_17); +lean_dec(x_17); +return x_33; +} +else +{ +lean_object* x_34; +lean_dec(x_27); +lean_dec(x_1); +x_34 = l_Lean_Parser_mergeOrElseErrors(x_26, x_20, x_17); +lean_dec(x_17); +return x_34; +} } } } @@ -2150,16 +2417,26 @@ return x_4; lean_object* _init_l_Lean_Parser_Level_ident___closed__2() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Level_ident___closed__1; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Level_ident___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__3; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Level_ident___closed__1; +x_3 = l_Lean_Parser_Level_ident___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Level_ident___closed__3() { +lean_object* _init_l_Lean_Parser_Level_ident___closed__4() { _start: { lean_object* x_1; @@ -2167,12 +2444,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Level_ident___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Level_ident___closed__4() { +lean_object* _init_l_Lean_Parser_Level_ident___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Level_ident___closed__2; -x_2 = l_Lean_Parser_Level_ident___closed__3; +x_1 = l_Lean_Parser_Level_ident___closed__3; +x_2 = l_Lean_Parser_Level_ident___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); @@ -2183,7 +2460,7 @@ lean_object* _init_l_Lean_Parser_Level_ident() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Level_ident___closed__4; +x_1 = l_Lean_Parser_Level_ident___closed__5; return x_1; } } @@ -2261,91 +2538,106 @@ return x_3; lean_object* l_Lean_Parser_Level_addLit___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_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); -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_Lean_Parser_Level_addLit___elambda__1___closed__3; -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; -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_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; +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = lean_unsigned_to_nat(65u); +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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) { -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; +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_17; lean_object* x_18; lean_object* x_19; +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_17 = lean_ctor_get(x_5, 1); +lean_inc(x_17); +lean_inc(x_1); +x_18 = l_Lean_Parser_tokenFn(x_1, x_5); +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; +x_20 = lean_ctor_get(x_18, 0); +lean_inc(x_20); +x_21 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_20); +lean_dec(x_20); +if (lean_obj_tag(x_21) == 2) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; +x_22 = lean_ctor_get(x_21, 1); +lean_inc(x_22); +lean_dec(x_21); +x_23 = l_Lean_Parser_Level_addLit___elambda__1___closed__3; +x_24 = lean_string_dec_eq(x_22, x_23); +lean_dec(x_22); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; +x_25 = l_Lean_Parser_Level_addLit___elambda__1___closed__6; +x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_25, x_17); +x_9 = x_26; +goto block_16; +} +else +{ +lean_dec(x_17); +x_9 = x_18; +goto block_16; +} +} +else +{ +lean_object* x_27; lean_object* x_28; +lean_dec(x_21); +x_27 = l_Lean_Parser_Level_addLit___elambda__1___closed__6; +x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_27, x_17); +x_9 = x_28; +goto block_16; +} +} +else +{ +lean_object* x_29; lean_object* x_30; +lean_dec(x_19); +x_29 = l_Lean_Parser_Level_addLit___elambda__1___closed__6; +x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_29, x_17); +x_9 = x_30; +goto block_16; +} +block_16: +{ +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_object* x_13; +x_11 = l_Lean_Parser_numLit___elambda__1(x_1, x_9); +x_12 = l_Lean_Parser_Level_addLit___elambda__1___closed__2; +x_13 = l_Lean_Parser_ParserState_mkTrailingNode(x_11, x_12, x_8); +lean_dec(x_8); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; +lean_dec(x_10); +lean_dec(x_1); +x_14 = l_Lean_Parser_Level_addLit___elambda__1___closed__2; +x_15 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_14, x_8); +lean_dec(x_8); +return x_15; +} +} } else { -lean_object* x_10; lean_object* x_11; lean_dec(x_6); lean_dec(x_1); -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; -} +return x_5; } } } @@ -2353,41 +2645,40 @@ lean_object* _init_l_Lean_Parser_Level_addLit___closed__1() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = lean_unsigned_to_nat(65u); -x_2 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_2, 0, x_1); +x_1 = l_Lean_Parser_Level_addLit___elambda__1___closed__3; +x_2 = l_Lean_Parser_symbolInfo(x_1); return x_2; } } lean_object* _init_l_Lean_Parser_Level_addLit___closed__2() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Level_addLit___elambda__1___closed__3; -x_2 = l_Lean_Parser_Level_addLit___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_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__1; +x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); +return x_4; } } 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_numLit; -x_2 = lean_ctor_get(x_1, 0); -lean_inc(x_2); -x_3 = l_Lean_Parser_Level_addLit___closed__2; -x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); -return x_4; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Level_addLit___elambda__1___closed__2; +x_2 = l_Lean_Parser_Level_addLit___closed__2; +x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Level_addLit___closed__4() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Level_addLit___elambda__1___closed__2; +x_1 = l_Lean_Parser_epsilonInfo; x_2 = l_Lean_Parser_Level_addLit___closed__3; -x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } } @@ -2463,6 +2754,8 @@ l_Lean_Parser_Level_paren___elambda__1___closed__5 = _init_l_Lean_Parser_Level_p 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___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(); @@ -2477,6 +2770,8 @@ l_Lean_Parser_Level_paren___closed__6 = _init_l_Lean_Parser_Level_paren___closed lean_mark_persistent(l_Lean_Parser_Level_paren___closed__6); l_Lean_Parser_Level_paren___closed__7 = _init_l_Lean_Parser_Level_paren___closed__7(); lean_mark_persistent(l_Lean_Parser_Level_paren___closed__7); +l_Lean_Parser_Level_paren___closed__8 = _init_l_Lean_Parser_Level_paren___closed__8(); +lean_mark_persistent(l_Lean_Parser_Level_paren___closed__8); l_Lean_Parser_Level_paren = _init_l_Lean_Parser_Level_paren(); lean_mark_persistent(l_Lean_Parser_Level_paren); res = l___regBuiltinParser_Lean_Parser_Level_paren(lean_io_mk_world()); @@ -2510,6 +2805,8 @@ l_Lean_Parser_Level_max___closed__6 = _init_l_Lean_Parser_Level_max___closed__6( lean_mark_persistent(l_Lean_Parser_Level_max___closed__6); l_Lean_Parser_Level_max___closed__7 = _init_l_Lean_Parser_Level_max___closed__7(); lean_mark_persistent(l_Lean_Parser_Level_max___closed__7); +l_Lean_Parser_Level_max___closed__8 = _init_l_Lean_Parser_Level_max___closed__8(); +lean_mark_persistent(l_Lean_Parser_Level_max___closed__8); l_Lean_Parser_Level_max = _init_l_Lean_Parser_Level_max(); lean_mark_persistent(l_Lean_Parser_Level_max); res = l___regBuiltinParser_Lean_Parser_Level_max(lean_io_mk_world()); @@ -2541,6 +2838,8 @@ l_Lean_Parser_Level_imax___closed__5 = _init_l_Lean_Parser_Level_imax___closed__ lean_mark_persistent(l_Lean_Parser_Level_imax___closed__5); l_Lean_Parser_Level_imax___closed__6 = _init_l_Lean_Parser_Level_imax___closed__6(); lean_mark_persistent(l_Lean_Parser_Level_imax___closed__6); +l_Lean_Parser_Level_imax___closed__7 = _init_l_Lean_Parser_Level_imax___closed__7(); +lean_mark_persistent(l_Lean_Parser_Level_imax___closed__7); l_Lean_Parser_Level_imax = _init_l_Lean_Parser_Level_imax(); lean_mark_persistent(l_Lean_Parser_Level_imax); res = l___regBuiltinParser_Lean_Parser_Level_imax(lean_io_mk_world()); @@ -2570,6 +2869,8 @@ l_Lean_Parser_Level_hole___closed__4 = _init_l_Lean_Parser_Level_hole___closed__ lean_mark_persistent(l_Lean_Parser_Level_hole___closed__4); l_Lean_Parser_Level_hole___closed__5 = _init_l_Lean_Parser_Level_hole___closed__5(); lean_mark_persistent(l_Lean_Parser_Level_hole___closed__5); +l_Lean_Parser_Level_hole___closed__6 = _init_l_Lean_Parser_Level_hole___closed__6(); +lean_mark_persistent(l_Lean_Parser_Level_hole___closed__6); l_Lean_Parser_Level_hole = _init_l_Lean_Parser_Level_hole(); lean_mark_persistent(l_Lean_Parser_Level_hole); res = l___regBuiltinParser_Lean_Parser_Level_hole(lean_io_mk_world()); @@ -2589,6 +2890,8 @@ l_Lean_Parser_Level_num___closed__3 = _init_l_Lean_Parser_Level_num___closed__3( lean_mark_persistent(l_Lean_Parser_Level_num___closed__3); l_Lean_Parser_Level_num___closed__4 = _init_l_Lean_Parser_Level_num___closed__4(); lean_mark_persistent(l_Lean_Parser_Level_num___closed__4); +l_Lean_Parser_Level_num___closed__5 = _init_l_Lean_Parser_Level_num___closed__5(); +lean_mark_persistent(l_Lean_Parser_Level_num___closed__5); l_Lean_Parser_Level_num = _init_l_Lean_Parser_Level_num(); lean_mark_persistent(l_Lean_Parser_Level_num); res = l___regBuiltinParser_Lean_Parser_Level_num(lean_io_mk_world()); @@ -2608,6 +2911,8 @@ l_Lean_Parser_Level_ident___closed__3 = _init_l_Lean_Parser_Level_ident___closed lean_mark_persistent(l_Lean_Parser_Level_ident___closed__3); l_Lean_Parser_Level_ident___closed__4 = _init_l_Lean_Parser_Level_ident___closed__4(); lean_mark_persistent(l_Lean_Parser_Level_ident___closed__4); +l_Lean_Parser_Level_ident___closed__5 = _init_l_Lean_Parser_Level_ident___closed__5(); +lean_mark_persistent(l_Lean_Parser_Level_ident___closed__5); l_Lean_Parser_Level_ident = _init_l_Lean_Parser_Level_ident(); lean_mark_persistent(l_Lean_Parser_Level_ident); res = l___regBuiltinParser_Lean_Parser_Level_ident(lean_io_mk_world()); diff --git a/stage0/stdlib/Lean/Parser/Module.c b/stage0/stdlib/Lean/Parser/Module.c index 0a173c98d1..9d11486643 100644 --- a/stage0/stdlib/Lean/Parser/Module.c +++ b/stage0/stdlib/Lean/Parser/Module.c @@ -141,7 +141,7 @@ lean_object* l_Lean_Parser_Module_prelude___closed__1; lean_object* l___private_Lean_Parser_Module_2__mkEOI___closed__1; lean_object* l_Lean_Parser_Module_header___closed__7; lean_object* l_Lean_Parser_Module_import___closed__7; -lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolInfo(lean_object*); lean_object* l_IO_FS_Handle_getLine___at_Lean_Parser_parseFile___spec__3(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*); @@ -168,7 +168,6 @@ uint8_t l_PersistentArray_anyM___at_Lean_MessageLog_hasErrors___spec__1(lean_obj lean_object* l_Lean_Parser_Module_prelude___elambda__1___closed__3; lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Parser_Module_import___elambda__1___closed__9; -extern lean_object* l_Lean_Syntax_decodeNatLitVal___closed__1; lean_object* l_PersistentArray_forM___at___private_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(lean_object*, lean_object*, lean_object*); lean_object* l_IO_FS_Handle_readToEndAux___main___at_Lean_Parser_parseFile___spec__2(lean_object*, lean_object*, lean_object*); lean_object* l_IO_FS_Handle_mk___at_IO_FS_withFile___spec__1(lean_object*, uint8_t, uint8_t, lean_object*); @@ -493,11 +492,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Module_prelude___closed__1() { _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_Module_prelude___elambda__1___closed__7; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Module_prelude___closed__2() { @@ -1236,21 +1234,19 @@ return x_140; lean_object* _init_l_Lean_Parser_Module_import___closed__1() { _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_Module_import___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Module_import___closed__2() { _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_Module_import___elambda__1___closed__8; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Module_import___closed__3() { diff --git a/stage0/stdlib/Lean/Parser/Parser.c b/stage0/stdlib/Lean/Parser/Parser.c index dac4f7ca8e..6cd936565e 100644 --- a/stage0/stdlib/Lean/Parser/Parser.c +++ b/stage0/stdlib/Lean/Parser/Parser.c @@ -18,20 +18,22 @@ lean_object* l_Lean_Parser_nonReservedSymbol___boxed(lean_object*, lean_object*) lean_object* l_List_reverse___rarg(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___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg(lean_object*); lean_object* l_Lean_Syntax_foldArgs___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__1(lean_object*); lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Lean_Parser_Parser_11__noImmediateColon; +lean_object* l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); lean_object* l_Lean_Parser_declareLeadingBuiltinParser___closed__2; lean_object* l_Lean_Parser_builtinTokenTable; 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; -uint8_t l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__1(lean_object*, lean_object*); +lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__1(lean_object*, lean_object*); +lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__1___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_andthenInfo___elambda__1(lean_object*, lean_object*, lean_object*); -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__6(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_15__addBuiltinParserCategory___spec__1(lean_object*, lean_object*); -lean_object* l_Lean_Parser_symbolAux___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolAux___boxed(lean_object*); lean_object* l_Lean_Parser_hashOrelse; 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); @@ -41,16 +43,17 @@ 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*); lean_object* l_Lean_Parser_declareLeadingBuiltinParser___closed__1; +lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__3___boxed(lean_object*, lean_object*); uint8_t l_RBNode_isRed___rarg(lean_object*); uint8_t l_Lean_Parser_checkTailWs(lean_object*); lean_object* l_Lean_Parser_mkParserExtension___closed__1; +lean_object* l___private_Lean_Parser_Parser_24__catNameToString(lean_object*); lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_hexNumberFn___spec__1(lean_object*, lean_object*, lean_object*); 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___private_Lean_Parser_Parser_23__catNameToString(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*); @@ -61,7 +64,6 @@ lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_octalNumberFn___s 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_declareBuiltinParser___closed__8; -lean_object* l_Lean_Parser_TokenConfig_toStr___closed__1; 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*); @@ -78,7 +80,6 @@ extern lean_object* l_Lean_nullKind; 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_Lean_Parser_strLitNoAntiquot; -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_octalNumberFn___closed__1; lean_object* l_Lean_Parser_many1___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_many(lean_object*); @@ -91,10 +92,11 @@ lean_object* l_Lean_Parser_strAux___boxed(lean_object*, lean_object*, lean_objec lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_rawCh___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_List_repr___rarg___closed__1; extern uint32_t l_Lean_idBeginEscape; -lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__3(lean_object*, lean_object*); +lean_object* l___private_Lean_Parser_Parser_26__ParserAttribute_add___boxed(lean_object*, lean_object*, lean_object*, 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*); lean_object* l_Lean_Parser_optionaInfo___elambda__2(lean_object*, lean_object*); lean_object* l_Lean_Parser_ParserFn_inhabited___rarg(lean_object*); +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__4(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_binNumberFn___closed__1; lean_object* l_Lean_Parser_hexNumberFn___closed__1; lean_object* l_Lean_Syntax_foldSepRevArgs(lean_object*); @@ -102,27 +104,29 @@ lean_object* l_Lean_Parser_binNumberFn___boxed(lean_object*, lean_object*, lean_ lean_object* l_List_foldlM___main___at_Lean_Parser_addParserTokens___spec__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_numberFnAux(lean_object*, lean_object*); lean_object* l_Lean_Parser_identEqFn___closed__1; -lean_object* l_Lean_Parser_TokenConfig_HasToString___closed__1; 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_Parser_unicodeSymbolInfo___elambda__2(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___private_Lean_Parser_Parser_23__ParserExtension_addImported(lean_object*, lean_object*, lean_object*); 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* 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___private_Lean_Parser_Parser_11__noImmediateColon___closed__2; 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_Lean_Parser_longestMatchFn(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_fieldIdx___closed__6; +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_registerBuiltinParserAttribute___closed__1; lean_object* l_Lean_Parser_nameLitNoAntiquot; -lean_object* l___private_Lean_Parser_Parser_10__noImmediateColon; 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_Lean_Parser_Parser_11__noImmediateColon___closed__1; 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_Trie_matchPrefix___rarg(lean_object*, lean_object*, lean_object*); @@ -135,14 +139,12 @@ lean_object* l_Lean_Parser_hexNumberFn(lean_object*, lean_object*, lean_object*) lean_object* l_Array_foldSepBy___rarg___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_strLitFnAux(lean_object*, lean_object*, lean_object*); uint8_t l_List_elem___main___at_Lean_NameHashSet_insert___spec__2(lean_object*, lean_object*); -lean_object* l_Lean_Parser_getTokenLbp_x3f___boxed(lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_Parser_SyntaxNodeKindSet_insert___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_ParserState_next(lean_object*, lean_object*, lean_object*); -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__5(lean_object*, 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* l___private_Lean_Parser_Parser_19__addTokenConfig(lean_object*, 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; @@ -166,33 +168,27 @@ lean_object* l_Lean_Parser_builtinParserCategoriesRef; lean_object* lean_environment_find(lean_object*, lean_object*); lean_object* l_Lean_Parser_parserExtension; lean_object* l_Lean_Parser_unquotedSymbolFn___closed__1; -lean_object* l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__3; 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___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2; lean_object* l_Lean_Parser_ident; lean_object* l_Lean_Parser_parserExtension___closed__2; +lean_object* l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__1; 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___private_Lean_Parser_Parser_22__ParserExtension_addImported___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_checkRbpLtFn___boxed(lean_object*, lean_object*, 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_antiquotNestedExpr___elambda__1___closed__1; -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg(lean_object*); lean_object* l_Lean_Parser_withAntiquotFn(lean_object*, lean_object*, lean_object*, lean_object*); -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_Lean_Parser_checkColGe(lean_object*, lean_object*); lean_object* l_Lean_Parser_checkRbpLtFn(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l___private_Lean_Parser_Parser_4__isToken(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_25__ParserAttribute_add___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_nonReservedSymbolFn(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_18__addTokenConfig(lean_object*, lean_object*); uint8_t l_Char_isDigit(uint32_t); -lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_ParserState_mkNode(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_mkParserState(lean_object*); lean_object* l_List_append___rarg(lean_object*, lean_object*); @@ -201,6 +197,7 @@ lean_object* l_Lean_Parser_categoryParserFnExtension___closed__2; lean_object* l_Lean_Parser_nameLitNoAntiquot___closed__1; 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_IO_ofExcept___at___private_Lean_Parser_Parser_16__addBuiltinParserCategory___spec__1___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_many1Indent___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1(lean_object*, lean_object*); lean_object* lean_io_ref_get(lean_object*, lean_object*); @@ -208,6 +205,8 @@ lean_object* l_Lean_Parser_satisfyFn___boxed(lean_object*, lean_object*, lean_ob lean_object* l_Lean_Parser_declareBuiltinParser___closed__5; extern uint32_t l_Lean_idEndEscape; lean_object* l_Lean_Parser_mkAntiquot___closed__9; +lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_16__addBuiltinParserCategory___spec__1(lean_object*, lean_object*); +lean_object* l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__1___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__8; 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*); @@ -222,21 +221,20 @@ lean_object* l_Lean_Parser_symbolNoWsFn___boxed(lean_object*, lean_object*, lean lean_object* l_Lean_Parser_ParserState_mkTrailingNode(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_quotedSymbol___closed__2; -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_mkAntiquot___closed__4; -lean_object* l___private_Lean_Parser_Parser_19__addTrailingParserAux(lean_object*, lean_object*); 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_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(uint32_t, uint8_t, lean_object*, lean_object*); lean_object* lean_array_get_size(lean_object*); +lean_object* l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__1; 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* l_Lean_Parser_tokenFn(lean_object*, lean_object*); +lean_object* l_List_foldlM___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__1(lean_object*, lean_object*, 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; @@ -250,12 +248,14 @@ 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* l_Lean_Parser_withPosition(lean_object*); +lean_object* l___private_Lean_Parser_Parser_20__addTrailingParserAux(lean_object*, lean_object*); lean_object* l_Lean_Parser_mkAntiquot___closed__11; lean_object* l_Lean_Parser_charLitFnAux(lean_object*, lean_object*, lean_object*); extern lean_object* l_List_repr___rarg___closed__3; lean_object* l_Lean_Parser_quotedSymbol___closed__1; lean_object* l_Lean_Parser_leadingParserAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); 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_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__2___boxed(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_Lean_Parser_tryAnti___boxed(lean_object*, lean_object*); @@ -268,7 +268,7 @@ lean_object* l_Lean_Parser_symbolFnAux___boxed(lean_object*, lean_object*, lean_ lean_object* l_Lean_Parser_mkNodeToken___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_initCacheForInput___boxed(lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_forArgsM___spec__1(lean_object*); -lean_object* l_Lean_Parser_symbolNoWs___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolNoWs___boxed(lean_object*); lean_object* l_Lean_Parser_isParserCategory___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_declareBuiltinParser___closed__2; lean_object* lean_string_utf8_byte_size(lean_object*); @@ -279,7 +279,7 @@ lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParser 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_symbolNoWsInfo___elambda__2(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolNoWsInfo___elambda__2(lean_object*, lean_object*); 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; @@ -330,7 +330,6 @@ lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; 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_List_foldl___main___at___private_Lean_Parser_Parser_19__addTrailingParserAux___spec__1(lean_object*, lean_object*, lean_object*); 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; @@ -346,19 +345,15 @@ lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgs___spec__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_setCategoryParserFnRef(lean_object*); lean_object* l_Lean_Syntax_forArgsM(lean_object*); lean_object* l_Lean_Parser_throwUnknownParserCategory(lean_object*); lean_object* l___private_Lean_Parser_Parser_6__nameLitAux(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_mkAntiquot___closed__15; -lean_object* l_Lean_Parser_checkRbpLt___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); 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___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); -lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__1___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_throwUnknownParserCategory___rarg___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*); @@ -367,7 +362,7 @@ lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgsM___spec__ lean_object* l_Lean_Parser_declareTrailingBuiltinParser___closed__2; lean_object* l_Lean_Parser_nonReservedSymbolInfo___elambda__2(lean_object*); lean_object* l_Lean_Parser_initCacheForInput(lean_object*); -lean_object* l_Lean_Parser_symbolNoWsAux(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolNoWsAux(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_antiquotNestedExpr___elambda__1___closed__4; lean_object* l_Lean_Parser_mkAntiquot___closed__18; @@ -379,10 +374,9 @@ 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* l_Lean_Parser_unicodeSymbol(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Parser_unicodeSymbol(lean_object*, lean_object*); lean_object* l_Lean_Parser_longestMatchFn___closed__1; lean_object* l_Lean_Parser_checkStackTopFn(lean_object*, lean_object*, lean_object*); -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__6___boxed(lean_object*, lean_object*, lean_object*, 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*); @@ -393,6 +387,7 @@ lean_object* l_Lean_Parser_mkTokenAndFixPos___closed__1; 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_List_foldlM___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__1___closed__1; 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_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*); @@ -407,7 +402,6 @@ lean_object* l_Lean_Parser_hasAndthen; 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_antiquotNestedExpr___closed__9; lean_object* l_Lean_Parser_Error_HasBeq___closed__1; lean_object* l_Lean_Parser_nonReservedSymbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_foldSepArgsM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -430,8 +424,10 @@ 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___private_Lean_Parser_Parser_22__ParserExtension_addEntry(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___private_Lean_Parser_Parser_13__mkTrailingResult(lean_object*, lean_object*); lean_object* l_Lean_Parser_quotedSymbol; lean_object* l_Lean_Parser_numLitNoAntiquot___closed__1; lean_object* lean_nat_sub(lean_object*, lean_object*); @@ -451,14 +447,13 @@ lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__1; lean_object* lean_array_swap(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_strLitKind; lean_object* l_Lean_Parser_nonReservedSymbolInfo(lean_object*, uint8_t); +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*); 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___private_Lean_Parser_Parser_22__ParserExtension_addImported(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_finishCommentBlock___boxed(lean_object*, 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*, lean_object*); lean_object* l_Lean_Syntax_foldArgs(lean_object*); lean_object* l_Lean_Parser_nonReservedSymbolInfo___elambda__1(lean_object*); -lean_object* l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4(lean_object*, size_t, size_t, lean_object*, lean_object*); lean_object* l_Lean_Parser_nodeInfo___elambda__1(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Error_merge(lean_object*, lean_object*); lean_object* l_Lean_Parser_mkParserOfConstantUnsafe(lean_object*, lean_object*, lean_object*); @@ -471,9 +466,7 @@ lean_object* l_Array_findRevMAux___main___at___private_Lean_Parser_Parser_9__pic 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___private_Lean_Parser_Parser_16__ParserExtension_mkInitial(lean_object*); lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg(lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_11__mkResult(lean_object*, lean_object*); lean_object* l_Lean_Parser_withAntiquot(lean_object*, lean_object*); lean_object* l_Lean_Parser_antiquotNestedExpr___closed__8; lean_object* l_Lean_Parser_fieldIdx___closed__3; @@ -482,15 +475,14 @@ lean_object* l_Lean_Parser_mkAntiquot___closed__26; lean_object* l_Lean_Parser_ParserState_keepNewError(lean_object*, lean_object*); lean_object* l_Lean_Parser_antiquotExpr; lean_object* l_Lean_Parser_regTermParserAttribute___closed__1; -lean_object* l_Lean_Parser_symbol(lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_21__ParserExtension_addEntry(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbol(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___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__2; 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___private_Lean_Parser_Parser_17__ParserExtension_mkInitial(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*); @@ -498,8 +490,8 @@ lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); uint8_t l_Lean_Parser_tryAnti(lean_object*, lean_object*); extern lean_object* l_Lean_numLitKind___closed__1; lean_object* l_Lean_Parser_optionaInfo(lean_object*); +lean_object* l___private_Lean_Parser_Parser_12__mkResult(lean_object*, lean_object*); lean_object* l_Lean_Parser_FirstTokens_seq(lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__1; 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; @@ -513,13 +505,13 @@ lean_object* l_Lean_Parser_nameLit; 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_PersistentHashMap_contains___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__1___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_charLitNoAntiquot___closed__3; lean_object* l_Lean_Parser_peekTokenAux(lean_object*, lean_object*); lean_object* l_Lean_Parser_Error_HasBeq; -lean_object* l___private_Lean_Parser_Parser_15__addBuiltinParserCategory(lean_object*, uint8_t, lean_object*); lean_object* l_Lean_Parser_nonReservedSymbolInfo___closed__3; +lean_object* l___private_Lean_Parser_Parser_16__addBuiltinParserCategory(lean_object*, uint8_t, lean_object*); lean_object* l_Lean_Parser_parserExtension___elambda__4(lean_object*, lean_object*); +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Error_Inhabited___closed__1; lean_object* l_Lean_Parser_throwUnknownParserCategory___rarg(lean_object*); lean_object* l_Lean_Parser_ParserState_shrinkStack(lean_object*, lean_object*); @@ -527,12 +519,10 @@ uint8_t l_Lean_Parser_checkTailNoWs(lean_object*); lean_object* l_Lean_Parser_checkTailWs___boxed(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___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1(lean_object*); 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_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___private_Lean_Parser_Parser_12__mkTrailingResult(lean_object*, lean_object*); lean_object* l_Lean_Parser_setExpectedFn(lean_object*); lean_object* l_Lean_Parser_strLitFn(lean_object*, lean_object*); lean_object* l_Lean_Parser_mkParserExtension___lambda__2___boxed(lean_object*); @@ -558,7 +548,6 @@ lean_object* l_Lean_Parser_checkWsBefore(lean_object*); lean_object* l_Lean_Parser_checkNoWsBeforeFn(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_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4___boxed(lean_object*, lean_object*, lean_object*, 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*); @@ -573,19 +562,19 @@ lean_object* l_Lean_Parser_nameLit___closed__2; lean_object* l_Lean_Parser_strLitNoAntiquot___closed__1; 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___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__1; lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_chFn___spec__1(uint32_t, lean_object*, lean_object*, lean_object*); extern lean_object* l_PersistentHashMap_insertAux___main___rarg___closed__3; -lean_object* l_List_foldlM___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__1___closed__1; 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_IO_ofExcept___at_Lean_Parser_declareBuiltinParser___spec__1(lean_object*, lean_object*); +lean_object* l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1___boxed(lean_object*, 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; extern lean_object* l_List_repr___rarg___closed__2; extern lean_object* l_Lean_charLitKind; +lean_object* l___private_Lean_Parser_Parser_16__addBuiltinParserCategory___boxed(lean_object*, lean_object*, 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_TokenMap_Inhabited(lean_object*); @@ -594,30 +583,28 @@ lean_object* l_Lean_Parser_categoryParserFnExtension___elambda__1___rarg___boxed lean_object* l_Lean_Parser_regTermParserAttribute___closed__2; 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___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__2; lean_object* l___private_Lean_Parser_Parser_9__pickNonNone___boxed(lean_object*); lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; lean_object* l_Lean_Parser_FirstTokens_merge(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_Lean_Parser_checkRbpLe(lean_object*, lean_object*); +lean_object* l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1___closed__1; lean_object* lean_eval_const(lean_object*, lean_object*); lean_object* l_Lean_Parser_mkParserAttributeImpl(lean_object*, lean_object*); lean_object* l_Lean_Parser_fieldIdx___closed__5; -lean_object* l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2; -lean_object* l_Lean_Parser_symbolInfo___elambda__2(lean_object*, lean_object*, lean_object*); +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolInfo___elambda__2(lean_object*, lean_object*); +lean_object* l___private_Lean_Parser_Parser_15__addParserCategoryCore(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_charLit___closed__2; lean_object* l_Lean_Parser_ParserFn_inhabited(lean_object*); lean_object* l_Lean_Parser_ParserExtensionState_inhabited; -lean_object* l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); 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___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__1; lean_object* l_Lean_Parser_compileParserDescr(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___private_Lean_Parser_Parser_14__addParserCategoryCore(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_nonReservedSymbolInfo___elambda__1___boxed(lean_object*); lean_object* l_Lean_Parser_setCategoryParserFnRef___closed__1; @@ -631,13 +618,14 @@ uint32_t lean_string_utf8_get(lean_object*, lean_object*); lean_object* l_Lean_Parser_declareBuiltinParser___closed__7; extern lean_object* l_Lean_Environment_evalConstCheck___rarg___closed__1; lean_object* l_Lean_Parser_parserExtension___elambda__2(lean_object*); +uint8_t l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__2(lean_object*, size_t, lean_object*); lean_object* l_Lean_Parser_mkAntiquot___closed__13; 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(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* l_Lean_Parser_unicodeSymbol___boxed(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_Lean_Parser_mkAntiquot___closed__23; @@ -650,16 +638,16 @@ lean_object* l_Lean_Parser_registerBuiltinParserAttribute(lean_object*, lean_obj lean_object* l_Lean_Parser_charLitNoAntiquot___closed__1; lean_object* l_Array_qsortAux___main___at_Lean_Parser_Error_toString___spec__2___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_categoryParserFnExtension___closed__3; +lean_object* l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__2; 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_symbolNoWsAux___boxed(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___private_Lean_Parser_Parser_18__mergePrecendences(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolNoWsInfo(lean_object*); lean_object* l_Lean_Parser_epsilonInfo___elambda__1___boxed(lean_object*); -lean_object* l___private_Lean_Parser_Parser_17__mergePrecendences(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_registerBuiltinAttribute(lean_object*, lean_object*); lean_object* l_Lean_FileMap_toPosition(lean_object*, lean_object*); -lean_object* l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_mkAtomicInfo___elambda__1(lean_object*); lean_object* l_Lean_Parser_anyOfFn(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_mkEmptySubstringAt(lean_object*, lean_object*); @@ -671,9 +659,9 @@ lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgs___spec__1 lean_object* l_IO_Prim_Ref_get___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_longestMatchMkResult(lean_object*, lean_object*); size_t l_USize_mul(size_t, size_t); -lean_object* l___private_Lean_Parser_Parser_18__addTokenConfig___closed__1; lean_object* l_Lean_FileMap_ofString(lean_object*); lean_object* l_Lean_Parser_whitespace(lean_object*, lean_object*); +lean_object* l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4___boxed(lean_object*, lean_object*, lean_object*, 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(uint32_t, uint8_t); @@ -684,10 +672,12 @@ lean_object* l_PersistentHashMap_empty___at_Lean_Parser_mkBuiltinParserCategorie lean_object* l_Lean_Parser_ParserState_restore___boxed(lean_object*, 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(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolAux(lean_object*); lean_object* l_Lean_Parser_isValidSyntaxNodeKind___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_antiquotNestedExpr___closed__3; lean_object* l_Lean_Parser_sepBy1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Lean_Parser_Parser_21__updateBuiltinTokens(lean_object*, lean_object*, lean_object*); +lean_object* l_PersistentHashMap_insertAtCollisionNodeAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__5(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Lean_Data_Trie_2__insertAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_strLit___closed__3; lean_object* l_Lean_Parser_mkParserExtension(lean_object*); @@ -697,8 +687,6 @@ lean_object* l_Lean_Parser_sepByFn___boxed(lean_object*, lean_object*, lean_obje lean_object* l_Lean_Parser_mkBuiltinTokenTable(lean_object*); lean_object* l_Lean_Parser_FirstTokens_toStr___closed__3; lean_object* l_Lean_Parser_manyAux(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_15__addBuiltinParserCategory___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_20__updateBuiltinTokens(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_addTrailingParser(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_mkAntiquot___closed__7; @@ -712,11 +700,9 @@ lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_quotedSymbolFn___spec__1(u lean_object* l_Lean_Parser_trailingNodeFn(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_rawIdent___closed__2; lean_object* l_Lean_Parser_addBuiltinLeadingParser(lean_object*, lean_object*, lean_object*, lean_object*); -uint8_t l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__2(lean_object*, size_t, lean_object*); 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_regBuiltinTermParserAttr___closed__1; -lean_object* l_Lean_Parser_prattParser___closed__1; lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; lean_object* l_Lean_Parser_rawIdentNoAntiquot___closed__2; lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*); @@ -736,7 +722,7 @@ lean_object* l_Lean_Parser_mkParserAttributeImpl___elambda__1___boxed(lean_objec lean_object* l_Lean_Parser_sepBy1Info(lean_object*, lean_object*); lean_object* l_Lean_Parser_quotedCharFn___closed__1; lean_object* l_Lean_Parser_charLitFnAux___closed__1; -lean_object* l_Lean_Parser_symbolNoWs(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolNoWs(lean_object*); lean_object* l_Lean_Parser_hexDigitFn___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_ParserState_mergeErrors___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Array_foldSepBy(lean_object*); @@ -749,13 +735,13 @@ lean_object* l_Lean_Parser_quotedCharFn___boxed(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; +lean_object* l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder(lean_object*); uint8_t l_Array_anyRangeMAux___main___at_Lean_Parser_mkParserExtension___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l___private_Lean_Compiler_InitAttr_1__getIOTypeArg___closed__1; -lean_object* l_Lean_Parser_TokenConfig_beq___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Parser_dollarSymbol___elambda__1___closed__5; extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__3; lean_object* l_Lean_Parser_noFirstTokenInfo___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_ident___elambda__1___closed__1; -lean_object* l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder(lean_object*); lean_object* l_Lean_Parser_declareLeadingBuiltinParser(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_appPrec; lean_object* l_Lean_Parser_checkColGeFn(lean_object*, lean_object*, lean_object*, lean_object*); @@ -764,6 +750,7 @@ lean_object* l_Lean_Parser_charLitFnAux___boxed(lean_object*, lean_object*, lean 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_Array_foldSepByM___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__2___boxed(lean_object*, lean_object*, lean_object*, 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; @@ -773,7 +760,7 @@ lean_object* l_Lean_Parser_ident___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_Error_HasToString; 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* l_Lean_Parser_symbol___boxed(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_charLit___elambda__1(lean_object*, lean_object*); uint8_t l_UInt32_decEq(uint32_t, uint32_t); @@ -782,18 +769,15 @@ lean_object* l_Lean_Parser_unquotedSymbolFn(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; -lean_object* l___private_Lean_Parser_Parser_17__mergePrecendences___closed__3; lean_object* l_Lean_Parser_leadingParser___boxed(lean_object*, 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* l_Lean_Parser_mkAntiquot___closed__16; +lean_object* l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__2; lean_object* l___private_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___private_Lean_Parser_Parser_20__updateBuiltinTokens___closed__1; lean_object* l_Lean_Parser_compileParserDescr___main___closed__2; -lean_object* l_Lean_Parser_getTokenLbp_x3f(lean_object*, lean_object*); lean_object* l_Lean_Parser_FirstTokens_HasToString___closed__1; lean_object* l_Lean_Parser_FirstTokens_HasToString; -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*); 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*); @@ -803,6 +787,7 @@ lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg___bo 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* l_Array_foldlStepMAux___main___at_Array_foldSepBy___spec__1(lean_object*); +lean_object* l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1(lean_object*); lean_object* l_Lean_Parser_ParserState_keepNewError___boxed(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*); @@ -810,6 +795,7 @@ lean_object* l_Lean_Parser_mkAntiquot___closed__24; 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___private_Lean_Parser_Parser_10__precErrorMsg; lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_tryFn(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_whitespace___main___boxed(lean_object*, lean_object*); @@ -831,6 +817,7 @@ lean_object* l_Lean_Syntax_getArgs(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(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getKind(lean_object*); +lean_object* l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4(lean_object*, size_t, size_t, lean_object*, 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___private_Lean_Parser_Parser_1__expectedToString(lean_object*); lean_object* l_Lean_Parser_chFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -844,22 +831,23 @@ lean_object* l_Lean_Parser_runParserCategory(lean_object*, lean_object*, lean_ob 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_Lean_Parser_setExpectedFn___boxed(lean_object*); +lean_object* l___private_Lean_Parser_Parser_18__mergePrecendences___closed__3; lean_object* l_Array_findRevMAux___main___at___private_Lean_Parser_Parser_9__pickNonNone___spec__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_quotedSymbolFn___boxed(lean_object*, lean_object*); lean_object* l_Lean_Name_toExprAux___main(lean_object*); uint8_t l_PersistentHashMap_containsAtAux___main___at_Lean_Parser_isValidSyntaxNodeKind___spec__3(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_10__noImmediateColon___closed__2; lean_object* l_Lean_Parser_mkParserExtension___closed__5; 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_symbolInfo(lean_object*); lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_binNumberFn___spec__2(lean_object*, lean_object*); -lean_object* l_Lean_Parser_TokenConfig_toStr(lean_object*); lean_object* l_Lean_Parser_quotedSymbolFn___closed__1; lean_object* l_Lean_Parser_checkStackTop(lean_object*); +lean_object* l_List_foldl___main___at___private_Lean_Parser_Parser_20__addTrailingParserAux___spec__1(lean_object*, lean_object*, 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___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_epsilonInfo; lean_object* l_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6(lean_object*); lean_object* l_Lean_Parser_anyOfFn___main(lean_object*, lean_object*, lean_object*); @@ -869,7 +857,6 @@ lean_object* l_Lean_Parser_epsilonInfo___closed__3; lean_object* l_Lean_Parser_unquotedSymbol; lean_object* l___private_Lean_Parser_Parser_1__expectedToString___main(lean_object*); lean_object* l_Lean_Parser_hashOrelse___closed__1; -lean_object* l_Lean_Parser_checkRbpLt___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_nonReservedSymbolInfo___elambda__2___boxed(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*); @@ -881,18 +868,17 @@ lean_object* l_Lean_Parser_symbolNoWsInfo___closed__1; 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___private_Lean_Parser_Parser_25__ParserAttribute_add(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); -lean_object* l___private_Lean_Parser_Parser_10__noImmediateColon___closed__1; lean_object* lean_io_ref_swap(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_rawIdentNoAntiquot; lean_object* l_Lean_Parser_ParserState_replaceLongest(lean_object*, lean_object*, lean_object*); -uint8_t l_Lean_Parser_TokenConfig_beq(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___private_Lean_Parser_Parser_10__precErrorMsg___closed__1; lean_object* l_Lean_Parser_fieldIdxFn___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_ParserCategory_inhabited; lean_object* l_Lean_Parser_mkAntiquot___closed__19; lean_object* l_Lean_Parser_dollarSymbol___elambda__1(lean_object*, lean_object*); +lean_object* l___private_Lean_Parser_Parser_26__ParserAttribute_add(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, 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*); @@ -905,7 +891,6 @@ 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_Lean_Parser_Parser_18__addTokenConfig___closed__3; 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*, lean_object*, lean_object*); lean_object* l_Lean_Parser_numberFnAux___closed__1; @@ -939,29 +924,33 @@ lean_object* l_Lean_Parser_dollarSymbol___elambda__1___closed__4; lean_object* l_Lean_Parser_checkRbpLt(lean_object*, lean_object*); lean_object* l_Lean_Parser_compileParserDescr___main(lean_object*, lean_object*); lean_object* l_Lean_Parser_regBuiltinTermParserAttr(lean_object*); +lean_object* l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___boxed(lean_object*, lean_object*, 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_Array_toList___rarg(lean_object*); lean_object* l_Lean_Parser_checkWsBeforeFn___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_optionalFn(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_nameLitFn___closed__1; +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); 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_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__1; +lean_object* l___private_Lean_Parser_Parser_18__mergePrecendences___closed__2; 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; lean_object* l_Lean_Parser_leadingNodePrec___boxed(lean_object*, lean_object*, lean_object*); uint8_t l_Lean_isIdFirst(uint32_t); lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1___boxed(lean_object*); uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*); lean_object* l_Lean_PersistentEnvExtension_getState___rarg(lean_object*, lean_object*); +lean_object* l___private_Lean_Parser_Parser_18__mergePrecendences___closed__1; lean_object* l_Lean_Parser_ParserState_mkLongestNodeAlt(lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_17__mergePrecendences___boxed(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Parser_currLbp(lean_object*, lean_object*, lean_object*); +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__5(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_mkParserOfConstant(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_takeWhile1Fn(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_qsortAux___main___at_Lean_Parser_Error_toString___spec__2(lean_object*, lean_object*, lean_object*); lean_object* lean_io_initializing(lean_object*); lean_object* l___private_Lean_Parser_Parser_8__updateCache(lean_object*, lean_object*); extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__2; +lean_object* l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__2; lean_object* l_Lean_Parser_sepByInfo___elambda__2(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_symbolInfo___closed__1; lean_object* l_Lean_Syntax_forSepArgsM___rarg(lean_object*, lean_object*, lean_object*); @@ -971,23 +960,20 @@ lean_object* l_Lean_Parser_nameLit___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_mkAntiquot___closed__6; lean_object* l_Lean_Parser_rawIdent___closed__1; lean_object* l_Lean_Parser_parserExtension___elambda__1(lean_object*); -lean_object* l_PersistentHashMap_insertAtCollisionNodeAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__5(lean_object*, lean_object*, 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_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(lean_object*, 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* l_Lean_Parser_fieldIdx___closed__7; lean_object* l_Lean_Parser_mkAntiquot(lean_object*, lean_object*, uint8_t); -lean_object* l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1___closed__1; 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___private_Lean_Parser_Parser_1__expectedToString___main___closed__1; -lean_object* l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1___boxed(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_mkStxLit(lean_object*, lean_object*, lean_object*); -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__4___boxed(lean_object*, 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; @@ -1003,14 +989,15 @@ 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* l___private_Lean_Parser_Parser_19__addTokenConfig___closed__1; 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___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined(lean_object*); +lean_object* l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined(lean_object*); lean_object* l___private_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___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_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__4(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_epsilonInfo___elambda__2(lean_object*); lean_object* l_Lean_Parser_orelse(lean_object*, lean_object*); +lean_object* l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__2(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(lean_object*, lean_object*, lean_object*, lean_object*); @@ -1026,23 +1013,22 @@ lean_object* l_List_toArrayAux___main___rarg(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___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, 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_Lean_Parser_stringToParserCoe___boxed(lean_object*); +lean_object* l___private_Lean_Parser_Parser_19__addTokenConfig___closed__2; lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*); 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_Lean_Parser_unicodeSymbolInfo(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; lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*); -extern lean_object* l_Lean_Syntax_decodeNatLitVal___closed__1; +lean_object* l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__2___boxed(lean_object*, 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* l_Lean_Parser_leadingNodePrec___closed__1; 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*); @@ -1051,8 +1037,8 @@ lean_object* l___private_Lean_Parser_Parser_6__nameLitAux___closed__1; 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_currLbp___closed__1; lean_object* l_Lean_Parser_checkWsBefore___elambda__1(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Lean_Parser_Parser_21__updateBuiltinTokens___closed__1; 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); @@ -1062,10 +1048,10 @@ uint8_t l_Lean_Parser_ParserState_hasError(lean_object*); lean_object* l_Lean_Parser_symbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_hexDigitFn___closed__1; lean_object* l_Lean_Parser_mkAtom(lean_object*, lean_object*); -lean_object* l_Lean_Parser_currLbp___boxed(lean_object*, lean_object*, lean_object*); lean_object* l___private_Lean_Parser_Parser_4__isToken___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_ParserState_mkEOIError(lean_object*); lean_object* l___private_Lean_Parser_Parser_6__nameLitAux___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__3(lean_object*, 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*); @@ -1080,7 +1066,9 @@ lean_object* l_Lean_Parser_checkWsBefore___elambda__1___boxed(lean_object*, lean lean_object* l_Lean_Parser_ParserFn_inhabited___rarg___boxed(lean_object*); extern lean_object* l_String_Inhabited; lean_object* l_List_eraseDups___at_Lean_Parser_addLeadingParser___spec__5(lean_object*); +lean_object* l___private_Lean_Parser_Parser_23__ParserExtension_addImported___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__3; +lean_object* l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___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(lean_object*); @@ -1090,7 +1078,6 @@ lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__5; 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_Syntax_foldArgs___rarg___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_18__addTokenConfig___closed__2; 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*); @@ -1098,25 +1085,21 @@ lean_object* l_Lean_Parser_longestMatchStep___boxed(lean_object*, lean_object*, lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___boxed(lean_object*, lean_object*, lean_object*, 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_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__2___boxed(lean_object*, lean_object*, lean_object*); 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_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__2___boxed(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_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__1; lean_object* l_Lean_Parser_Parser_inhabited___closed__1; lean_object* l_Lean_Syntax_getTailInfo___main(lean_object*); lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(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*); extern lean_object* l_Lean_registerTagAttribute___lambda__4___closed__1; -lean_object* l_List_foldlM___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_initAttr; 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___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__2; 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_antiquotExpr___closed__3; lean_object* l_Lean_Parser_charLitNoAntiquot; @@ -1129,21 +1112,19 @@ 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_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(lean_object*, lean_object*, lean_object*); lean_object* l___private_Lean_Parser_Parser_5__isIdFirstOrBeginEscape___boxed(lean_object*); +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__6(size_t, lean_object*, lean_object*, 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(lean_object*, lean_object*); lean_object* l_Lean_Parser_strLit; lean_object* l_Lean_Parser_many1(lean_object*, uint8_t); -lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__3___boxed(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* l_Lean_Parser_identNoAntiquot___closed__2; uint8_t l___private_Lean_Parser_Parser_5__isIdFirstOrBeginEscape(uint32_t); -lean_object* l___private_Lean_Parser_Parser_17__mergePrecendences___closed__2; lean_object* l_Lean_Parser_strLit___closed__2; lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__2; -lean_object* l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__1; +lean_object* l___private_Lean_Parser_Parser_18__mergePrecendences___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_nonReservedSymbolInfo___boxed(lean_object*, lean_object*); -lean_object* l___private_Lean_Parser_Parser_17__mergePrecendences___closed__1; 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*); @@ -1153,19 +1134,19 @@ lean_object* l_Lean_Parser_fieldIdxFn(lean_object*, 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_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t lean_string_dec_eq(lean_object*, lean_object*); -lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_15__addBuiltinParserCategory___spec__1___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_isLitKind___boxed(lean_object*); lean_object* l_IO_ofExcept___at_Lean_Parser_declareBuiltinParser___spec__1___boxed(lean_object*, lean_object*); 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_Lean_Parser_mkAntiquot___boxed(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_PersistentHashMap_contains___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__1(lean_object*, lean_object*); uint8_t l_Lean_Syntax_isIdent(lean_object*); 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*); -lean_object* l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__2(lean_object*, lean_object*); uint8_t l_Lean_Parser_isLitKind(lean_object* x_1) { _start: { @@ -1273,243 +1254,6 @@ x_1 = lean_unsigned_to_nat(1024u); return x_1; } } -uint8_t l_Lean_Parser_TokenConfig_beq(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; uint8_t x_17; -x_3 = lean_ctor_get(x_1, 0); -x_4 = lean_ctor_get(x_1, 1); -x_5 = lean_ctor_get(x_1, 2); -x_6 = lean_ctor_get(x_2, 0); -x_7 = lean_ctor_get(x_2, 1); -x_8 = lean_ctor_get(x_2, 2); -x_17 = lean_string_dec_eq(x_3, x_6); -if (x_17 == 0) -{ -uint8_t x_18; -x_18 = 0; -return x_18; -} -else -{ -if (lean_obj_tag(x_4) == 0) -{ -if (lean_obj_tag(x_7) == 0) -{ -lean_object* x_19; -x_19 = lean_box(0); -x_9 = x_19; -goto block_16; -} -else -{ -uint8_t x_20; -x_20 = 0; -return x_20; -} -} -else -{ -if (lean_obj_tag(x_7) == 0) -{ -uint8_t x_21; -x_21 = 0; -return x_21; -} -else -{ -lean_object* x_22; lean_object* x_23; uint8_t x_24; -x_22 = lean_ctor_get(x_4, 0); -x_23 = lean_ctor_get(x_7, 0); -x_24 = lean_nat_dec_eq(x_22, x_23); -if (x_24 == 0) -{ -uint8_t x_25; -x_25 = 0; -return x_25; -} -else -{ -lean_object* x_26; -x_26 = lean_box(0); -x_9 = x_26; -goto block_16; -} -} -} -} -block_16: -{ -lean_dec(x_9); -if (lean_obj_tag(x_5) == 0) -{ -if (lean_obj_tag(x_8) == 0) -{ -uint8_t x_10; -x_10 = 1; -return x_10; -} -else -{ -uint8_t x_11; -x_11 = 0; -return x_11; -} -} -else -{ -if (lean_obj_tag(x_8) == 0) -{ -uint8_t x_12; -x_12 = 0; -return x_12; -} -else -{ -lean_object* x_13; lean_object* x_14; uint8_t x_15; -x_13 = lean_ctor_get(x_5, 0); -x_14 = lean_ctor_get(x_8, 0); -x_15 = lean_nat_dec_eq(x_13, x_14); -return x_15; -} -} -} -} -} -lean_object* l_Lean_Parser_TokenConfig_beq___boxed(lean_object* x_1, lean_object* x_2) { -_start: -{ -uint8_t x_3; lean_object* x_4; -x_3 = l_Lean_Parser_TokenConfig_beq(x_1, x_2); -lean_dec(x_2); -lean_dec(x_1); -x_4 = lean_box(x_3); -return x_4; -} -} -lean_object* _init_l_Lean_Parser_TokenConfig_HasBeq___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l_Lean_Parser_TokenConfig_beq___boxed), 2, 0); -return x_1; -} -} -lean_object* _init_l_Lean_Parser_TokenConfig_HasBeq() { -_start: -{ -lean_object* x_1; -x_1 = l_Lean_Parser_TokenConfig_HasBeq___closed__1; -return x_1; -} -} -lean_object* _init_l_Lean_Parser_TokenConfig_toStr___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string(":none:"); -return x_1; -} -} -lean_object* l_Lean_Parser_TokenConfig_toStr(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = lean_ctor_get(x_1, 1); -lean_inc(x_2); -if (lean_obj_tag(x_2) == 0) -{ -lean_object* x_3; -x_3 = lean_ctor_get(x_1, 2); -lean_inc(x_3); -if (lean_obj_tag(x_3) == 0) -{ -lean_object* x_4; -x_4 = lean_ctor_get(x_1, 0); -lean_inc(x_4); -lean_dec(x_1); -return x_4; -} -else -{ -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, 0); -lean_inc(x_5); -lean_dec(x_1); -x_6 = lean_ctor_get(x_3, 0); -lean_inc(x_6); -lean_dec(x_3); -x_7 = l_Lean_Parser_TokenConfig_toStr___closed__1; -x_8 = lean_string_append(x_5, x_7); -x_9 = l_Nat_repr(x_6); -x_10 = lean_string_append(x_8, x_9); -lean_dec(x_9); -return x_10; -} -} -else -{ -lean_object* x_11; -x_11 = lean_ctor_get(x_1, 2); -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; lean_object* x_17; -x_12 = lean_ctor_get(x_1, 0); -lean_inc(x_12); -lean_dec(x_1); -x_13 = lean_ctor_get(x_2, 0); -lean_inc(x_13); -lean_dec(x_2); -x_14 = l___private_Init_Util_1__mkPanicMessage___closed__2; -x_15 = lean_string_append(x_12, x_14); -x_16 = l_Nat_repr(x_13); -x_17 = lean_string_append(x_15, x_16); -lean_dec(x_16); -return x_17; -} -else -{ -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_18 = lean_ctor_get(x_1, 0); -lean_inc(x_18); -lean_dec(x_1); -x_19 = lean_ctor_get(x_2, 0); -lean_inc(x_19); -lean_dec(x_2); -x_20 = lean_ctor_get(x_11, 0); -lean_inc(x_20); -lean_dec(x_11); -x_21 = l___private_Init_Util_1__mkPanicMessage___closed__2; -x_22 = lean_string_append(x_18, x_21); -x_23 = l_Nat_repr(x_19); -x_24 = lean_string_append(x_22, x_23); -lean_dec(x_23); -x_25 = lean_string_append(x_24, x_21); -x_26 = l_Nat_repr(x_20); -x_27 = lean_string_append(x_25, x_26); -lean_dec(x_26); -return x_27; -} -} -} -} -lean_object* _init_l_Lean_Parser_TokenConfig_HasToString___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l_Lean_Parser_TokenConfig_toStr), 1, 0); -return x_1; -} -} -lean_object* _init_l_Lean_Parser_TokenConfig_HasToString() { -_start: -{ -lean_object* x_1; -x_1 = l_Lean_Parser_TokenConfig_HasToString___closed__1; -return x_1; -} -} lean_object* l_Lean_Parser_initCacheForInput(lean_object* x_1) { _start: { @@ -3928,44 +3672,42 @@ return x_3; } else { -lean_object* x_4; 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_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 = lean_ctor_get(x_2, 1); lean_inc(x_5); lean_dec(x_2); -x_6 = l_Lean_Parser_TokenConfig_toStr(x_4); -x_7 = l_List_reprAux___main___rarg___closed__1; -x_8 = lean_string_append(x_7, x_6); -lean_dec(x_6); -x_9 = l_List_toStringAux___main___at_Lean_Parser_FirstTokens_toStr___spec__2(x_1, x_5); -x_10 = lean_string_append(x_8, x_9); -lean_dec(x_9); -return x_10; +x_6 = l_List_reprAux___main___rarg___closed__1; +x_7 = lean_string_append(x_6, x_4); +lean_dec(x_4); +x_8 = l_List_toStringAux___main___at_Lean_Parser_FirstTokens_toStr___spec__2(x_1, x_5); +x_9 = lean_string_append(x_7, x_8); +lean_dec(x_8); +return x_9; } } else { if (lean_obj_tag(x_2) == 0) { -lean_object* x_11; -x_11 = l_String_splitAux___main___closed__1; -return x_11; +lean_object* x_10; +x_10 = l_String_splitAux___main___closed__1; +return x_10; } else { -lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; -x_12 = lean_ctor_get(x_2, 0); +lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; +x_11 = lean_ctor_get(x_2, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_2, 1); lean_inc(x_12); -x_13 = lean_ctor_get(x_2, 1); -lean_inc(x_13); lean_dec(x_2); -x_14 = l_Lean_Parser_TokenConfig_toStr(x_12); -x_15 = 0; -x_16 = l_List_toStringAux___main___at_Lean_Parser_FirstTokens_toStr___spec__2(x_15, x_13); -x_17 = lean_string_append(x_14, x_16); -lean_dec(x_16); -return x_17; +x_13 = 0; +x_14 = l_List_toStringAux___main___at_Lean_Parser_FirstTokens_toStr___spec__2(x_13, x_12); +x_15 = lean_string_append(x_11, x_14); +lean_dec(x_14); +return x_15; } } } @@ -8522,15 +8264,14 @@ return x_4; } else { -lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; +lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; x_5 = lean_ctor_get(x_3, 0); x_6 = lean_nat_sub(x_2, x_1); -x_7 = lean_ctor_get(x_5, 0); -x_8 = lean_string_utf8_byte_size(x_7); -x_9 = lean_nat_dec_le(x_6, x_8); -lean_dec(x_8); +x_7 = lean_string_utf8_byte_size(x_5); +x_8 = lean_nat_dec_le(x_6, x_7); +lean_dec(x_7); lean_dec(x_6); -return x_9; +return x_8; } } } @@ -8570,7 +8311,7 @@ uint8_t x_7; x_7 = !lean_is_exclusive(x_2); if (x_7 == 0) { -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_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; x_8 = lean_ctor_get(x_3, 0); x_9 = lean_ctor_get(x_2, 0); x_10 = lean_ctor_get(x_8, 0); @@ -8580,82 +8321,76 @@ x_11 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_11, 0, x_10); lean_ctor_set(x_11, 1, x_1); lean_ctor_set(x_11, 2, x_1); -x_12 = lean_ctor_get(x_9, 0); -lean_inc(x_12); -lean_dec(x_9); -x_13 = lean_string_utf8_byte_size(x_12); -x_14 = lean_nat_add(x_1, x_13); -lean_dec(x_13); -lean_inc(x_14); -x_15 = l_Lean_Parser_ParserState_setPos(x_4, x_14); -x_16 = l_Lean_Parser_whitespace___main(x_3, x_15); -x_17 = lean_ctor_get(x_16, 1); -lean_inc(x_17); +x_12 = lean_string_utf8_byte_size(x_9); +x_13 = lean_nat_add(x_1, x_12); +lean_dec(x_12); +lean_inc(x_13); +x_14 = l_Lean_Parser_ParserState_setPos(x_4, x_13); +x_15 = l_Lean_Parser_whitespace___main(x_3, x_14); +x_16 = lean_ctor_get(x_15, 1); +lean_inc(x_16); lean_inc(x_10); -x_18 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_18, 0, x_10); -lean_ctor_set(x_18, 1, x_14); -lean_ctor_set(x_18, 2, x_17); +x_17 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_17, 0, x_10); +lean_ctor_set(x_17, 1, x_13); +lean_ctor_set(x_17, 2, x_16); lean_ctor_set(x_2, 0, x_11); +x_18 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_18, 0, x_1); x_19 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_19, 0, x_1); -x_20 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_20, 0, x_18); -x_21 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_21, 0, x_2); -lean_ctor_set(x_21, 1, x_19); -lean_ctor_set(x_21, 2, 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_12); -x_23 = l_Lean_Parser_ParserState_pushSyntax(x_16, x_22); -return x_23; +lean_ctor_set(x_19, 0, x_17); +x_20 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_20, 0, x_2); +lean_ctor_set(x_20, 1, x_18); +lean_ctor_set(x_20, 2, 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_9); +x_22 = l_Lean_Parser_ParserState_pushSyntax(x_15, x_21); +return x_22; } 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; 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; -x_24 = lean_ctor_get(x_3, 0); -x_25 = lean_ctor_get(x_2, 0); -lean_inc(x_25); +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_23 = lean_ctor_get(x_3, 0); +x_24 = lean_ctor_get(x_2, 0); +lean_inc(x_24); lean_dec(x_2); -x_26 = lean_ctor_get(x_24, 0); +x_25 = lean_ctor_get(x_23, 0); lean_inc_n(x_1, 2); -lean_inc(x_26); -x_27 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_27, 0, x_26); -lean_ctor_set(x_27, 1, x_1); -lean_ctor_set(x_27, 2, x_1); -x_28 = lean_ctor_get(x_25, 0); +lean_inc(x_25); +x_26 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_1); +lean_ctor_set(x_26, 2, x_1); +x_27 = lean_string_utf8_byte_size(x_24); +x_28 = lean_nat_add(x_1, x_27); +lean_dec(x_27); lean_inc(x_28); -lean_dec(x_25); -x_29 = lean_string_utf8_byte_size(x_28); -x_30 = lean_nat_add(x_1, x_29); -lean_dec(x_29); -lean_inc(x_30); -x_31 = l_Lean_Parser_ParserState_setPos(x_4, x_30); -x_32 = l_Lean_Parser_whitespace___main(x_3, x_31); -x_33 = lean_ctor_get(x_32, 1); -lean_inc(x_33); -lean_inc(x_26); -x_34 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_34, 0, x_26); -lean_ctor_set(x_34, 1, x_30); -lean_ctor_set(x_34, 2, x_33); +x_29 = l_Lean_Parser_ParserState_setPos(x_4, x_28); +x_30 = l_Lean_Parser_whitespace___main(x_3, x_29); +x_31 = lean_ctor_get(x_30, 1); +lean_inc(x_31); +lean_inc(x_25); +x_32 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_32, 0, x_25); +lean_ctor_set(x_32, 1, x_28); +lean_ctor_set(x_32, 2, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_26); +x_34 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_34, 0, x_1); x_35 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_35, 0, x_27); -x_36 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_36, 0, x_1); -x_37 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_37, 0, x_34); -x_38 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_38, 0, x_35); -lean_ctor_set(x_38, 1, x_36); -lean_ctor_set(x_38, 2, x_37); -x_39 = lean_alloc_ctor(2, 2, 0); -lean_ctor_set(x_39, 0, x_38); -lean_ctor_set(x_39, 1, x_28); -x_40 = l_Lean_Parser_ParserState_pushSyntax(x_32, x_39); -return x_40; +lean_ctor_set(x_35, 0, x_32); +x_36 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_36, 0, x_33); +lean_ctor_set(x_36, 1, x_34); +lean_ctor_set(x_36, 2, x_35); +x_37 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_24); +x_38 = l_Lean_Parser_ParserState_pushSyntax(x_30, x_37); +return x_38; } } } @@ -9669,19 +9404,14 @@ lean_inc(x_1); return x_1; } } -lean_object* l_Lean_Parser_symbolInfo___elambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_Parser_symbolInfo___elambda__2(lean_object* x_1, lean_object* x_2) { _start: { -lean_object* x_4; lean_object* x_5; lean_object* x_6; -x_4 = lean_box(0); -x_5 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_5, 0, x_1); -lean_ctor_set(x_5, 1, x_2); -lean_ctor_set(x_5, 2, x_4); -x_6 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_6, 0, x_5); -lean_ctor_set(x_6, 1, x_3); -return x_6; +lean_object* x_3; +x_3 = lean_alloc_ctor(1, 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_symbolInfo___closed__1() { @@ -9692,32 +9422,25 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_symbolInfo___elambda__1___boxed), return x_1; } } -lean_object* l_Lean_Parser_symbolInfo(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbolInfo(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; lean_object* x_8; lean_object* x_9; lean_object* x_10; -lean_inc(x_2); +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_inc(x_1); -x_3 = lean_alloc_closure((void*)(l_Lean_Parser_symbolInfo___elambda__2), 3, 2); -lean_closure_set(x_3, 0, x_1); -lean_closure_set(x_3, 1, x_2); -x_4 = lean_box(0); -x_5 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_5, 0, x_1); -lean_ctor_set(x_5, 1, x_2); -lean_ctor_set(x_5, 2, x_4); -x_6 = lean_box(0); -x_7 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_7, 0, x_5); +x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolInfo___elambda__2), 2, 1); +lean_closure_set(x_2, 0, x_1); +x_3 = lean_box(0); +x_4 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_3); +x_5 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_5, 0, x_4); +x_6 = l_Lean_Parser_symbolInfo___closed__1; +x_7 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_7, 0, x_2); lean_ctor_set(x_7, 1, x_6); -x_8 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_8, 0, x_7); -x_9 = l_Lean_Parser_symbolInfo___closed__1; -x_10 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_10, 0, x_3); -lean_ctor_set(x_10, 1, x_9); -lean_ctor_set(x_10, 2, x_8); -return x_10; +lean_ctor_set(x_7, 2, x_5); +return x_7; } } lean_object* l_Lean_Parser_symbolInfo___elambda__1___boxed(lean_object* x_1) { @@ -9799,54 +9522,52 @@ lean_dec(x_1); return x_4; } } -lean_object* l_Lean_Parser_symbolAux(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbolAux(lean_object* x_1) { _start: { -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* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_String_trim(x_1); +lean_inc(x_2); +x_3 = l_Lean_Parser_symbolInfo(x_2); +x_4 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1); +lean_closure_set(x_4, 0, x_2); +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_3); +lean_ctor_set(x_5, 1, x_4); +return x_5; } } -lean_object* l_Lean_Parser_symbolAux___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbolAux___boxed(lean_object* x_1) { _start: { -lean_object* x_3; -x_3 = l_Lean_Parser_symbolAux(x_1, x_2); +lean_object* x_2; +x_2 = l_Lean_Parser_symbolAux(x_1); lean_dec(x_1); -return x_3; +return x_2; } } -lean_object* l_Lean_Parser_symbol(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbol(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_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___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); -lean_ctor_set(x_7, 1, x_6); -return x_7; +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_String_trim(x_1); +lean_inc(x_2); +x_3 = l_Lean_Parser_symbolInfo(x_2); +x_4 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1); +lean_closure_set(x_4, 0, x_2); +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_3); +lean_ctor_set(x_5, 1, x_4); +return x_5; } } -lean_object* l_Lean_Parser_symbol___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbol___boxed(lean_object* x_1) { _start: { -lean_object* x_3; -x_3 = l_Lean_Parser_symbol(x_1, x_2); +lean_object* x_2; +x_2 = l_Lean_Parser_symbol(x_1); lean_dec(x_1); -return x_3; +return x_2; } } lean_object* l_Lean_Parser_nonReservedSymbolFnAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { @@ -9997,19 +9718,6 @@ _start: lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); x_2 = l_Lean_identKind___closed__1; -x_3 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_3, 0, x_2); -lean_ctor_set(x_3, 1, x_1); -lean_ctor_set(x_3, 2, x_1); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_nonReservedSymbolInfo___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_nonReservedSymbolInfo___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); @@ -10021,47 +9729,37 @@ _start: { if (x_2 == 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_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; x_3 = lean_box(0); -x_4 = lean_alloc_ctor(0, 3, 0); +x_4 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_3); -lean_ctor_set(x_4, 2, x_3); -x_5 = lean_box(0); -x_6 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_6, 0, x_4); -lean_ctor_set(x_6, 1, x_5); -x_7 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_7, 0, x_6); -x_8 = l_Lean_Parser_nonReservedSymbolInfo___closed__1; -x_9 = l_Lean_Parser_nonReservedSymbolInfo___closed__2; -x_10 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_10, 0, x_8); -lean_ctor_set(x_10, 1, x_9); -lean_ctor_set(x_10, 2, x_7); -return x_10; +x_5 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_5, 0, x_4); +x_6 = l_Lean_Parser_nonReservedSymbolInfo___closed__1; +x_7 = l_Lean_Parser_nonReservedSymbolInfo___closed__2; +x_8 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_8, 0, x_6); +lean_ctor_set(x_8, 1, x_7); +lean_ctor_set(x_8, 2, x_5); +return x_8; } else { -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_11 = lean_box(0); -x_12 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_12, 0, x_1); -lean_ctor_set(x_12, 1, x_11); -lean_ctor_set(x_12, 2, x_11); -x_13 = l_Lean_Parser_nonReservedSymbolInfo___closed__4; -x_14 = lean_alloc_ctor(1, 2, 0); +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 = l_Lean_Parser_nonReservedSymbolInfo___closed__3; +x_10 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +x_11 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_11, 0, x_10); +x_12 = l_Lean_Parser_nonReservedSymbolInfo___closed__1; +x_13 = l_Lean_Parser_nonReservedSymbolInfo___closed__2; +x_14 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_14, 0, x_12); lean_ctor_set(x_14, 1, x_13); -x_15 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_15, 0, x_14); -x_16 = l_Lean_Parser_nonReservedSymbolInfo___closed__1; -x_17 = l_Lean_Parser_nonReservedSymbolInfo___closed__2; -x_18 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_18, 0, x_16); -lean_ctor_set(x_18, 1, x_17); -lean_ctor_set(x_18, 2, x_15); -return x_18; +lean_ctor_set(x_14, 2, x_11); +return x_14; } } } @@ -10523,19 +10221,14 @@ lean_inc(x_1); return x_1; } } -lean_object* l_Lean_Parser_symbolNoWsInfo___elambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_Parser_symbolNoWsInfo___elambda__2(lean_object* x_1, lean_object* x_2) { _start: { -lean_object* x_4; lean_object* x_5; lean_object* x_6; -x_4 = lean_box(0); -x_5 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_5, 0, x_1); -lean_ctor_set(x_5, 1, x_4); -lean_ctor_set(x_5, 2, x_2); -x_6 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_6, 0, x_5); -lean_ctor_set(x_6, 1, x_3); -return x_6; +lean_object* x_3; +x_3 = lean_alloc_ctor(1, 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_symbolNoWsInfo___closed__1() { @@ -10546,32 +10239,25 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_symbolNoWsInfo___elambda__1___box return x_1; } } -lean_object* l_Lean_Parser_symbolNoWsInfo(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbolNoWsInfo(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; lean_object* x_8; lean_object* x_9; lean_object* x_10; -lean_inc(x_2); +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_inc(x_1); -x_3 = lean_alloc_closure((void*)(l_Lean_Parser_symbolNoWsInfo___elambda__2), 3, 2); -lean_closure_set(x_3, 0, x_1); -lean_closure_set(x_3, 1, x_2); -x_4 = lean_box(0); -x_5 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_5, 0, x_1); -lean_ctor_set(x_5, 1, x_4); -lean_ctor_set(x_5, 2, x_2); -x_6 = lean_box(0); -x_7 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_7, 0, x_5); +x_2 = lean_alloc_closure((void*)(l_Lean_Parser_symbolNoWsInfo___elambda__2), 2, 1); +lean_closure_set(x_2, 0, x_1); +x_3 = lean_box(0); +x_4 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_3); +x_5 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_5, 0, x_4); +x_6 = l_Lean_Parser_symbolNoWsInfo___closed__1; +x_7 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_7, 0, x_2); lean_ctor_set(x_7, 1, x_6); -x_8 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_8, 0, x_7); -x_9 = l_Lean_Parser_symbolNoWsInfo___closed__1; -x_10 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_10, 0, x_3); -lean_ctor_set(x_10, 1, x_9); -lean_ctor_set(x_10, 2, x_8); -return x_10; +lean_ctor_set(x_7, 2, x_5); +return x_7; } } lean_object* l_Lean_Parser_symbolNoWsInfo___elambda__1___boxed(lean_object* x_1) { @@ -10759,54 +10445,52 @@ lean_dec(x_2); return x_4; } } -lean_object* l_Lean_Parser_symbolNoWsAux(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbolNoWsAux(lean_object* x_1) { _start: { -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), 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* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_String_trim(x_1); +lean_inc(x_2); +x_3 = l_Lean_Parser_symbolNoWsInfo(x_2); +x_4 = lean_alloc_closure((void*)(l_Lean_Parser_symbolNoWsFn___boxed), 3, 1); +lean_closure_set(x_4, 0, x_2); +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_3); +lean_ctor_set(x_5, 1, x_4); +return x_5; } } -lean_object* l_Lean_Parser_symbolNoWsAux___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbolNoWsAux___boxed(lean_object* x_1) { _start: { -lean_object* x_3; -x_3 = l_Lean_Parser_symbolNoWsAux(x_1, x_2); +lean_object* x_2; +x_2 = l_Lean_Parser_symbolNoWsAux(x_1); lean_dec(x_1); -return x_3; +return x_2; } } -lean_object* l_Lean_Parser_symbolNoWs(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbolNoWs(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_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_symbolNoWsInfo(x_4, x_3); -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); -lean_ctor_set(x_7, 1, x_6); -return x_7; +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_String_trim(x_1); +lean_inc(x_2); +x_3 = l_Lean_Parser_symbolNoWsInfo(x_2); +x_4 = lean_alloc_closure((void*)(l_Lean_Parser_symbolNoWsFn___boxed), 3, 1); +lean_closure_set(x_4, 0, x_2); +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_3); +lean_ctor_set(x_5, 1, x_4); +return x_5; } } -lean_object* l_Lean_Parser_symbolNoWs___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Parser_symbolNoWs___boxed(lean_object* x_1) { _start: { -lean_object* x_3; -x_3 = l_Lean_Parser_symbolNoWs(x_1, x_2); +lean_object* x_2; +x_2 = l_Lean_Parser_symbolNoWs(x_1); lean_dec(x_1); -return x_3; +return x_2; } } lean_object* l_Lean_Parser_unicodeSymbolFnAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { @@ -10892,27 +10576,17 @@ lean_inc(x_1); return x_1; } } -lean_object* l_Lean_Parser_unicodeSymbolInfo___elambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_Lean_Parser_unicodeSymbolInfo___elambda__2(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_box(0); -lean_inc(x_3); -x_6 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_6, 0, x_1); -lean_ctor_set(x_6, 1, x_3); -lean_ctor_set(x_6, 2, x_5); -x_7 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_7, 0, x_2); -lean_ctor_set(x_7, 1, x_3); -lean_ctor_set(x_7, 2, x_5); -x_8 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_8, 0, x_7); -lean_ctor_set(x_8, 1, x_4); -x_9 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_9, 0, x_6); -lean_ctor_set(x_9, 1, x_8); -return x_9; +lean_object* x_4; lean_object* x_5; +x_4 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_4, 0, x_2); +lean_ctor_set(x_4, 1, x_3); +x_5 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_5, 0, x_1); +lean_ctor_set(x_5, 1, x_4); +return x_5; } } lean_object* _init_l_Lean_Parser_unicodeSymbolInfo___closed__1() { @@ -10923,42 +10597,30 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolInfo___elambda__1___ return x_1; } } -lean_object* l_Lean_Parser_unicodeSymbolInfo(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_Parser_unicodeSymbolInfo(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_inc(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_inc(x_2); lean_inc(x_1); -x_4 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolInfo___elambda__2), 4, 3); -lean_closure_set(x_4, 0, x_1); -lean_closure_set(x_4, 1, x_2); -lean_closure_set(x_4, 2, x_3); -x_5 = lean_box(0); -lean_inc(x_3); -x_6 = lean_alloc_ctor(0, 3, 0); +x_3 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolInfo___elambda__2), 3, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +x_4 = lean_box(0); +x_5 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_5, 0, x_2); +lean_ctor_set(x_5, 1, x_4); +x_6 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_6, 0, x_1); -lean_ctor_set(x_6, 1, x_3); -lean_ctor_set(x_6, 2, x_5); -x_7 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_7, 0, x_2); -lean_ctor_set(x_7, 1, x_3); -lean_ctor_set(x_7, 2, 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_6, 1, x_5); +x_7 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_7, 0, x_6); +x_8 = l_Lean_Parser_unicodeSymbolInfo___closed__1; +x_9 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_9, 0, x_3); lean_ctor_set(x_9, 1, x_8); -x_10 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_10, 0, x_6); -lean_ctor_set(x_10, 1, x_9); -x_11 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_11, 0, x_10); -x_12 = l_Lean_Parser_unicodeSymbolInfo___closed__1; -x_13 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_13, 0, x_4); -lean_ctor_set(x_13, 1, x_12); -lean_ctor_set(x_13, 2, x_11); -return x_13; +lean_ctor_set(x_9, 2, x_7); +return x_9; } } lean_object* l_Lean_Parser_unicodeSymbolInfo___elambda__1___boxed(lean_object* x_1) { @@ -11006,32 +10668,32 @@ lean_dec(x_1); return x_5; } } -lean_object* l_Lean_Parser_unicodeSymbol(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_Parser_unicodeSymbol(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_String_trim(x_1); -x_5 = l_String_trim(x_2); -lean_inc(x_5); +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = l_String_trim(x_1); +x_4 = l_String_trim(x_2); 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_inc(x_3); +x_5 = l_Lean_Parser_unicodeSymbolInfo(x_3, x_4); +x_6 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___boxed), 4, 2); +lean_closure_set(x_6, 0, x_3); +lean_closure_set(x_6, 1, 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_unicodeSymbol___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_Parser_unicodeSymbol___boxed(lean_object* x_1, lean_object* x_2) { _start: { -lean_object* x_4; -x_4 = l_Lean_Parser_unicodeSymbol(x_1, x_2, x_3); +lean_object* x_3; +x_3 = l_Lean_Parser_unicodeSymbol(x_1, x_2); lean_dec(x_2); lean_dec(x_1); -return x_4; +return x_3; } } lean_object* l_Lean_Parser_checkRbpLtFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { @@ -11063,19 +10725,27 @@ lean_dec(x_1); return x_5; } } -lean_object* l_Lean_Parser_checkRbpLt___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* _init_l___private_Lean_Parser_Parser_10__precErrorMsg___closed__1() { _start: { -lean_object* x_5; -x_5 = l_Lean_Parser_checkRbpLtFn(x_1, x_2, x_3, x_4); -return x_5; +lean_object* x_1; +x_1 = lean_mk_string("unexpected token at this precedence level; consider parenthesizing the term"); +return x_1; +} +} +lean_object* _init_l___private_Lean_Parser_Parser_10__precErrorMsg() { +_start: +{ +lean_object* x_1; +x_1 = l___private_Lean_Parser_Parser_10__precErrorMsg___closed__1; +return x_1; } } lean_object* l_Lean_Parser_checkRbpLt(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_checkRbpLt___elambda__1___boxed), 4, 2); +x_3 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLtFn___boxed), 4, 2); lean_closure_set(x_3, 0, x_1); lean_closure_set(x_3, 1, x_2); x_4 = l_Lean_Parser_epsilonInfo; @@ -11085,24 +10755,20 @@ lean_ctor_set(x_5, 1, x_3); return x_5; } } -lean_object* l_Lean_Parser_checkRbpLt___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_checkRbpLt___elambda__1(x_1, x_2, x_3, x_4); -lean_dec(x_3); -lean_dec(x_1); -return x_5; -} -} lean_object* l_Lean_Parser_checkRbpLe(lean_object* x_1, lean_object* x_2) { _start: { -lean_object* x_3; lean_object* x_4; lean_object* 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_unsigned_to_nat(1u); x_4 = lean_nat_add(x_1, x_3); -x_5 = l_Lean_Parser_checkRbpLt(x_4, x_2); -return x_5; +x_5 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLtFn___boxed), 4, 2); +lean_closure_set(x_5, 0, x_4); +lean_closure_set(x_5, 1, x_2); +x_6 = l_Lean_Parser_epsilonInfo; +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_checkRbpLe___boxed(lean_object* x_1, lean_object* x_2) { @@ -11114,43 +10780,35 @@ lean_dec(x_1); return x_3; } } -lean_object* _init_l_Lean_Parser_leadingNodePrec___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("unexpected RBP"); -return x_1; -} -} lean_object* l_Lean_Parser_leadingNodePrec(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_13; lean_object* x_14; -x_4 = l_Lean_Parser_leadingNodePrec___closed__1; -x_5 = l_Lean_Parser_checkRbpLe(x_2, x_4); -x_6 = lean_ctor_get(x_3, 0); -lean_inc(x_6); -lean_inc(x_1); -x_7 = l_Lean_Parser_nodeInfo(x_1, x_6); -x_8 = lean_ctor_get(x_3, 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; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_4 = lean_unsigned_to_nat(1u); +x_5 = lean_nat_add(x_2, x_4); +x_6 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_7 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLtFn___boxed), 4, 2); +lean_closure_set(x_7, 0, x_5); +lean_closure_set(x_7, 1, x_6); +x_8 = lean_ctor_get(x_3, 0); lean_inc(x_8); -lean_dec(x_3); -x_9 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2); -lean_closure_set(x_9, 0, x_1); -lean_closure_set(x_9, 1, x_8); -x_10 = lean_ctor_get(x_5, 0); +lean_inc(x_1); +x_9 = l_Lean_Parser_nodeInfo(x_1, x_8); +x_10 = lean_ctor_get(x_3, 1); lean_inc(x_10); -x_11 = l_Lean_Parser_andthenInfo(x_10, x_7); -x_12 = lean_ctor_get(x_5, 1); -lean_inc(x_12); -lean_dec(x_5); -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_9); -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; +lean_dec(x_3); +x_11 = lean_alloc_closure((void*)(l_Lean_Parser_nodeFn), 4, 2); +lean_closure_set(x_11, 0, x_1); +lean_closure_set(x_11, 1, x_10); +x_12 = l_Lean_Parser_epsilonInfo; +x_13 = l_Lean_Parser_andthenInfo(x_12, x_9); +x_14 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2); +lean_closure_set(x_14, 0, x_7); +lean_closure_set(x_14, 1, x_11); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_14); +return x_15; } } lean_object* l_Lean_Parser_leadingNodePrec___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { @@ -11166,27 +10824,27 @@ lean_object* l_Lean_Parser_trailingNodePrec(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 = lean_ctor_get(x_3, 0); -lean_inc(x_4); -lean_inc(x_1); -x_5 = l_Lean_Parser_nodeInfo(x_1, x_4); -x_6 = lean_ctor_get(x_3, 1); +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLtFn___boxed), 4, 2); +lean_closure_set(x_5, 0, x_2); +lean_closure_set(x_5, 1, x_4); +x_6 = lean_ctor_get(x_3, 0); lean_inc(x_6); +lean_inc(x_1); +x_7 = l_Lean_Parser_nodeInfo(x_1, x_6); +x_8 = lean_ctor_get(x_3, 1); +lean_inc(x_8); lean_dec(x_3); -x_7 = lean_alloc_closure((void*)(l_Lean_Parser_trailingNodeFn), 4, 2); -lean_closure_set(x_7, 0, x_1); -lean_closure_set(x_7, 1, x_6); -x_8 = l_Lean_Parser_epsilonInfo; -x_9 = l_Lean_Parser_andthenInfo(x_8, x_5); -x_10 = l_Lean_Parser_leadingNodePrec___closed__1; -x_11 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLt___elambda__1___boxed), 4, 2); -lean_closure_set(x_11, 0, x_2); -lean_closure_set(x_11, 1, x_10); +x_9 = lean_alloc_closure((void*)(l_Lean_Parser_trailingNodeFn), 4, 2); +lean_closure_set(x_9, 0, x_1); +lean_closure_set(x_9, 1, x_8); +x_10 = l_Lean_Parser_epsilonInfo; +x_11 = l_Lean_Parser_andthenInfo(x_10, x_7); x_12 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2); -lean_closure_set(x_12, 0, x_11); -lean_closure_set(x_12, 1, x_7); +lean_closure_set(x_12, 0, x_5); +lean_closure_set(x_12, 1, x_9); x_13 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_13, 0, x_9); +lean_ctor_set(x_13, 0, x_11); lean_ctor_set(x_13, 1, x_12); return x_13; } @@ -11224,25 +10882,20 @@ return x_1; lean_object* l_Lean_Parser_mkAtomicInfo(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; lean_object* x_8; lean_object* x_9; +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_box(0); -x_3 = lean_alloc_ctor(0, 3, 0); +x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_1); lean_ctor_set(x_3, 1, x_2); -lean_ctor_set(x_3, 2, x_2); -x_4 = lean_box(0); -x_5 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_5, 0, x_3); -lean_ctor_set(x_5, 1, x_4); -x_6 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_6, 0, x_5); -x_7 = l_Lean_Parser_mkAtomicInfo___closed__1; -x_8 = l_Lean_Parser_mkAtomicInfo___closed__2; -x_9 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_9, 0, x_7); -lean_ctor_set(x_9, 1, x_8); -lean_ctor_set(x_9, 2, x_6); -return x_9; +x_4 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_4, 0, x_3); +x_5 = l_Lean_Parser_mkAtomicInfo___closed__1; +x_6 = l_Lean_Parser_mkAtomicInfo___closed__2; +x_7 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_7, 0, x_5); +lean_ctor_set(x_7, 1, x_6); +lean_ctor_set(x_7, 2, x_4); +return x_7; } } lean_object* l_Lean_Parser_mkAtomicInfo___elambda__1___boxed(lean_object* x_1) { @@ -12179,17 +11832,16 @@ 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; +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; x_2 = l_String_trim(x_1); -x_3 = l_Lean_Syntax_decodeNatLitVal___closed__1; lean_inc(x_2); -x_4 = l_Lean_Parser_symbolInfo(x_2, x_3); -x_5 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1); -lean_closure_set(x_5, 0, x_2); -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; +x_3 = l_Lean_Parser_symbolInfo(x_2); +x_4 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1); +lean_closure_set(x_4, 0, x_2); +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_3); +lean_ctor_set(x_5, 1, x_4); +return x_5; } } lean_object* l_Lean_Parser_stringToParserCoe___boxed(lean_object* x_1) { @@ -23329,970 +22981,6 @@ x_1 = l_Lean_Parser_ParserCategory_inhabited___closed__1; return x_1; } } -lean_object* _init_l_Lean_Parser_currLbp___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("$"); -return x_1; -} -} -lean_object* l_Lean_Parser_currLbp(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -lean_object* x_4; lean_object* x_163; lean_object* x_164; lean_object* x_165; uint8_t x_166; -x_163 = lean_ctor_get(x_3, 2); -lean_inc(x_163); -x_164 = lean_ctor_get(x_163, 0); -lean_inc(x_164); -x_165 = lean_ctor_get(x_3, 1); -lean_inc(x_165); -x_166 = lean_nat_dec_eq(x_164, x_165); -lean_dec(x_165); -lean_dec(x_164); -if (x_166 == 0) -{ -lean_object* x_167; -lean_dec(x_163); -lean_inc(x_2); -x_167 = l_Lean_Parser_peekTokenAux(x_2, x_3); -x_4 = x_167; -goto block_162; -} -else -{ -lean_object* x_168; lean_object* x_169; lean_object* x_170; -x_168 = lean_ctor_get(x_163, 2); -lean_inc(x_168); -lean_dec(x_163); -x_169 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_169, 0, x_168); -x_170 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_170, 0, x_3); -lean_ctor_set(x_170, 1, x_169); -x_4 = x_170; -goto block_162; -} -block_162: -{ -lean_object* x_5; -x_5 = lean_ctor_get(x_4, 1); -lean_inc(x_5); -if (lean_obj_tag(x_5) == 0) -{ -uint8_t x_6; -lean_dec(x_2); -x_6 = !lean_is_exclusive(x_4); -if (x_6 == 0) -{ -lean_object* x_7; lean_object* x_8; -x_7 = lean_ctor_get(x_4, 1); -lean_dec(x_7); -x_8 = lean_unsigned_to_nat(0u); -lean_ctor_set(x_4, 1, x_8); -return x_4; -} -else -{ -lean_object* x_9; lean_object* x_10; lean_object* x_11; -x_9 = lean_ctor_get(x_4, 0); -lean_inc(x_9); -lean_dec(x_4); -x_10 = lean_unsigned_to_nat(0u); -x_11 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_11, 0, x_9); -lean_ctor_set(x_11, 1, x_10); -return x_11; -} -} -else -{ -lean_object* x_12; -x_12 = lean_ctor_get(x_5, 0); -lean_inc(x_12); -lean_dec(x_5); -switch (lean_obj_tag(x_12)) { -case 0: -{ -uint8_t x_13; -lean_dec(x_2); -x_13 = !lean_is_exclusive(x_4); -if (x_13 == 0) -{ -lean_object* x_14; lean_object* x_15; -x_14 = lean_ctor_get(x_4, 1); -lean_dec(x_14); -x_15 = lean_unsigned_to_nat(0u); -lean_ctor_set(x_4, 1, x_15); -return x_4; -} -else -{ -lean_object* x_16; lean_object* x_17; lean_object* x_18; -x_16 = lean_ctor_get(x_4, 0); -lean_inc(x_16); -lean_dec(x_4); -x_17 = lean_unsigned_to_nat(0u); -x_18 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_18, 0, x_16); -lean_ctor_set(x_18, 1, x_17); -return x_18; -} -} -case 1: -{ -uint8_t x_19; -lean_dec(x_2); -x_19 = !lean_is_exclusive(x_4); -if (x_19 == 0) -{ -lean_object* x_20; lean_object* x_21; uint8_t x_22; -x_20 = lean_ctor_get(x_4, 1); -lean_dec(x_20); -x_21 = lean_ctor_get(x_12, 0); -lean_inc(x_21); -lean_dec(x_12); -x_22 = l_Lean_Parser_isLitKind(x_21); -if (x_22 == 0) -{ -lean_object* x_23; uint8_t x_24; -x_23 = l_Lean_fieldIdxKind; -x_24 = lean_name_eq(x_21, x_23); -lean_dec(x_21); -if (x_24 == 0) -{ -lean_object* x_25; -x_25 = lean_unsigned_to_nat(0u); -lean_ctor_set(x_4, 1, x_25); -return x_4; -} -else -{ -lean_object* x_26; -x_26 = l_Lean_Parser_appPrec; -lean_ctor_set(x_4, 1, x_26); -return x_4; -} -} -else -{ -lean_object* x_27; -lean_dec(x_21); -x_27 = l_Lean_Parser_appPrec; -lean_ctor_set(x_4, 1, x_27); -return x_4; -} -} -else -{ -lean_object* x_28; lean_object* x_29; uint8_t x_30; -x_28 = lean_ctor_get(x_4, 0); -lean_inc(x_28); -lean_dec(x_4); -x_29 = lean_ctor_get(x_12, 0); -lean_inc(x_29); -lean_dec(x_12); -x_30 = l_Lean_Parser_isLitKind(x_29); -if (x_30 == 0) -{ -lean_object* x_31; uint8_t x_32; -x_31 = l_Lean_fieldIdxKind; -x_32 = lean_name_eq(x_29, x_31); -lean_dec(x_29); -if (x_32 == 0) -{ -lean_object* x_33; lean_object* x_34; -x_33 = lean_unsigned_to_nat(0u); -x_34 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_34, 0, x_28); -lean_ctor_set(x_34, 1, x_33); -return x_34; -} -else -{ -lean_object* x_35; lean_object* x_36; -x_35 = l_Lean_Parser_appPrec; -x_36 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_36, 0, x_28); -lean_ctor_set(x_36, 1, x_35); -return x_36; -} -} -else -{ -lean_object* x_37; lean_object* x_38; -lean_dec(x_29); -x_37 = l_Lean_Parser_appPrec; -x_38 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_38, 0, x_28); -lean_ctor_set(x_38, 1, x_37); -return x_38; -} -} -} -case 2: -{ -uint8_t x_39; -x_39 = !lean_is_exclusive(x_4); -if (x_39 == 0) -{ -lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; -x_40 = lean_ctor_get(x_4, 0); -x_41 = lean_ctor_get(x_4, 1); -lean_dec(x_41); -x_42 = lean_ctor_get(x_12, 1); -lean_inc(x_42); -x_43 = l_Lean_Parser_currLbp___closed__1; -x_44 = lean_string_dec_eq(x_42, x_43); -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, 3); -lean_inc(x_45); -lean_dec(x_2); -x_46 = lean_unsigned_to_nat(0u); -x_47 = l_Lean_Parser_Trie_matchPrefix___rarg(x_42, x_45, x_46); -lean_dec(x_42); -x_48 = !lean_is_exclusive(x_47); -if (x_48 == 0) -{ -lean_object* x_49; lean_object* x_50; -x_49 = lean_ctor_get(x_47, 1); -x_50 = lean_ctor_get(x_47, 0); -lean_dec(x_50); -if (lean_obj_tag(x_49) == 0) -{ -lean_ctor_set(x_47, 1, x_46); -lean_ctor_set(x_47, 0, x_40); -return x_47; -} -else -{ -lean_object* x_51; lean_object* x_52; -x_51 = lean_ctor_get(x_49, 0); -lean_inc(x_51); -lean_dec(x_49); -x_52 = lean_ctor_get(x_51, 1); -lean_inc(x_52); -if (lean_obj_tag(x_52) == 0) -{ -lean_object* x_53; -x_53 = lean_ctor_get(x_51, 2); -lean_inc(x_53); -lean_dec(x_51); -if (lean_obj_tag(x_53) == 0) -{ -lean_ctor_set(x_47, 1, x_46); -lean_ctor_set(x_47, 0, x_40); -return x_47; -} -else -{ -lean_object* x_54; -x_54 = lean_ctor_get(x_53, 0); -lean_inc(x_54); -lean_dec(x_53); -lean_ctor_set(x_47, 1, x_54); -lean_ctor_set(x_47, 0, x_40); -return x_47; -} -} -else -{ -lean_object* x_55; -x_55 = lean_ctor_get(x_51, 2); -lean_inc(x_55); -lean_dec(x_51); -if (lean_obj_tag(x_55) == 0) -{ -lean_object* x_56; -x_56 = lean_ctor_get(x_52, 0); -lean_inc(x_56); -lean_dec(x_52); -lean_ctor_set(x_47, 1, x_56); -lean_ctor_set(x_47, 0, x_40); -return x_47; -} -else -{ -lean_object* x_57; lean_object* x_58; uint8_t x_59; -x_57 = lean_ctor_get(x_52, 0); -lean_inc(x_57); -lean_dec(x_52); -x_58 = lean_ctor_get(x_55, 0); -lean_inc(x_58); -lean_dec(x_55); -x_59 = l_Lean_Parser_checkTailNoWs(x_1); -if (x_59 == 0) -{ -lean_dec(x_58); -lean_ctor_set(x_47, 1, x_57); -lean_ctor_set(x_47, 0, x_40); -return x_47; -} -else -{ -lean_dec(x_57); -lean_ctor_set(x_47, 1, x_58); -lean_ctor_set(x_47, 0, x_40); -return x_47; -} -} -} -} -} -else -{ -lean_object* x_60; -x_60 = lean_ctor_get(x_47, 1); -lean_inc(x_60); -lean_dec(x_47); -if (lean_obj_tag(x_60) == 0) -{ -lean_object* x_61; -x_61 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_61, 0, x_40); -lean_ctor_set(x_61, 1, x_46); -return x_61; -} -else -{ -lean_object* x_62; lean_object* x_63; -x_62 = lean_ctor_get(x_60, 0); -lean_inc(x_62); -lean_dec(x_60); -x_63 = lean_ctor_get(x_62, 1); -lean_inc(x_63); -if (lean_obj_tag(x_63) == 0) -{ -lean_object* x_64; -x_64 = lean_ctor_get(x_62, 2); -lean_inc(x_64); -lean_dec(x_62); -if (lean_obj_tag(x_64) == 0) -{ -lean_object* x_65; -x_65 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_65, 0, x_40); -lean_ctor_set(x_65, 1, x_46); -return x_65; -} -else -{ -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_64, 0); -lean_inc(x_66); -lean_dec(x_64); -x_67 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_67, 0, x_40); -lean_ctor_set(x_67, 1, x_66); -return x_67; -} -} -else -{ -lean_object* x_68; -x_68 = lean_ctor_get(x_62, 2); -lean_inc(x_68); -lean_dec(x_62); -if (lean_obj_tag(x_68) == 0) -{ -lean_object* x_69; lean_object* x_70; -x_69 = lean_ctor_get(x_63, 0); -lean_inc(x_69); -lean_dec(x_63); -x_70 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_70, 0, x_40); -lean_ctor_set(x_70, 1, x_69); -return x_70; -} -else -{ -lean_object* x_71; lean_object* x_72; uint8_t x_73; -x_71 = lean_ctor_get(x_63, 0); -lean_inc(x_71); -lean_dec(x_63); -x_72 = lean_ctor_get(x_68, 0); -lean_inc(x_72); -lean_dec(x_68); -x_73 = l_Lean_Parser_checkTailNoWs(x_1); -if (x_73 == 0) -{ -lean_object* x_74; -lean_dec(x_72); -x_74 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_74, 0, x_40); -lean_ctor_set(x_74, 1, x_71); -return x_74; -} -else -{ -lean_object* x_75; -lean_dec(x_71); -x_75 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_75, 0, x_40); -lean_ctor_set(x_75, 1, x_72); -return x_75; -} -} -} -} -} -} -else -{ -uint8_t x_76; -x_76 = l_Lean_Parser_checkTailNoWs(x_12); -lean_dec(x_12); -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, 3); -lean_inc(x_77); -lean_dec(x_2); -x_78 = lean_unsigned_to_nat(0u); -x_79 = l_Lean_Parser_Trie_matchPrefix___rarg(x_42, x_77, x_78); -lean_dec(x_42); -x_80 = !lean_is_exclusive(x_79); -if (x_80 == 0) -{ -lean_object* x_81; lean_object* x_82; -x_81 = lean_ctor_get(x_79, 1); -x_82 = lean_ctor_get(x_79, 0); -lean_dec(x_82); -if (lean_obj_tag(x_81) == 0) -{ -lean_ctor_set(x_79, 1, x_78); -lean_ctor_set(x_79, 0, x_40); -return x_79; -} -else -{ -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_ctor_get(x_83, 1); -lean_inc(x_84); -if (lean_obj_tag(x_84) == 0) -{ -lean_object* x_85; -x_85 = lean_ctor_get(x_83, 2); -lean_inc(x_85); -lean_dec(x_83); -if (lean_obj_tag(x_85) == 0) -{ -lean_ctor_set(x_79, 1, x_78); -lean_ctor_set(x_79, 0, x_40); -return x_79; -} -else -{ -lean_object* x_86; -x_86 = lean_ctor_get(x_85, 0); -lean_inc(x_86); -lean_dec(x_85); -lean_ctor_set(x_79, 1, x_86); -lean_ctor_set(x_79, 0, x_40); -return x_79; -} -} -else -{ -lean_object* x_87; -x_87 = lean_ctor_get(x_83, 2); -lean_inc(x_87); -lean_dec(x_83); -if (lean_obj_tag(x_87) == 0) -{ -lean_object* x_88; -x_88 = lean_ctor_get(x_84, 0); -lean_inc(x_88); -lean_dec(x_84); -lean_ctor_set(x_79, 1, x_88); -lean_ctor_set(x_79, 0, x_40); -return x_79; -} -else -{ -lean_object* x_89; lean_object* x_90; uint8_t x_91; -x_89 = lean_ctor_get(x_84, 0); -lean_inc(x_89); -lean_dec(x_84); -x_90 = lean_ctor_get(x_87, 0); -lean_inc(x_90); -lean_dec(x_87); -x_91 = l_Lean_Parser_checkTailNoWs(x_1); -if (x_91 == 0) -{ -lean_dec(x_90); -lean_ctor_set(x_79, 1, x_89); -lean_ctor_set(x_79, 0, x_40); -return x_79; -} -else -{ -lean_dec(x_89); -lean_ctor_set(x_79, 1, x_90); -lean_ctor_set(x_79, 0, x_40); -return x_79; -} -} -} -} -} -else -{ -lean_object* x_92; -x_92 = lean_ctor_get(x_79, 1); -lean_inc(x_92); -lean_dec(x_79); -if (lean_obj_tag(x_92) == 0) -{ -lean_object* x_93; -x_93 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_93, 0, x_40); -lean_ctor_set(x_93, 1, x_78); -return x_93; -} -else -{ -lean_object* x_94; lean_object* x_95; -x_94 = lean_ctor_get(x_92, 0); -lean_inc(x_94); -lean_dec(x_92); -x_95 = lean_ctor_get(x_94, 1); -lean_inc(x_95); -if (lean_obj_tag(x_95) == 0) -{ -lean_object* x_96; -x_96 = lean_ctor_get(x_94, 2); -lean_inc(x_96); -lean_dec(x_94); -if (lean_obj_tag(x_96) == 0) -{ -lean_object* x_97; -x_97 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_97, 0, x_40); -lean_ctor_set(x_97, 1, x_78); -return x_97; -} -else -{ -lean_object* x_98; lean_object* x_99; -x_98 = lean_ctor_get(x_96, 0); -lean_inc(x_98); -lean_dec(x_96); -x_99 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_99, 0, x_40); -lean_ctor_set(x_99, 1, x_98); -return x_99; -} -} -else -{ -lean_object* x_100; -x_100 = lean_ctor_get(x_94, 2); -lean_inc(x_100); -lean_dec(x_94); -if (lean_obj_tag(x_100) == 0) -{ -lean_object* x_101; lean_object* x_102; -x_101 = lean_ctor_get(x_95, 0); -lean_inc(x_101); -lean_dec(x_95); -x_102 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_102, 0, x_40); -lean_ctor_set(x_102, 1, x_101); -return x_102; -} -else -{ -lean_object* x_103; lean_object* x_104; uint8_t x_105; -x_103 = lean_ctor_get(x_95, 0); -lean_inc(x_103); -lean_dec(x_95); -x_104 = lean_ctor_get(x_100, 0); -lean_inc(x_104); -lean_dec(x_100); -x_105 = l_Lean_Parser_checkTailNoWs(x_1); -if (x_105 == 0) -{ -lean_object* x_106; -lean_dec(x_104); -x_106 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_106, 0, x_40); -lean_ctor_set(x_106, 1, x_103); -return x_106; -} -else -{ -lean_object* x_107; -lean_dec(x_103); -x_107 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_107, 0, x_40); -lean_ctor_set(x_107, 1, x_104); -return x_107; -} -} -} -} -} -} -else -{ -lean_object* x_108; -lean_dec(x_42); -lean_dec(x_2); -x_108 = l_Lean_Parser_appPrec; -lean_ctor_set(x_4, 1, x_108); -return x_4; -} -} -} -else -{ -lean_object* x_109; lean_object* x_110; lean_object* x_111; uint8_t x_112; -x_109 = lean_ctor_get(x_4, 0); -lean_inc(x_109); -lean_dec(x_4); -x_110 = lean_ctor_get(x_12, 1); -lean_inc(x_110); -x_111 = l_Lean_Parser_currLbp___closed__1; -x_112 = lean_string_dec_eq(x_110, x_111); -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, 3); -lean_inc(x_113); -lean_dec(x_2); -x_114 = lean_unsigned_to_nat(0u); -x_115 = l_Lean_Parser_Trie_matchPrefix___rarg(x_110, x_113, x_114); -lean_dec(x_110); -x_116 = lean_ctor_get(x_115, 1); -lean_inc(x_116); -if (lean_is_exclusive(x_115)) { - lean_ctor_release(x_115, 0); - lean_ctor_release(x_115, 1); - x_117 = x_115; -} else { - lean_dec_ref(x_115); - x_117 = lean_box(0); -} -if (lean_obj_tag(x_116) == 0) -{ -lean_object* x_118; -if (lean_is_scalar(x_117)) { - x_118 = lean_alloc_ctor(0, 2, 0); -} else { - x_118 = x_117; -} -lean_ctor_set(x_118, 0, x_109); -lean_ctor_set(x_118, 1, x_114); -return x_118; -} -else -{ -lean_object* x_119; lean_object* x_120; -x_119 = lean_ctor_get(x_116, 0); -lean_inc(x_119); -lean_dec(x_116); -x_120 = lean_ctor_get(x_119, 1); -lean_inc(x_120); -if (lean_obj_tag(x_120) == 0) -{ -lean_object* x_121; -x_121 = lean_ctor_get(x_119, 2); -lean_inc(x_121); -lean_dec(x_119); -if (lean_obj_tag(x_121) == 0) -{ -lean_object* x_122; -if (lean_is_scalar(x_117)) { - x_122 = lean_alloc_ctor(0, 2, 0); -} else { - x_122 = x_117; -} -lean_ctor_set(x_122, 0, x_109); -lean_ctor_set(x_122, 1, x_114); -return x_122; -} -else -{ -lean_object* x_123; lean_object* x_124; -x_123 = lean_ctor_get(x_121, 0); -lean_inc(x_123); -lean_dec(x_121); -if (lean_is_scalar(x_117)) { - x_124 = lean_alloc_ctor(0, 2, 0); -} else { - x_124 = x_117; -} -lean_ctor_set(x_124, 0, x_109); -lean_ctor_set(x_124, 1, x_123); -return x_124; -} -} -else -{ -lean_object* x_125; -x_125 = lean_ctor_get(x_119, 2); -lean_inc(x_125); -lean_dec(x_119); -if (lean_obj_tag(x_125) == 0) -{ -lean_object* x_126; lean_object* x_127; -x_126 = lean_ctor_get(x_120, 0); -lean_inc(x_126); -lean_dec(x_120); -if (lean_is_scalar(x_117)) { - x_127 = lean_alloc_ctor(0, 2, 0); -} else { - x_127 = x_117; -} -lean_ctor_set(x_127, 0, x_109); -lean_ctor_set(x_127, 1, x_126); -return x_127; -} -else -{ -lean_object* x_128; lean_object* x_129; uint8_t x_130; -x_128 = lean_ctor_get(x_120, 0); -lean_inc(x_128); -lean_dec(x_120); -x_129 = lean_ctor_get(x_125, 0); -lean_inc(x_129); -lean_dec(x_125); -x_130 = l_Lean_Parser_checkTailNoWs(x_1); -if (x_130 == 0) -{ -lean_object* x_131; -lean_dec(x_129); -if (lean_is_scalar(x_117)) { - x_131 = lean_alloc_ctor(0, 2, 0); -} else { - x_131 = x_117; -} -lean_ctor_set(x_131, 0, x_109); -lean_ctor_set(x_131, 1, x_128); -return x_131; -} -else -{ -lean_object* x_132; -lean_dec(x_128); -if (lean_is_scalar(x_117)) { - x_132 = lean_alloc_ctor(0, 2, 0); -} else { - x_132 = x_117; -} -lean_ctor_set(x_132, 0, x_109); -lean_ctor_set(x_132, 1, x_129); -return x_132; -} -} -} -} -} -else -{ -uint8_t x_133; -x_133 = l_Lean_Parser_checkTailNoWs(x_12); -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, 3); -lean_inc(x_134); -lean_dec(x_2); -x_135 = lean_unsigned_to_nat(0u); -x_136 = l_Lean_Parser_Trie_matchPrefix___rarg(x_110, x_134, x_135); -lean_dec(x_110); -x_137 = lean_ctor_get(x_136, 1); -lean_inc(x_137); -if (lean_is_exclusive(x_136)) { - lean_ctor_release(x_136, 0); - lean_ctor_release(x_136, 1); - x_138 = x_136; -} else { - lean_dec_ref(x_136); - x_138 = lean_box(0); -} -if (lean_obj_tag(x_137) == 0) -{ -lean_object* x_139; -if (lean_is_scalar(x_138)) { - x_139 = lean_alloc_ctor(0, 2, 0); -} else { - x_139 = x_138; -} -lean_ctor_set(x_139, 0, x_109); -lean_ctor_set(x_139, 1, x_135); -return x_139; -} -else -{ -lean_object* x_140; lean_object* x_141; -x_140 = lean_ctor_get(x_137, 0); -lean_inc(x_140); -lean_dec(x_137); -x_141 = lean_ctor_get(x_140, 1); -lean_inc(x_141); -if (lean_obj_tag(x_141) == 0) -{ -lean_object* x_142; -x_142 = lean_ctor_get(x_140, 2); -lean_inc(x_142); -lean_dec(x_140); -if (lean_obj_tag(x_142) == 0) -{ -lean_object* x_143; -if (lean_is_scalar(x_138)) { - x_143 = lean_alloc_ctor(0, 2, 0); -} else { - x_143 = x_138; -} -lean_ctor_set(x_143, 0, x_109); -lean_ctor_set(x_143, 1, x_135); -return x_143; -} -else -{ -lean_object* x_144; lean_object* x_145; -x_144 = lean_ctor_get(x_142, 0); -lean_inc(x_144); -lean_dec(x_142); -if (lean_is_scalar(x_138)) { - x_145 = lean_alloc_ctor(0, 2, 0); -} else { - x_145 = x_138; -} -lean_ctor_set(x_145, 0, x_109); -lean_ctor_set(x_145, 1, x_144); -return x_145; -} -} -else -{ -lean_object* x_146; -x_146 = lean_ctor_get(x_140, 2); -lean_inc(x_146); -lean_dec(x_140); -if (lean_obj_tag(x_146) == 0) -{ -lean_object* x_147; lean_object* x_148; -x_147 = lean_ctor_get(x_141, 0); -lean_inc(x_147); -lean_dec(x_141); -if (lean_is_scalar(x_138)) { - x_148 = lean_alloc_ctor(0, 2, 0); -} else { - x_148 = x_138; -} -lean_ctor_set(x_148, 0, x_109); -lean_ctor_set(x_148, 1, x_147); -return x_148; -} -else -{ -lean_object* x_149; lean_object* x_150; uint8_t x_151; -x_149 = lean_ctor_get(x_141, 0); -lean_inc(x_149); -lean_dec(x_141); -x_150 = lean_ctor_get(x_146, 0); -lean_inc(x_150); -lean_dec(x_146); -x_151 = l_Lean_Parser_checkTailNoWs(x_1); -if (x_151 == 0) -{ -lean_object* x_152; -lean_dec(x_150); -if (lean_is_scalar(x_138)) { - x_152 = lean_alloc_ctor(0, 2, 0); -} else { - x_152 = x_138; -} -lean_ctor_set(x_152, 0, x_109); -lean_ctor_set(x_152, 1, x_149); -return x_152; -} -else -{ -lean_object* x_153; -lean_dec(x_149); -if (lean_is_scalar(x_138)) { - x_153 = lean_alloc_ctor(0, 2, 0); -} else { - x_153 = x_138; -} -lean_ctor_set(x_153, 0, x_109); -lean_ctor_set(x_153, 1, x_150); -return x_153; -} -} -} -} -} -else -{ -lean_object* x_154; lean_object* x_155; -lean_dec(x_110); -lean_dec(x_2); -x_154 = l_Lean_Parser_appPrec; -x_155 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_155, 0, x_109); -lean_ctor_set(x_155, 1, x_154); -return x_155; -} -} -} -} -default: -{ -uint8_t x_156; -lean_dec(x_12); -lean_dec(x_2); -x_156 = !lean_is_exclusive(x_4); -if (x_156 == 0) -{ -lean_object* x_157; lean_object* x_158; -x_157 = lean_ctor_get(x_4, 1); -lean_dec(x_157); -x_158 = l_Lean_Parser_appPrec; -lean_ctor_set(x_4, 1, x_158); -return x_4; -} -else -{ -lean_object* x_159; lean_object* x_160; lean_object* x_161; -x_159 = lean_ctor_get(x_4, 0); -lean_inc(x_159); -lean_dec(x_4); -x_160 = l_Lean_Parser_appPrec; -x_161 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_161, 0, x_159); -lean_ctor_set(x_161, 1, x_160); -return x_161; -} -} -} -} -} -} -} -lean_object* l_Lean_Parser_currLbp___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -lean_object* x_4; -x_4 = l_Lean_Parser_currLbp(x_1, x_2, x_3); -lean_dec(x_1); -return x_4; -} -} lean_object* l_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg(lean_object* x_1, lean_object* x_2) { _start: { @@ -25166,28 +23854,26 @@ return x_3; lean_object* _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_currLbp___closed__1; -x_2 = l_String_trim(x_1); -return x_2; +lean_object* x_1; +x_1 = lean_mk_string("$"); +return x_1; } } 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___closed__1; -x_3 = lean_string_append(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Parser_dollarSymbol___elambda__1___closed__1; +x_2 = l_String_trim(x_1); +return x_2; } } 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___closed__2; -x_2 = l_Char_HasRepr___closed__1; +x_1 = l_Char_HasRepr___closed__1; +x_2 = l_Lean_Parser_dollarSymbol___elambda__1___closed__2; x_3 = lean_string_append(x_1, x_2); return x_3; } @@ -25196,8 +23882,18 @@ 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 = l_Lean_Parser_dollarSymbol___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_dollarSymbol___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_dollarSymbol___elambda__1___closed__3; +x_2 = l_Lean_Parser_dollarSymbol___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); @@ -25226,13 +23922,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___closed__1; +x_9 = l_Lean_Parser_dollarSymbol___elambda__1___closed__2; 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___closed__4; +x_11 = l_Lean_Parser_dollarSymbol___elambda__1___closed__5; x_12 = l_Lean_Parser_ParserState_mkErrorsAt(x_4, x_11, x_3); return x_12; } @@ -25246,7 +23942,7 @@ else { lean_object* x_13; lean_object* x_14; lean_dec(x_7); -x_13 = l_Lean_Parser_dollarSymbol___elambda__1___closed__4; +x_13 = l_Lean_Parser_dollarSymbol___elambda__1___closed__5; x_14 = l_Lean_Parser_ParserState_mkErrorsAt(x_4, x_13, x_3); return x_14; } @@ -25255,7 +23951,7 @@ else { lean_object* x_15; lean_object* x_16; lean_dec(x_5); -x_15 = l_Lean_Parser_dollarSymbol___elambda__1___closed__4; +x_15 = l_Lean_Parser_dollarSymbol___elambda__1___closed__5; x_16 = l_Lean_Parser_ParserState_mkErrorsAt(x_4, x_15, x_3); return x_16; } @@ -25265,36 +23961,25 @@ lean_object* _init_l_Lean_Parser_dollarSymbol___closed__1() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = lean_unsigned_to_nat(1u); -x_2 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_2, 0, x_1); +x_1 = l_Lean_Parser_dollarSymbol___elambda__1___closed__2; +x_2 = l_Lean_Parser_symbolInfo(x_1); return x_2; } } 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___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* _init_l_Lean_Parser_dollarSymbol___closed__3() { -_start: -{ lean_object* x_1; x_1 = lean_alloc_closure((void*)(l_Lean_Parser_dollarSymbol___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_dollarSymbol___closed__4() { +lean_object* _init_l_Lean_Parser_dollarSymbol___closed__3() { _start: { 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_1 = l_Lean_Parser_dollarSymbol___closed__1; +x_2 = l_Lean_Parser_dollarSymbol___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); @@ -25305,11 +23990,11 @@ lean_object* _init_l_Lean_Parser_dollarSymbol() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_dollarSymbol___closed__4; +x_1 = l_Lean_Parser_dollarSymbol___closed__3; return x_1; } } -lean_object* _init_l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1___closed__1() { +lean_object* _init_l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1___closed__1() { _start: { lean_object* x_1; @@ -25317,7 +24002,7 @@ x_1 = lean_mk_string("unexpected ':'"); return x_1; } } -lean_object* l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; lean_object* x_4; uint8_t x_5; @@ -25353,7 +24038,7 @@ return x_2; else { lean_object* x_13; lean_object* x_14; -x_13 = l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1___closed__1; +x_13 = l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1___closed__1; x_14 = l_Lean_Parser_ParserState_mkUnexpectedError(x_2, x_13); return x_14; } @@ -25366,39 +24051,39 @@ return x_2; } } } -lean_object* _init_l___private_Lean_Parser_Parser_10__noImmediateColon___closed__1() { +lean_object* _init_l___private_Lean_Parser_Parser_11__noImmediateColon___closed__1() { _start: { lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1___boxed), 2, 0); +x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1___boxed), 2, 0); return x_1; } } -lean_object* _init_l___private_Lean_Parser_Parser_10__noImmediateColon___closed__2() { +lean_object* _init_l___private_Lean_Parser_Parser_11__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_Lean_Parser_Parser_10__noImmediateColon___closed__1; +x_2 = l___private_Lean_Parser_Parser_11__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* _init_l___private_Lean_Parser_Parser_10__noImmediateColon() { +lean_object* _init_l___private_Lean_Parser_Parser_11__noImmediateColon() { _start: { lean_object* x_1; -x_1 = l___private_Lean_Parser_Parser_10__noImmediateColon___closed__2; +x_1 = l___private_Lean_Parser_Parser_11__noImmediateColon___closed__2; return x_1; } } -lean_object* l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1(x_1, x_2); +x_3 = l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1(x_1, x_2); lean_dec(x_1); return x_3; } @@ -25950,9 +24635,8 @@ lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__1() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_appPrec; -x_2 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_2, 0, x_1); +x_1 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; +x_2 = l_Lean_Parser_symbolInfo(x_1); return x_2; } } @@ -25960,65 +24644,54 @@ lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__3() { -_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_Lean_Parser_antiquotNestedExpr___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; +} +} lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__4() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +x_3 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); +return x_4; } } lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__5() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; -x_2 = lean_ctor_get(x_1, 0); -lean_inc(x_2); -x_3 = l_Lean_Parser_antiquotNestedExpr___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_antiquotNestedExpr___closed__1; +x_2 = l_Lean_Parser_antiquotNestedExpr___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__5; -x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__7() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__2; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__6; +x_2 = l_Lean_Parser_antiquotNestedExpr___closed__5; x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__8() { +lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__7() { _start: { lean_object* x_1; @@ -26026,12 +24699,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_antiquotNestedExpr___elambda__1), return x_1; } } -lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__9() { +lean_object* _init_l_Lean_Parser_antiquotNestedExpr___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__7; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__8; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__6; +x_2 = l_Lean_Parser_antiquotNestedExpr___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); @@ -26042,7 +24715,7 @@ lean_object* _init_l_Lean_Parser_antiquotNestedExpr() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__9; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__8; return x_1; } } @@ -26203,11 +24876,10 @@ return x_2; lean_object* _init_l_Lean_Parser_mkAntiquot___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_mkAntiquot___closed__4; -x_3 = l_Lean_Parser_symbolInfo(x_2, x_1); -return x_3; +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Parser_mkAntiquot___closed__4; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_mkAntiquot___closed__6() { @@ -26257,7 +24929,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_mkAntiquot___closed__9; -x_2 = l_Lean_Parser_dollarSymbol___closed__3; +x_2 = l_Lean_Parser_dollarSymbol___closed__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); @@ -26303,11 +24975,10 @@ return x_2; lean_object* _init_l_Lean_Parser_mkAntiquot___closed__15() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = lean_box(0); -x_2 = l_Lean_Parser_mkAntiquot___closed__14; -x_3 = l_Lean_Parser_symbolInfo(x_2, x_1); -return x_3; +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Parser_mkAntiquot___closed__14; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_mkAntiquot___closed__16() { @@ -26406,7 +25077,7 @@ lean_object* _init_l_Lean_Parser_mkAntiquot___closed__25() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Lean_Parser_Parser_10__noImmediateColon; +x_1 = l___private_Lean_Parser_Parser_11__noImmediateColon; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_mkAntiquot___closed__23; @@ -26418,7 +25089,7 @@ lean_object* _init_l_Lean_Parser_mkAntiquot___closed__26() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Lean_Parser_Parser_10__noImmediateColon___closed__1; +x_1 = l___private_Lean_Parser_Parser_11__noImmediateColon___closed__1; x_2 = l_Lean_Parser_mkAntiquot___closed__24; x_3 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2); lean_closure_set(x_3, 0, x_1); @@ -26646,7 +25317,7 @@ lean_object* x_7; lean_object* x_8; uint8_t x_9; x_7 = lean_ctor_get(x_6, 1); lean_inc(x_7); lean_dec(x_6); -x_8 = l_Lean_Parser_currLbp___closed__1; +x_8 = l_Lean_Parser_dollarSymbol___elambda__1___closed__1; x_9 = lean_string_dec_eq(x_7, x_8); lean_dec(x_7); return x_9; @@ -27778,7 +26449,7 @@ lean_dec(x_1); return x_5; } } -lean_object* l___private_Lean_Parser_Parser_11__mkResult(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Lean_Parser_Parser_12__mkResult(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; @@ -27833,7 +26504,7 @@ 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_Lean_Parser_Parser_11__mkResult(x_15, x_7); +x_16 = l___private_Lean_Parser_Parser_12__mkResult(x_15, x_7); return x_16; } else @@ -27998,11 +26669,11 @@ return x_16; } } } -lean_object* l___private_Lean_Parser_Parser_12__mkTrailingResult(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Lean_Parser_Parser_13__mkTrailingResult(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; -x_3 = l___private_Lean_Parser_Parser_11__mkResult(x_1, x_2); +x_3 = l___private_Lean_Parser_Parser_12__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_checkStackTopFn___spec__1(x_4); @@ -28016,116 +26687,130 @@ return x_8; lean_object* l_Lean_Parser_trailingLoop___main(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; uint8_t x_10; -x_4 = lean_ctor_get(x_3, 0); +lean_object* x_4; uint8_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; +x_4 = lean_ctor_get(x_1, 2); lean_inc(x_4); -x_5 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_4); -lean_dec(x_4); +x_5 = 0; lean_inc(x_2); -x_6 = l_Lean_Parser_currLbp(x_5, x_2, x_3); -lean_dec(x_5); +x_6 = l_Lean_Parser_indexed___rarg(x_4, x_2, x_3, x_5); +lean_dec(x_4); x_7 = lean_ctor_get(x_6, 0); lean_inc(x_7); x_8 = lean_ctor_get(x_6, 1); lean_inc(x_8); lean_dec(x_6); -x_9 = lean_ctor_get(x_2, 1); -lean_inc(x_9); -x_10 = lean_nat_dec_le(x_8, x_9); -lean_dec(x_9); -lean_dec(x_8); -if (x_10 == 0) +x_9 = l_List_isEmpty___rarg(x_8); +if (x_9 == 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_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_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); -x_17 = lean_ctor_get(x_15, 1); -lean_inc(x_17); -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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = lean_ctor_get(x_7, 0); +lean_inc(x_10); +x_11 = lean_array_get_size(x_10); +lean_dec(x_10); +x_12 = lean_ctor_get(x_7, 1); +lean_inc(x_12); lean_inc(x_2); lean_inc(x_1); -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) +x_13 = l_Lean_Parser_trailingLoopStep(x_1, x_8, x_2, x_7); +x_14 = lean_ctor_get(x_13, 3); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) { -lean_object* x_21; -x_21 = l___private_Lean_Parser_Parser_12__mkTrailingResult(x_19, x_12); -x_3 = x_21; +lean_object* x_15; +lean_dec(x_12); +x_15 = l___private_Lean_Parser_Parser_13__mkTrailingResult(x_13, x_11); +x_3 = x_15; goto _start; } else { -lean_dec(x_20); -lean_dec(x_12); +lean_object* x_17; uint8_t x_18; +lean_dec(x_14); lean_dec(x_2); lean_dec(x_1); +x_17 = lean_ctor_get(x_13, 1); +lean_inc(x_17); +x_18 = lean_nat_dec_eq(x_17, x_12); +lean_dec(x_17); +if (x_18 == 0) +{ +lean_dec(x_12); +lean_dec(x_11); +return x_13; +} +else +{ +lean_object* x_19; +x_19 = l_Lean_Parser_ParserState_restore(x_13, x_11, x_12); +lean_dec(x_11); return x_19; } } +} else { -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_20; uint8_t x_21; +x_20 = lean_ctor_get(x_1, 3); +lean_inc(x_20); +x_21 = l_List_isEmpty___rarg(x_20); +lean_dec(x_20); +if (x_21 == 0) { -lean_object* x_25; lean_object* x_26; +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_7, 0); +lean_inc(x_22); +x_23 = lean_array_get_size(x_22); +lean_dec(x_22); +x_24 = lean_ctor_get(x_7, 1); +lean_inc(x_24); lean_inc(x_2); lean_inc(x_1); -x_25 = l_Lean_Parser_trailingLoopStep(x_1, x_17, x_2, x_16); +x_25 = l_Lean_Parser_trailingLoopStep(x_1, x_8, x_2, x_7); x_26 = lean_ctor_get(x_25, 3); lean_inc(x_26); if (lean_obj_tag(x_26) == 0) { lean_object* x_27; -x_27 = l___private_Lean_Parser_Parser_12__mkTrailingResult(x_25, x_12); +lean_dec(x_24); +x_27 = l___private_Lean_Parser_Parser_13__mkTrailingResult(x_25, x_23); x_3 = x_27; goto _start; } else { +lean_object* x_29; uint8_t x_30; lean_dec(x_26); -lean_dec(x_12); lean_dec(x_2); lean_dec(x_1); +x_29 = lean_ctor_get(x_25, 1); +lean_inc(x_29); +x_30 = lean_nat_dec_eq(x_29, x_24); +lean_dec(x_29); +if (x_30 == 0) +{ +lean_dec(x_24); +lean_dec(x_23); return x_25; } -} else { -lean_dec(x_17); -lean_dec(x_12); -lean_dec(x_2); -lean_dec(x_1); -return x_16; +lean_object* x_31; +x_31 = l_Lean_Parser_ParserState_restore(x_25, x_23, x_24); +lean_dec(x_23); +return x_31; } } } else { +lean_dec(x_8); lean_dec(x_2); lean_dec(x_1); return x_7; } } } +} lean_object* l_Lean_Parser_trailingLoop(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { @@ -28134,148 +26819,108 @@ x_4 = l_Lean_Parser_trailingLoop___main(x_1, x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_prattParser___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("unexpected token"); -return x_1; -} -} 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_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; -x_7 = lean_ctor_get(x_6, 0); -lean_inc(x_7); -x_8 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_7); -lean_dec(x_7); +uint8_t x_7; +lean_inc(x_6); lean_inc(x_5); -x_9 = l_Lean_Parser_currLbp(x_8, x_5, x_6); -lean_dec(x_8); -x_10 = lean_ctor_get(x_9, 0); -lean_inc(x_10); -x_11 = lean_ctor_get(x_9, 1); -lean_inc(x_11); +x_7 = l_Lean_Parser_tryAnti(x_5, x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; +lean_dec(x_4); +lean_inc(x_5); +lean_inc(x_2); +x_8 = l_Lean_Parser_leadingParserAux(x_1, x_2, x_3, x_5, x_6); +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_trailingLoop___main(x_2, x_5, x_8); +return x_10; +} +else +{ lean_dec(x_9); -x_12 = lean_ctor_get(x_5, 1); -lean_inc(x_12); -x_13 = lean_nat_dec_lt(x_11, x_12); -lean_dec(x_12); +lean_dec(x_5); +lean_dec(x_2); +return x_8; +} +} +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_6, 0); +lean_inc(x_11); +x_12 = lean_array_get_size(x_11); lean_dec(x_11); -if (x_13 == 0) -{ -uint8_t x_14; -lean_inc(x_10); +x_13 = lean_ctor_get(x_6, 1); +lean_inc(x_13); lean_inc(x_5); -x_14 = l_Lean_Parser_tryAnti(x_5, x_10); -if (x_14 == 0) +x_14 = lean_apply_2(x_4, x_5, x_6); +x_15 = lean_ctor_get(x_14, 3); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) { -lean_object* x_15; lean_object* x_16; -lean_dec(x_4); -lean_inc(x_5); -lean_inc(x_2); -x_15 = l_Lean_Parser_leadingParserAux(x_1, x_2, x_3, x_5, x_10); -x_16 = lean_ctor_get(x_15, 3); -lean_inc(x_16); -if (lean_obj_tag(x_16) == 0) -{ -lean_object* x_17; -x_17 = l_Lean_Parser_trailingLoop___main(x_2, x_5, x_15); -return x_17; +lean_object* x_16; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_1); +x_16 = l_Lean_Parser_trailingLoop___main(x_2, x_5, x_14); +return x_16; } else { -lean_dec(x_16); -lean_dec(x_5); -lean_dec(x_2); -return x_15; -} -} -else -{ -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_10, 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_array_get_size(x_18); +x_19 = lean_nat_dec_eq(x_18, x_13); lean_dec(x_18); -x_20 = lean_ctor_get(x_10, 1); -lean_inc(x_20); -lean_inc(x_5); -x_21 = lean_apply_2(x_4, x_5, x_10); -x_22 = lean_ctor_get(x_21, 3); -lean_inc(x_22); -if (lean_obj_tag(x_22) == 0) +if (x_19 == 0) { -lean_object* x_23; -lean_dec(x_20); -lean_dec(x_19); -lean_dec(x_1); -x_23 = l_Lean_Parser_trailingLoop___main(x_2, x_5, x_21); -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); -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_20); -lean_dec(x_25); -if (x_26 == 0) -{ -lean_dec(x_24); -lean_dec(x_20); -lean_dec(x_19); +lean_dec(x_17); +lean_dec(x_13); +lean_dec(x_12); lean_dec(x_5); lean_dec(x_2); lean_dec(x_1); -return x_21; +return x_14; } else { -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; -lean_inc(x_20); -x_27 = l_Lean_Parser_ParserState_restore(x_21, x_19, x_20); -lean_dec(x_19); +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_inc(x_13); +x_20 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13); +lean_dec(x_12); lean_inc(x_5); lean_inc(x_2); -x_28 = l_Lean_Parser_leadingParserAux(x_1, x_2, x_3, x_5, x_27); -x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_24, x_20); -lean_dec(x_20); -x_30 = lean_ctor_get(x_29, 3); -lean_inc(x_30); -if (lean_obj_tag(x_30) == 0) +x_21 = l_Lean_Parser_leadingParserAux(x_1, x_2, x_3, x_5, x_20); +x_22 = l_Lean_Parser_mergeOrElseErrors(x_21, x_17, x_13); +lean_dec(x_13); +x_23 = lean_ctor_get(x_22, 3); +lean_inc(x_23); +if (lean_obj_tag(x_23) == 0) { -lean_object* x_31; -x_31 = l_Lean_Parser_trailingLoop___main(x_2, x_5, x_29); -return x_31; +lean_object* x_24; +x_24 = l_Lean_Parser_trailingLoop___main(x_2, x_5, x_22); +return x_24; } else { -lean_dec(x_30); +lean_dec(x_23); lean_dec(x_5); lean_dec(x_2); -return x_29; +return x_22; } } } } } -else -{ -lean_object* x_32; lean_object* x_33; -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_dec(x_1); -x_32 = l_Lean_Parser_prattParser___closed__1; -x_33 = l_Lean_Parser_ParserState_mkUnexpectedError(x_10, x_32); -return x_33; -} -} } 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) { _start: @@ -28330,7 +26975,7 @@ x_3 = lean_io_mk_ref(x_2, x_1); return x_3; } } -lean_object* _init_l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__1() { +lean_object* _init_l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__1() { _start: { lean_object* x_1; @@ -28338,7 +26983,7 @@ x_1 = lean_mk_string("parser category '"); return x_1; } } -lean_object* _init_l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__2() { +lean_object* _init_l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__2() { _start: { lean_object* x_1; @@ -28346,31 +26991,31 @@ x_1 = lean_mk_string("' has already been defined"); return x_1; } } -lean_object* l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg(lean_object* x_1) { +lean_object* l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg(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; lean_object* x_8; x_2 = l_Lean_Name_toString___closed__1; x_3 = l_Lean_Name_toStringWithSep___main(x_2, x_1); -x_4 = l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__1; +x_4 = l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__1; x_5 = lean_string_append(x_4, x_3); lean_dec(x_3); -x_6 = l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__2; +x_6 = l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__2; x_7 = lean_string_append(x_5, x_6); x_8 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_8, 0, x_7); return x_8; } } -lean_object* l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined(lean_object* x_1) { +lean_object* l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg), 1, 0); +x_2 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg), 1, 0); return x_2; } } -uint8_t l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__2(lean_object* x_1, size_t x_2, lean_object* x_3) { +uint8_t l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__2(lean_object* x_1, size_t x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_1) == 0) @@ -28430,7 +27075,7 @@ return x_19; } } } -uint8_t l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__1(lean_object* x_1, lean_object* x_2) { +uint8_t l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__1(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; size_t x_4; uint8_t x_5; @@ -28438,11 +27083,11 @@ x_3 = lean_ctor_get(x_1, 0); lean_inc(x_3); lean_dec(x_1); x_4 = l_Lean_Name_hash(x_2); -x_5 = l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__2(x_3, x_4, x_2); +x_5 = l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__2(x_3, x_4, x_2); return x_5; } } -lean_object* l_PersistentHashMap_insertAtCollisionNodeAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_PersistentHashMap_insertAtCollisionNodeAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__5(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; uint8_t x_8; @@ -28534,7 +27179,7 @@ return x_29; } } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__6(size_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_Array_iterateMAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__6(size_t 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; uint8_t x_8; @@ -28557,7 +27202,7 @@ x_13 = x_1 - x_12; x_14 = 5; x_15 = x_14 * x_13; x_16 = x_11 >> x_15; -x_17 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4(x_6, x_16, x_1, x_9, x_10); +x_17 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4(x_6, x_16, x_1, x_9, x_10); x_18 = lean_unsigned_to_nat(1u); x_19 = lean_nat_add(x_5, x_18); lean_dec(x_5); @@ -28567,7 +27212,7 @@ goto _start; } } } -lean_object* l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5) { _start: { if (lean_obj_tag(x_1) == 0) @@ -28680,7 +27325,7 @@ lean_object* x_35; size_t x_36; size_t x_37; lean_object* x_38; lean_object* x_3 x_35 = lean_ctor_get(x_15, 0); x_36 = x_2 >> x_9; x_37 = x_3 + x_8; -x_38 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4(x_35, x_36, x_37, x_4, x_5); +x_38 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4(x_35, x_36, x_37, x_4, x_5); lean_ctor_set(x_15, 0, x_38); x_39 = lean_array_fset(x_17, x_12, x_15); lean_dec(x_12); @@ -28695,7 +27340,7 @@ lean_inc(x_40); lean_dec(x_15); x_41 = x_2 >> x_9; x_42 = x_3 + x_8; -x_43 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4(x_40, x_41, x_42, x_4, x_5); +x_43 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4(x_40, x_41, x_42, x_4, x_5); x_44 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_44, 0, x_43); x_45 = lean_array_fset(x_17, x_12, x_44); @@ -28811,7 +27456,7 @@ if (lean_is_exclusive(x_57)) { } x_73 = x_2 >> x_50; x_74 = x_3 + x_49; -x_75 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4(x_71, x_73, x_74, x_4, x_5); +x_75 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4(x_71, x_73, x_74, x_4, x_5); if (lean_is_scalar(x_72)) { x_76 = lean_alloc_ctor(1, 1, 0); } else { @@ -28844,7 +27489,7 @@ else { lean_object* x_82; lean_object* x_83; size_t x_84; uint8_t x_85; x_82 = lean_unsigned_to_nat(0u); -x_83 = l_PersistentHashMap_insertAtCollisionNodeAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__5(x_1, x_82, x_4, x_5); +x_83 = l_PersistentHashMap_insertAtCollisionNodeAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__5(x_1, x_82, x_4, x_5); x_84 = 7; x_85 = x_84 <= x_3; if (x_85 == 0) @@ -28863,7 +27508,7 @@ x_90 = lean_ctor_get(x_83, 1); lean_inc(x_90); lean_dec(x_83); x_91 = l_PersistentHashMap_insertAux___main___rarg___closed__3; -x_92 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__6(x_3, x_89, x_90, x_89, x_82, x_91); +x_92 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__6(x_3, x_89, x_90, x_89, x_82, x_91); lean_dec(x_90); lean_dec(x_89); return x_92; @@ -28880,7 +27525,7 @@ return x_83; } } } -lean_object* l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { uint8_t x_4; @@ -28892,7 +27537,7 @@ x_5 = lean_ctor_get(x_1, 0); x_6 = lean_ctor_get(x_1, 1); x_7 = l_Lean_Name_hash(x_2); x_8 = 1; -x_9 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4(x_5, x_7, x_8, x_2, x_3); +x_9 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4(x_5, x_7, x_8, x_2, x_3); x_10 = lean_unsigned_to_nat(1u); x_11 = lean_nat_add(x_6, x_10); lean_dec(x_6); @@ -28910,7 +27555,7 @@ lean_inc(x_12); lean_dec(x_1); x_14 = l_Lean_Name_hash(x_2); x_15 = 1; -x_16 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4(x_12, x_14, x_15, x_2, x_3); +x_16 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4(x_12, x_14, x_15, x_2, x_3); x_17 = lean_unsigned_to_nat(1u); x_18 = lean_nat_add(x_13, x_17); lean_dec(x_13); @@ -28921,16 +27566,16 @@ return x_19; } } } -lean_object* l___private_Lean_Parser_Parser_14__addParserCategoryCore(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Lean_Parser_Parser_15__addParserCategoryCore(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { uint8_t x_4; lean_inc(x_1); -x_4 = l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__1(x_1, x_2); +x_4 = l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__1(x_1, x_2); if (x_4 == 0) { lean_object* x_5; lean_object* x_6; -x_5 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_1, x_2, x_3); +x_5 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_1, x_2, x_3); x_6 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_6, 0, x_5); return x_6; @@ -28940,47 +27585,47 @@ else lean_object* x_7; lean_dec(x_3); lean_dec(x_1); -x_7 = l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg(x_2); +x_7 = l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg(x_2); return x_7; } } } -lean_object* l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { size_t x_4; uint8_t x_5; lean_object* x_6; x_4 = lean_unbox_usize(x_2); lean_dec(x_2); -x_5 = l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__2(x_1, x_4, x_3); +x_5 = l_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__2(x_1, x_4, x_3); lean_dec(x_3); x_6 = lean_box(x_5); return x_6; } } -lean_object* l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__1___boxed(lean_object* x_1, lean_object* x_2) { _start: { uint8_t x_3; lean_object* x_4; -x_3 = l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__1(x_1, x_2); +x_3 = l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__1(x_1, x_2); lean_dec(x_2); x_4 = lean_box(x_3); return x_4; } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___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* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___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) { _start: { size_t x_7; lean_object* x_8; x_7 = lean_unbox_usize(x_1); lean_dec(x_1); -x_8 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__6(x_7, x_2, x_3, x_4, x_5, x_6); +x_8 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__6(x_7, x_2, x_3, x_4, x_5, x_6); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); return x_8; } } -lean_object* l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___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* l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { size_t x_6; size_t x_7; lean_object* x_8; @@ -28988,11 +27633,11 @@ x_6 = lean_unbox_usize(x_2); lean_dec(x_2); x_7 = lean_unbox_usize(x_3); lean_dec(x_3); -x_8 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__4(x_1, x_6, x_7, x_4, x_5); +x_8 = l_PersistentHashMap_insertAux___main___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__4(x_1, x_6, x_7, x_4, x_5); return x_8; } } -lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_15__addBuiltinParserCategory___spec__1(lean_object* x_1, lean_object* x_2) { +lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_16__addBuiltinParserCategory___spec__1(lean_object* x_1, lean_object* x_2) { _start: { if (lean_obj_tag(x_1) == 0) @@ -29019,7 +27664,7 @@ return x_7; } } } -lean_object* l___private_Lean_Parser_Parser_15__addBuiltinParserCategory(lean_object* x_1, uint8_t x_2, lean_object* x_3) { +lean_object* l___private_Lean_Parser_Parser_16__addBuiltinParserCategory(lean_object* x_1, uint8_t x_2, lean_object* x_3) { _start: { lean_object* x_4; lean_object* x_5; @@ -29037,8 +27682,8 @@ x_8 = l_Lean_Parser_PrattParsingTables_inhabited___closed__1; x_9 = lean_alloc_ctor(0, 1, 1); lean_ctor_set(x_9, 0, x_8); lean_ctor_set_uint8(x_9, sizeof(void*)*1, x_2); -x_10 = l___private_Lean_Parser_Parser_14__addParserCategoryCore(x_6, x_1, x_9); -x_11 = l_IO_ofExcept___at___private_Lean_Parser_Parser_15__addBuiltinParserCategory___spec__1(x_10, x_7); +x_10 = l___private_Lean_Parser_Parser_15__addParserCategoryCore(x_6, x_1, x_9); +x_11 = l_IO_ofExcept___at___private_Lean_Parser_Parser_16__addBuiltinParserCategory___spec__1(x_10, x_7); lean_dec(x_10); if (lean_obj_tag(x_11) == 0) { @@ -29099,22 +27744,22 @@ return x_22; } } } -lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_15__addBuiltinParserCategory___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_16__addBuiltinParserCategory___spec__1___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = l_IO_ofExcept___at___private_Lean_Parser_Parser_15__addBuiltinParserCategory___spec__1(x_1, x_2); +x_3 = l_IO_ofExcept___at___private_Lean_Parser_Parser_16__addBuiltinParserCategory___spec__1(x_1, x_2); lean_dec(x_1); return x_3; } } -lean_object* l___private_Lean_Parser_Parser_15__addBuiltinParserCategory___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Lean_Parser_Parser_16__addBuiltinParserCategory___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___private_Lean_Parser_Parser_15__addBuiltinParserCategory(x_1, x_4, x_3); +x_5 = l___private_Lean_Parser_Parser_16__addBuiltinParserCategory(x_1, x_4, x_3); return x_5; } } @@ -29142,7 +27787,7 @@ x_1 = l_Lean_Parser_ParserExtensionState_inhabited___closed__1; return x_1; } } -lean_object* l___private_Lean_Parser_Parser_16__ParserExtension_mkInitial(lean_object* x_1) { +lean_object* l___private_Lean_Parser_Parser_17__ParserExtension_mkInitial(lean_object* x_1) { _start: { lean_object* x_2; lean_object* x_3; @@ -29278,7 +27923,7 @@ return x_32; } } } -lean_object* _init_l___private_Lean_Parser_Parser_17__mergePrecendences___closed__1() { +lean_object* _init_l___private_Lean_Parser_Parser_18__mergePrecendences___closed__1() { _start: { lean_object* x_1; @@ -29286,7 +27931,7 @@ x_1 = lean_mk_string("precedence mismatch for '"); return x_1; } } -lean_object* _init_l___private_Lean_Parser_Parser_17__mergePrecendences___closed__2() { +lean_object* _init_l___private_Lean_Parser_Parser_18__mergePrecendences___closed__2() { _start: { lean_object* x_1; @@ -29294,7 +27939,7 @@ x_1 = lean_mk_string("', previous: "); return x_1; } } -lean_object* _init_l___private_Lean_Parser_Parser_17__mergePrecendences___closed__3() { +lean_object* _init_l___private_Lean_Parser_Parser_18__mergePrecendences___closed__3() { _start: { lean_object* x_1; @@ -29302,7 +27947,7 @@ x_1 = lean_mk_string(", new: "); return x_1; } } -lean_object* l___private_Lean_Parser_Parser_17__mergePrecendences(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Lean_Parser_Parser_18__mergePrecendences(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { if (lean_obj_tag(x_3) == 0) @@ -29336,15 +27981,15 @@ if (x_9 == 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_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_dec(x_3); -x_10 = l___private_Lean_Parser_Parser_17__mergePrecendences___closed__1; +x_10 = l___private_Lean_Parser_Parser_18__mergePrecendences___closed__1; x_11 = lean_string_append(x_1, x_10); x_12 = lean_string_append(x_11, x_2); -x_13 = l___private_Lean_Parser_Parser_17__mergePrecendences___closed__2; +x_13 = l___private_Lean_Parser_Parser_18__mergePrecendences___closed__2; x_14 = lean_string_append(x_12, x_13); x_15 = l_Nat_repr(x_7); x_16 = lean_string_append(x_14, x_15); lean_dec(x_15); -x_17 = l___private_Lean_Parser_Parser_17__mergePrecendences___closed__3; +x_17 = l___private_Lean_Parser_Parser_18__mergePrecendences___closed__3; x_18 = lean_string_append(x_16, x_17); x_19 = l_Nat_repr(x_8); x_20 = lean_string_append(x_18, x_19); @@ -29367,24 +28012,16 @@ return x_22; } } } -lean_object* l___private_Lean_Parser_Parser_17__mergePrecendences___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Lean_Parser_Parser_18__mergePrecendences___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___private_Lean_Parser_Parser_17__mergePrecendences(x_1, x_2, x_3, x_4); +x_5 = l___private_Lean_Parser_Parser_18__mergePrecendences(x_1, x_2, x_3, x_4); lean_dec(x_2); return x_5; } } -lean_object* _init_l___private_Lean_Parser_Parser_18__addTokenConfig___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(no whitespace) "); -return x_1; -} -} -lean_object* _init_l___private_Lean_Parser_Parser_18__addTokenConfig___closed__2() { +lean_object* _init_l___private_Lean_Parser_Parser_19__addTokenConfig___closed__1() { _start: { lean_object* x_1; @@ -29392,265 +28029,55 @@ x_1 = lean_mk_string("invalid empty symbol"); return x_1; } } -lean_object* _init_l___private_Lean_Parser_Parser_18__addTokenConfig___closed__3() { +lean_object* _init_l___private_Lean_Parser_Parser_19__addTokenConfig___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Lean_Parser_Parser_18__addTokenConfig___closed__2; +x_1 = l___private_Lean_Parser_Parser_19__addTokenConfig___closed__1; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* l___private_Lean_Parser_Parser_18__addTokenConfig(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Lean_Parser_Parser_19__addTokenConfig(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; -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_2, 2); -lean_inc(x_5); -x_6 = l_String_splitAux___main___closed__1; -x_7 = lean_string_dec_eq(x_3, x_6); -if (x_7 == 0) +lean_object* x_3; uint8_t x_4; +x_3 = l_String_splitAux___main___closed__1; +x_4 = lean_string_dec_eq(x_2, x_3); +if (x_4 == 0) { -lean_object* x_8; lean_object* x_9; -x_8 = lean_unsigned_to_nat(0u); +lean_object* x_5; lean_object* x_6; +x_5 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_9 = l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(x_3, x_1, x_8); -if (lean_obj_tag(x_9) == 0) +x_6 = l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(x_2, x_1, x_5); +if (lean_obj_tag(x_6) == 0) { -lean_object* x_10; lean_object* x_11; -lean_dec(x_5); -lean_dec(x_4); -x_10 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_3, x_2, x_1, x_8); -lean_dec(x_3); -x_11 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_11, 0, x_10); -return x_11; -} -else -{ -uint8_t x_12; -x_12 = !lean_is_exclusive(x_2); -if (x_12 == 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; -x_13 = lean_ctor_get(x_2, 2); -lean_dec(x_13); -x_14 = lean_ctor_get(x_2, 1); -lean_dec(x_14); -x_15 = lean_ctor_get(x_2, 0); -lean_dec(x_15); -x_16 = lean_ctor_get(x_9, 0); -lean_inc(x_16); -lean_dec(x_9); -x_17 = lean_ctor_get(x_16, 1); -lean_inc(x_17); -x_18 = l___private_Lean_Parser_Parser_17__mergePrecendences(x_6, x_3, x_17, x_4); -if (lean_obj_tag(x_18) == 0) -{ -uint8_t x_19; -lean_dec(x_16); -lean_free_object(x_2); -lean_dec(x_5); -lean_dec(x_3); -lean_dec(x_1); -x_19 = !lean_is_exclusive(x_18); -if (x_19 == 0) -{ -return x_18; -} -else -{ -lean_object* x_20; lean_object* x_21; -x_20 = lean_ctor_get(x_18, 0); -lean_inc(x_20); -lean_dec(x_18); -x_21 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_21, 0, x_20); -return x_21; -} -} -else -{ -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; -x_22 = lean_ctor_get(x_18, 0); -lean_inc(x_22); -lean_dec(x_18); -x_23 = lean_ctor_get(x_16, 2); -lean_inc(x_23); -lean_dec(x_16); -x_24 = l___private_Lean_Parser_Parser_18__addTokenConfig___closed__1; -x_25 = l___private_Lean_Parser_Parser_17__mergePrecendences(x_24, x_3, x_23, x_5); -if (lean_obj_tag(x_25) == 0) -{ -uint8_t x_26; -lean_dec(x_22); -lean_free_object(x_2); -lean_dec(x_3); -lean_dec(x_1); -x_26 = !lean_is_exclusive(x_25); -if (x_26 == 0) -{ -return x_25; -} -else -{ -lean_object* x_27; lean_object* x_28; -x_27 = lean_ctor_get(x_25, 0); -lean_inc(x_27); -lean_dec(x_25); -x_28 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_28, 0, x_27); -return x_28; -} -} -else -{ -uint8_t x_29; -x_29 = !lean_is_exclusive(x_25); -if (x_29 == 0) -{ -lean_object* x_30; lean_object* x_31; -x_30 = lean_ctor_get(x_25, 0); -lean_inc(x_3); -lean_ctor_set(x_2, 2, x_30); -lean_ctor_set(x_2, 1, x_22); -x_31 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_3, x_2, x_1, x_8); -lean_dec(x_3); -lean_ctor_set(x_25, 0, x_31); -return x_25; -} -else -{ -lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_32 = lean_ctor_get(x_25, 0); -lean_inc(x_32); -lean_dec(x_25); -lean_inc(x_3); -lean_ctor_set(x_2, 2, x_32); -lean_ctor_set(x_2, 1, x_22); -x_33 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_3, x_2, x_1, x_8); -lean_dec(x_3); -x_34 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_34, 0, x_33); -return x_34; -} -} -} -} -else -{ -lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_object* x_7; lean_object* x_8; +lean_inc(x_2); +x_7 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_2, x_2, x_1, x_5); lean_dec(x_2); -x_35 = lean_ctor_get(x_9, 0); -lean_inc(x_35); -lean_dec(x_9); -x_36 = lean_ctor_get(x_35, 1); -lean_inc(x_36); -x_37 = l___private_Lean_Parser_Parser_17__mergePrecendences(x_6, x_3, x_36, x_4); -if (lean_obj_tag(x_37) == 0) -{ -lean_object* x_38; lean_object* x_39; lean_object* x_40; -lean_dec(x_35); -lean_dec(x_5); -lean_dec(x_3); -lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -if (lean_is_exclusive(x_37)) { - lean_ctor_release(x_37, 0); - x_39 = x_37; -} else { - lean_dec_ref(x_37); - x_39 = lean_box(0); -} -if (lean_is_scalar(x_39)) { - x_40 = lean_alloc_ctor(0, 1, 0); -} else { - x_40 = x_39; -} -lean_ctor_set(x_40, 0, x_38); -return x_40; +x_8 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_8, 0, x_7); +return x_8; } else { -lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; -x_41 = lean_ctor_get(x_37, 0); -lean_inc(x_41); -lean_dec(x_37); -x_42 = lean_ctor_get(x_35, 2); -lean_inc(x_42); -lean_dec(x_35); -x_43 = l___private_Lean_Parser_Parser_18__addTokenConfig___closed__1; -x_44 = l___private_Lean_Parser_Parser_17__mergePrecendences(x_43, x_3, x_42, x_5); -if (lean_obj_tag(x_44) == 0) -{ -lean_object* x_45; lean_object* x_46; lean_object* x_47; -lean_dec(x_41); -lean_dec(x_3); -lean_dec(x_1); -x_45 = lean_ctor_get(x_44, 0); -lean_inc(x_45); -if (lean_is_exclusive(x_44)) { - lean_ctor_release(x_44, 0); - x_46 = x_44; -} else { - lean_dec_ref(x_44); - x_46 = lean_box(0); -} -if (lean_is_scalar(x_46)) { - x_47 = lean_alloc_ctor(0, 1, 0); -} else { - x_47 = x_46; -} -lean_ctor_set(x_47, 0, x_45); -return x_47; -} -else -{ -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_44, 0); -lean_inc(x_48); -if (lean_is_exclusive(x_44)) { - lean_ctor_release(x_44, 0); - x_49 = x_44; -} else { - lean_dec_ref(x_44); - x_49 = lean_box(0); -} -lean_inc(x_3); -x_50 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_50, 0, x_3); -lean_ctor_set(x_50, 1, x_41); -lean_ctor_set(x_50, 2, x_48); -x_51 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_3, x_50, x_1, x_8); -lean_dec(x_3); -if (lean_is_scalar(x_49)) { - x_52 = lean_alloc_ctor(1, 1, 0); -} else { - x_52 = x_49; -} -lean_ctor_set(x_52, 0, x_51); -return x_52; -} -} -} +lean_object* x_9; +lean_dec(x_6); +lean_dec(x_2); +x_9 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_9, 0, x_1); +return x_9; } } else { -lean_object* x_53; -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_3); +lean_object* x_10; lean_dec(x_2); lean_dec(x_1); -x_53 = l___private_Lean_Parser_Parser_18__addTokenConfig___closed__3; -return x_53; +x_10 = l___private_Lean_Parser_Parser_19__addTokenConfig___closed__2; +return x_10; } } } @@ -29833,37 +28260,31 @@ 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; 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 = lean_ctor_get(x_1, 0); x_5 = lean_ctor_get(x_1, 1); -x_6 = lean_ctor_get(x_4, 0); -lean_inc(x_6); -lean_dec(x_4); -x_7 = lean_box(0); -x_8 = lean_name_mk_string(x_7, x_6); -x_9 = l_List_map___main___at_Lean_Parser_addLeadingParser___spec__4(x_5); -lean_ctor_set(x_1, 1, x_9); -lean_ctor_set(x_1, 0, x_8); +x_6 = lean_box(0); +x_7 = lean_name_mk_string(x_6, x_4); +x_8 = l_List_map___main___at_Lean_Parser_addLeadingParser___spec__4(x_5); +lean_ctor_set(x_1, 1, x_8); +lean_ctor_set(x_1, 0, x_7); 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_16; -x_10 = lean_ctor_get(x_1, 0); -x_11 = lean_ctor_get(x_1, 1); -lean_inc(x_11); +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_1, 0); +x_10 = lean_ctor_get(x_1, 1); lean_inc(x_10); +lean_inc(x_9); lean_dec(x_1); -x_12 = lean_ctor_get(x_10, 0); -lean_inc(x_12); -lean_dec(x_10); -x_13 = lean_box(0); -x_14 = lean_name_mk_string(x_13, x_12); -x_15 = l_List_map___main___at_Lean_Parser_addLeadingParser___spec__4(x_11); -x_16 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_16, 0, x_14); -lean_ctor_set(x_16, 1, x_15); -return x_16; +x_11 = lean_box(0); +x_12 = lean_name_mk_string(x_11, x_9); +x_13 = l_List_map___main___at_Lean_Parser_addLeadingParser___spec__4(x_10); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_12); +lean_ctor_set(x_14, 1, x_13); +return x_14; } } } @@ -30068,7 +28489,7 @@ x_13 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_13, 0, x_4); lean_ctor_set(x_13, 1, x_12); lean_ctor_set(x_10, 1, x_13); -x_14 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_1, x_2, x_7); +x_14 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_1, x_2, x_7); x_15 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_15, 0, x_14); return x_15; @@ -30094,7 +28515,7 @@ lean_ctor_set(x_21, 1, x_20); lean_ctor_set(x_21, 2, x_18); lean_ctor_set(x_21, 3, x_19); lean_ctor_set(x_7, 0, x_21); -x_22 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_1, x_2, x_7); +x_22 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_1, x_2, x_7); x_23 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_23, 0, x_22); return x_23; @@ -30140,7 +28561,7 @@ lean_ctor_set(x_32, 3, x_29); x_33 = lean_alloc_ctor(0, 1, 1); lean_ctor_set(x_33, 0, x_32); lean_ctor_set_uint8(x_33, sizeof(void*)*1, x_25); -x_34 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_1, x_2, x_33); +x_34 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_1, x_2, x_33); x_35 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_35, 0, x_34); return x_35; @@ -30158,7 +28579,7 @@ x_40 = lean_ctor_get(x_7, 0); x_41 = l_List_eraseDups___at_Lean_Parser_addLeadingParser___spec__5(x_38); x_42 = l_List_foldl___main___at_Lean_Parser_addLeadingParser___spec__7(x_4, x_40, x_41); lean_ctor_set(x_7, 0, x_42); -x_43 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_1, x_2, x_7); +x_43 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_1, x_2, x_7); x_44 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_44, 0, x_43); return x_44; @@ -30175,7 +28596,7 @@ x_48 = l_List_foldl___main___at_Lean_Parser_addLeadingParser___spec__7(x_4, x_45 x_49 = lean_alloc_ctor(0, 1, 1); lean_ctor_set(x_49, 0, x_48); lean_ctor_set_uint8(x_49, sizeof(void*)*1, x_46); -x_50 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_1, x_2, x_49); +x_50 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_1, x_2, x_49); x_51 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_51, 0, x_50); return x_51; @@ -30224,7 +28645,7 @@ lean_dec(x_3); return x_5; } } -lean_object* l_List_foldl___main___at___private_Lean_Parser_Parser_19__addTrailingParserAux___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Lean_Parser_Parser_20__addTrailingParserAux___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -30277,7 +28698,7 @@ goto _start; } } } -lean_object* l___private_Lean_Parser_Parser_19__addTrailingParserAux(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Lean_Parser_Parser_20__addTrailingParserAux(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; lean_object* x_14; lean_object* x_19; lean_object* x_20; @@ -30357,7 +28778,7 @@ block_18: lean_object* x_15; lean_object* x_16; lean_object* x_17; x_15 = l_List_map___main___at_Lean_Parser_addLeadingParser___spec__4(x_14); x_16 = l_List_eraseDups___at_Lean_Parser_addLeadingParser___spec__5(x_15); -x_17 = l_List_foldl___main___at___private_Lean_Parser_Parser_19__addTrailingParserAux___spec__1(x_2, x_1, x_16); +x_17 = l_List_foldl___main___at___private_Lean_Parser_Parser_20__addTrailingParserAux___spec__1(x_2, x_1, x_16); return x_17; } } @@ -30387,9 +28808,9 @@ if (x_7 == 0) { lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; x_8 = lean_ctor_get(x_6, 0); -x_9 = l___private_Lean_Parser_Parser_19__addTrailingParserAux(x_8, x_3); +x_9 = l___private_Lean_Parser_Parser_20__addTrailingParserAux(x_8, x_3); lean_ctor_set(x_6, 0, x_9); -x_10 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_1, x_2, x_6); +x_10 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_1, x_2, x_6); x_11 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_11, 0, x_10); return x_11; @@ -30401,11 +28822,11 @@ x_12 = lean_ctor_get(x_6, 0); x_13 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); lean_inc(x_12); lean_dec(x_6); -x_14 = l___private_Lean_Parser_Parser_19__addTrailingParserAux(x_12, x_3); +x_14 = l___private_Lean_Parser_Parser_20__addTrailingParserAux(x_12, x_3); x_15 = lean_alloc_ctor(0, 1, 1); lean_ctor_set(x_15, 0, x_14); lean_ctor_set_uint8(x_15, sizeof(void*)*1, x_13); -x_16 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_1, x_2, x_15); +x_16 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_1, x_2, x_15); x_17 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_17, 0, x_16); return x_17; @@ -30459,7 +28880,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_2, 1); lean_inc(x_5); lean_dec(x_2); -x_6 = l___private_Lean_Parser_Parser_18__addTokenConfig(x_1, x_4); +x_6 = l___private_Lean_Parser_Parser_19__addTokenConfig(x_1, x_4); if (lean_obj_tag(x_6) == 0) { uint8_t x_7; @@ -30506,7 +28927,7 @@ x_6 = l_List_foldlM___main___at_Lean_Parser_addParserTokens___spec__1(x_1, x_5); return x_6; } } -lean_object* _init_l___private_Lean_Parser_Parser_20__updateBuiltinTokens___closed__1() { +lean_object* _init_l___private_Lean_Parser_Parser_21__updateBuiltinTokens___closed__1() { _start: { lean_object* x_1; @@ -30514,7 +28935,7 @@ x_1 = lean_mk_string("invalid builtin parser '"); return x_1; } } -lean_object* l___private_Lean_Parser_Parser_20__updateBuiltinTokens(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Lean_Parser_Parser_21__updateBuiltinTokens(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; @@ -30539,7 +28960,7 @@ lean_inc(x_11); lean_dec(x_10); x_12 = l_Lean_Name_toString___closed__1; x_13 = l_Lean_Name_toStringWithSep___main(x_12, x_2); -x_14 = l___private_Lean_Parser_Parser_20__updateBuiltinTokens___closed__1; +x_14 = l___private_Lean_Parser_Parser_21__updateBuiltinTokens___closed__1; x_15 = lean_string_append(x_14, x_13); lean_dec(x_13); x_16 = l_Lean_registerTagAttribute___lambda__4___closed__4; @@ -30581,7 +29002,7 @@ lean_inc(x_25); lean_dec(x_24); x_26 = l_Lean_Name_toString___closed__1; x_27 = l_Lean_Name_toStringWithSep___main(x_26, x_2); -x_28 = l___private_Lean_Parser_Parser_20__updateBuiltinTokens___closed__1; +x_28 = l___private_Lean_Parser_Parser_21__updateBuiltinTokens___closed__1; x_29 = lean_string_append(x_28, x_27); lean_dec(x_27); x_30 = l_Lean_registerTagAttribute___lambda__4___closed__4; @@ -30649,7 +29070,7 @@ lean_inc(x_9); lean_dec(x_7); lean_inc(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_Lean_Parser_Parser_15__addBuiltinParserCategory___spec__1(x_10, x_9); +x_11 = l_IO_ofExcept___at___private_Lean_Parser_Parser_16__addBuiltinParserCategory___spec__1(x_10, x_9); lean_dec(x_10); if (lean_obj_tag(x_11) == 0) { @@ -30696,7 +29117,7 @@ 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_Lean_Parser_Parser_20__updateBuiltinTokens(x_14, x_2, x_26); +x_27 = l___private_Lean_Parser_Parser_21__updateBuiltinTokens(x_14, x_2, x_26); return x_27; } else @@ -30882,7 +29303,7 @@ x_6 = l_Lean_Parser_addBuiltinParser(x_1, x_2, x_5, x_3, x_4); return x_6; } } -lean_object* l___private_Lean_Parser_Parser_21__ParserExtension_addEntry(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Lean_Parser_Parser_22__ParserExtension_addEntry(lean_object* x_1, lean_object* x_2) { _start: { switch (lean_obj_tag(x_2)) { @@ -30901,7 +29322,7 @@ x_6 = lean_ctor_get(x_1, 1); x_7 = lean_ctor_get(x_1, 2); x_8 = lean_ctor_get(x_1, 3); lean_inc(x_3); -x_9 = l___private_Lean_Parser_Parser_18__addTokenConfig(x_5, x_3); +x_9 = l___private_Lean_Parser_Parser_19__addTokenConfig(x_5, x_3); if (lean_obj_tag(x_9) == 0) { lean_object* x_10; lean_object* x_11; @@ -30944,7 +29365,7 @@ lean_inc(x_16); lean_inc(x_15); lean_dec(x_1); lean_inc(x_3); -x_19 = l___private_Lean_Parser_Parser_18__addTokenConfig(x_15, x_3); +x_19 = l___private_Lean_Parser_Parser_19__addTokenConfig(x_15, x_3); if (lean_obj_tag(x_19) == 0) { lean_object* x_20; lean_object* x_21; @@ -31045,7 +29466,7 @@ lean_inc(x_47); x_48 = lean_ctor_get(x_1, 3); lean_inc(x_48); lean_inc(x_47); -x_49 = l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__1(x_47, x_43); +x_49 = l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__1(x_47, x_43); if (x_49 == 0) { uint8_t x_50; @@ -31066,7 +29487,7 @@ x_56 = lean_alloc_ctor(0, 1, 1); lean_ctor_set(x_56, 0, x_55); lean_ctor_set_uint8(x_56, sizeof(void*)*1, x_44); lean_inc(x_43); -x_57 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_47, x_43, x_56); +x_57 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_47, x_43, x_56); x_58 = lean_alloc_ctor(2, 1, 1); lean_ctor_set(x_58, 0, x_43); lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_44); @@ -31086,7 +29507,7 @@ x_61 = lean_alloc_ctor(0, 1, 1); lean_ctor_set(x_61, 0, x_60); lean_ctor_set_uint8(x_61, sizeof(void*)*1, x_44); lean_inc(x_43); -x_62 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__3(x_47, x_43, x_61); +x_62 = l_PersistentHashMap_insert___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__3(x_47, x_43, x_61); x_63 = lean_alloc_ctor(2, 1, 1); lean_ctor_set(x_63, 0, x_43); lean_ctor_set_uint8(x_63, sizeof(void*)*1, x_44); @@ -32339,108 +30760,123 @@ return x_275; } case 11: { -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_object* x_283; +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_dec(x_1); 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 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_278, 0, x_277); -x_279 = l_String_trim(x_276); +x_277 = l_String_trim(x_276); lean_dec(x_276); -lean_inc(x_279); -x_280 = l_Lean_Parser_symbolInfo(x_279, x_278); -x_281 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1); -lean_closure_set(x_281, 0, x_279); -x_282 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_282, 0, x_280); -lean_ctor_set(x_282, 1, x_281); -x_283 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_283, 0, x_282); -return x_283; +lean_inc(x_277); +x_278 = l_Lean_Parser_symbolInfo(x_277); +x_279 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 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 12: { -lean_object* x_284; uint8_t x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; +lean_object* x_282; uint8_t x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_dec(x_1); -x_284 = lean_ctor_get(x_2, 0); -lean_inc(x_284); -x_285 = lean_ctor_get_uint8(x_2, sizeof(void*)*1); +x_282 = lean_ctor_get(x_2, 0); +lean_inc(x_282); +x_283 = lean_ctor_get_uint8(x_2, sizeof(void*)*1); lean_dec(x_2); -x_286 = l_String_trim(x_284); -lean_dec(x_284); -lean_inc(x_286); -x_287 = l_Lean_Parser_nonReservedSymbolInfo(x_286, x_285); -x_288 = lean_alloc_closure((void*)(l_Lean_Parser_nonReservedSymbolFn), 3, 1); -lean_closure_set(x_288, 0, x_286); -x_289 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_289, 0, x_287); -lean_ctor_set(x_289, 1, x_288); -x_290 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_290, 0, x_289); -return x_290; +x_284 = l_String_trim(x_282); +lean_dec(x_282); +lean_inc(x_284); +x_285 = l_Lean_Parser_nonReservedSymbolInfo(x_284, x_283); +x_286 = lean_alloc_closure((void*)(l_Lean_Parser_nonReservedSymbolFn), 3, 1); +lean_closure_set(x_286, 0, x_284); +x_287 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_287, 0, x_285); +lean_ctor_set(x_287, 1, x_286); +x_288 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_288, 0, x_287); +return x_288; } case 13: { -lean_object* x_291; +lean_object* x_289; lean_dec(x_1); -x_291 = l_Lean_Parser_compileParserDescr___main___closed__1; -return x_291; +x_289 = l_Lean_Parser_compileParserDescr___main___closed__1; +return x_289; } case 14: { -lean_object* x_292; +lean_object* x_290; lean_dec(x_1); -x_292 = l_Lean_Parser_compileParserDescr___main___closed__2; -return x_292; +x_290 = l_Lean_Parser_compileParserDescr___main___closed__2; +return x_290; } case 15: { -lean_object* x_293; +lean_object* x_291; lean_dec(x_1); -x_293 = l_Lean_Parser_compileParserDescr___main___closed__3; -return x_293; +x_291 = l_Lean_Parser_compileParserDescr___main___closed__3; +return x_291; } case 16: { -lean_object* x_294; +lean_object* x_292; lean_dec(x_1); -x_294 = l_Lean_Parser_compileParserDescr___main___closed__4; -return x_294; +x_292 = l_Lean_Parser_compileParserDescr___main___closed__4; +return x_292; } case 17: { -lean_object* x_295; +lean_object* x_293; lean_dec(x_1); -x_295 = l_Lean_Parser_compileParserDescr___main___closed__5; -return x_295; +x_293 = l_Lean_Parser_compileParserDescr___main___closed__5; +return x_293; +} +case 18: +{ +lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_1); +x_294 = lean_ctor_get(x_2, 0); +lean_inc(x_294); +lean_dec(x_2); +x_295 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_296 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLtFn___boxed), 4, 2); +lean_closure_set(x_296, 0, x_294); +lean_closure_set(x_296, 1, x_295); +x_297 = l_Lean_Parser_epsilonInfo; +x_298 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_298, 0, x_297); +lean_ctor_set(x_298, 1, x_296); +x_299 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_299, 0, x_298); +return x_299; } default: { -lean_object* x_296; lean_object* x_297; lean_object* x_298; -x_296 = lean_ctor_get(x_2, 0); -lean_inc(x_296); -x_297 = lean_ctor_get(x_2, 1); -lean_inc(x_297); +lean_object* x_300; lean_object* x_301; lean_object* x_302; +x_300 = lean_ctor_get(x_2, 0); +lean_inc(x_300); +x_301 = lean_ctor_get(x_2, 1); +lean_inc(x_301); lean_dec(x_2); -x_298 = l_PersistentHashMap_find_x3f___at_Lean_Parser_addLeadingParser___spec__1(x_1, x_296); -if (lean_obj_tag(x_298) == 0) +x_302 = l_PersistentHashMap_find_x3f___at_Lean_Parser_addLeadingParser___spec__1(x_1, x_300); +if (lean_obj_tag(x_302) == 0) { -lean_object* x_299; -lean_dec(x_297); -x_299 = l_Lean_Parser_throwUnknownParserCategory___rarg(x_296); -return x_299; +lean_object* x_303; +lean_dec(x_301); +x_303 = l_Lean_Parser_throwUnknownParserCategory___rarg(x_300); +return x_303; } else { -lean_object* x_300; lean_object* x_301; -lean_dec(x_298); -x_300 = l_Lean_Parser_categoryParser(x_296, x_297); -x_301 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_301, 0, x_300); -return x_301; +lean_object* x_304; lean_object* x_305; +lean_dec(x_302); +x_304 = l_Lean_Parser_categoryParser(x_300, x_301); +x_305 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_305, 0, x_304); +return x_305; } } } @@ -33042,7 +31478,7 @@ lean_dec(x_1); return x_4; } } -lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__1(lean_object* x_1, lean_object* x_2) { +lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__1(lean_object* x_1, lean_object* x_2) { _start: { if (lean_obj_tag(x_1) == 0) @@ -33069,7 +31505,7 @@ return x_7; } } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___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) { +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___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_7; uint8_t x_8; @@ -33108,8 +31544,8 @@ x_15 = lean_ctor_get(x_5, 0); x_16 = lean_ctor_get(x_5, 1); x_17 = lean_ctor_get(x_5, 2); x_18 = lean_ctor_get(x_5, 3); -x_19 = l___private_Lean_Parser_Parser_18__addTokenConfig(x_15, x_13); -x_20 = l_IO_ofExcept___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__1(x_19, x_6); +x_19 = l___private_Lean_Parser_Parser_19__addTokenConfig(x_15, x_13); +x_20 = l_IO_ofExcept___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__1(x_19, x_6); lean_dec(x_19); if (lean_obj_tag(x_20) == 0) { @@ -33165,8 +31601,8 @@ lean_inc(x_30); lean_inc(x_29); lean_inc(x_28); lean_dec(x_5); -x_32 = l___private_Lean_Parser_Parser_18__addTokenConfig(x_28, x_13); -x_33 = l_IO_ofExcept___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__1(x_32, x_6); +x_32 = l___private_Lean_Parser_Parser_19__addTokenConfig(x_28, x_13); +x_33 = l_IO_ofExcept___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__1(x_32, x_6); lean_dec(x_32); if (lean_obj_tag(x_33) == 0) { @@ -33277,8 +31713,8 @@ x_63 = l_Lean_Parser_PrattParsingTables_inhabited___closed__1; x_64 = lean_alloc_ctor(0, 1, 1); lean_ctor_set(x_64, 0, x_63); lean_ctor_set_uint8(x_64, sizeof(void*)*1, x_57); -x_65 = l___private_Lean_Parser_Parser_14__addParserCategoryCore(x_61, x_56, x_64); -x_66 = l_IO_ofExcept___at___private_Lean_Parser_Parser_15__addBuiltinParserCategory___spec__1(x_65, x_6); +x_65 = l___private_Lean_Parser_Parser_15__addParserCategoryCore(x_61, x_56, x_64); +x_66 = l_IO_ofExcept___at___private_Lean_Parser_Parser_16__addBuiltinParserCategory___spec__1(x_65, x_6); lean_dec(x_65); if (lean_obj_tag(x_66) == 0) { @@ -33338,8 +31774,8 @@ x_78 = l_Lean_Parser_PrattParsingTables_inhabited___closed__1; x_79 = lean_alloc_ctor(0, 1, 1); lean_ctor_set(x_79, 0, x_78); lean_ctor_set_uint8(x_79, sizeof(void*)*1, x_57); -x_80 = l___private_Lean_Parser_Parser_14__addParserCategoryCore(x_76, x_56, x_79); -x_81 = l_IO_ofExcept___at___private_Lean_Parser_Parser_15__addBuiltinParserCategory___spec__1(x_80, x_6); +x_80 = l___private_Lean_Parser_Parser_15__addParserCategoryCore(x_76, x_56, x_79); +x_81 = l_IO_ofExcept___at___private_Lean_Parser_Parser_16__addBuiltinParserCategory___spec__1(x_80, x_6); lean_dec(x_80); if (lean_obj_tag(x_81) == 0) { @@ -33570,7 +32006,7 @@ goto _start; } } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__3(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_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__3(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; uint8_t x_8; @@ -33596,7 +32032,7 @@ x_12 = lean_nat_add(x_4, x_11); lean_dec(x_4); x_13 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_14 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__2(x_1, x_10, x_10, x_13, x_5, x_6); +x_14 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__2(x_1, x_10, x_10, x_13, x_5, x_6); lean_dec(x_10); if (lean_obj_tag(x_14) == 0) { @@ -33638,11 +32074,11 @@ return x_21; } } } -lean_object* l___private_Lean_Parser_Parser_22__ParserExtension_addImported(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Lean_Parser_Parser_23__ParserExtension_addImported(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l___private_Lean_Parser_Parser_16__ParserExtension_mkInitial(x_3); +x_4 = l___private_Lean_Parser_Parser_17__ParserExtension_mkInitial(x_3); if (lean_obj_tag(x_4) == 0) { lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; @@ -33652,7 +32088,7 @@ x_6 = lean_ctor_get(x_4, 1); lean_inc(x_6); lean_dec(x_4); x_7 = lean_unsigned_to_nat(0u); -x_8 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__3(x_1, x_2, x_2, x_7, x_5, x_6); +x_8 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__3(x_1, x_2, x_2, x_7, x_5, x_6); return x_8; } else @@ -33680,40 +32116,40 @@ return x_12; } } } -lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_IO_ofExcept___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__1___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = l_IO_ofExcept___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__1(x_1, x_2); +x_3 = l_IO_ofExcept___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__1(x_1, x_2); lean_dec(x_1); return x_3; } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___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* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___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: { lean_object* x_7; -x_7 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__2(x_1, x_2, x_3, x_4, x_5, x_6); +x_7 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__2(x_1, x_2, x_3, x_4, x_5, x_6); lean_dec(x_3); lean_dec(x_2); return x_7; } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___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* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___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: { lean_object* x_7; -x_7 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_22__ParserExtension_addImported___spec__3(x_1, x_2, x_3, x_4, x_5, x_6); +x_7 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_23__ParserExtension_addImported___spec__3(x_1, x_2, x_3, x_4, x_5, x_6); lean_dec(x_3); lean_dec(x_2); return x_7; } } -lean_object* l___private_Lean_Parser_Parser_22__ParserExtension_addImported___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Lean_Parser_Parser_23__ParserExtension_addImported___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l___private_Lean_Parser_Parser_22__ParserExtension_addImported(x_1, x_2, x_3); +x_4 = l___private_Lean_Parser_Parser_23__ParserExtension_addImported(x_1, x_2, x_3); lean_dec(x_2); return x_4; } @@ -34524,7 +32960,7 @@ lean_object* _init_l_Lean_Parser_mkParserExtension___closed__3() { _start: { lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_16__ParserExtension_mkInitial), 1, 0); +x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_17__ParserExtension_mkInitial), 1, 0); return x_1; } } @@ -34532,7 +32968,7 @@ lean_object* _init_l_Lean_Parser_mkParserExtension___closed__4() { _start: { lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_22__ParserExtension_addImported___boxed), 3, 0); +x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_23__ParserExtension_addImported___boxed), 3, 0); return x_1; } } @@ -34540,7 +32976,7 @@ lean_object* _init_l_Lean_Parser_mkParserExtension___closed__5() { _start: { lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_21__ParserExtension_addEntry), 2, 0); +x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_22__ParserExtension_addEntry), 2, 0); return x_1; } } @@ -34766,7 +33202,7 @@ x_4 = l_Lean_PersistentEnvExtension_getState___rarg(x_3, x_1); x_5 = lean_ctor_get(x_4, 2); lean_inc(x_5); lean_dec(x_4); -x_6 = l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_14__addParserCategoryCore___spec__1(x_5, x_2); +x_6 = l_PersistentHashMap_contains___at___private_Lean_Parser_Parser_15__addParserCategoryCore___spec__1(x_5, x_2); return x_6; } } @@ -34802,7 +33238,7 @@ else { lean_object* x_9; lean_dec(x_1); -x_9 = l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg(x_2); +x_9 = l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg(x_2); return x_9; } } @@ -34856,7 +33292,7 @@ x_4 = lean_box(x_3); return x_4; } } -lean_object* l___private_Lean_Parser_Parser_23__catNameToString(lean_object* x_1) { +lean_object* l___private_Lean_Parser_Parser_24__catNameToString(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 1) @@ -34894,7 +33330,7 @@ lean_object* l_Lean_Parser_mkCategoryAntiquotParser(lean_object* x_1, lean_objec _start: { lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; -x_4 = l___private_Lean_Parser_Parser_23__catNameToString(x_1); +x_4 = l___private_Lean_Parser_Parser_24__catNameToString(x_1); x_5 = lean_box(0); x_6 = 1; x_7 = l_Lean_Parser_mkAntiquot(x_4, x_5, x_6); @@ -34935,7 +33371,7 @@ return x_15; } else { -lean_object* x_16; lean_object* x_17; uint8_t 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; uint8_t x_25; +lean_object* x_16; lean_object* x_17; uint8_t x_18; uint8_t x_19; x_16 = lean_ctor_get(x_8, 0); lean_inc(x_16); lean_dec(x_8); @@ -34943,143 +33379,112 @@ x_17 = lean_ctor_get(x_16, 0); lean_inc(x_17); x_18 = lean_ctor_get_uint8(x_16, sizeof(void*)*1); lean_dec(x_16); -x_19 = lean_ctor_get(x_3, 0); -lean_inc(x_19); -x_20 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_19); -lean_dec(x_19); +lean_inc(x_3); lean_inc(x_2); -x_21 = l_Lean_Parser_currLbp(x_20, x_2, x_3); -lean_dec(x_20); -x_22 = lean_ctor_get(x_21, 0); -lean_inc(x_22); -x_23 = lean_ctor_get(x_21, 1); -lean_inc(x_23); +x_19 = l_Lean_Parser_tryAnti(x_2, x_3); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; +lean_inc(x_2); +lean_inc(x_17); +x_20 = l_Lean_Parser_leadingParserAux(x_1, x_17, x_18, x_2, x_3); +x_21 = lean_ctor_get(x_20, 3); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; +x_22 = l_Lean_Parser_trailingLoop___main(x_17, x_2, x_20); +return x_22; +} +else +{ lean_dec(x_21); -x_24 = lean_ctor_get(x_2, 1); -lean_inc(x_24); -x_25 = lean_nat_dec_lt(x_23, x_24); -lean_dec(x_24); +lean_dec(x_17); +lean_dec(x_2); +return x_20; +} +} +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_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_23 = lean_ctor_get(x_3, 0); +lean_inc(x_23); +x_24 = lean_array_get_size(x_23); lean_dec(x_23); -if (x_25 == 0) -{ -uint8_t x_26; -lean_inc(x_22); -lean_inc(x_2); -x_26 = l_Lean_Parser_tryAnti(x_2, x_22); -if (x_26 == 0) -{ -lean_object* x_27; lean_object* x_28; -lean_inc(x_2); -lean_inc(x_17); -x_27 = l_Lean_Parser_leadingParserAux(x_1, x_17, x_18, x_2, 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; -x_29 = l_Lean_Parser_trailingLoop___main(x_17, x_2, x_27); -return x_29; -} -else -{ -lean_dec(x_28); -lean_dec(x_17); -lean_dec(x_2); -return x_27; -} -} -else -{ -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; -x_30 = lean_ctor_get(x_22, 0); -lean_inc(x_30); -x_31 = lean_array_get_size(x_30); -lean_dec(x_30); -x_32 = lean_ctor_get(x_22, 1); -lean_inc(x_32); +x_25 = lean_ctor_get(x_3, 1); +lean_inc(x_25); lean_inc(x_1); -x_33 = l___private_Lean_Parser_Parser_23__catNameToString(x_1); -x_34 = lean_box(0); -x_35 = 1; -x_36 = l_Lean_Parser_mkAntiquot(x_33, x_34, x_35); -lean_dec(x_33); -x_37 = lean_ctor_get(x_36, 1); -lean_inc(x_37); -lean_dec(x_36); +x_26 = l___private_Lean_Parser_Parser_24__catNameToString(x_1); +x_27 = lean_box(0); +x_28 = 1; +x_29 = l_Lean_Parser_mkAntiquot(x_26, x_27, x_28); +lean_dec(x_26); +x_30 = lean_ctor_get(x_29, 1); +lean_inc(x_30); +lean_dec(x_29); lean_inc(x_2); -x_38 = lean_apply_2(x_37, x_2, x_22); -x_39 = lean_ctor_get(x_38, 3); -lean_inc(x_39); -if (lean_obj_tag(x_39) == 0) +x_31 = lean_apply_2(x_30, x_2, x_3); +x_32 = lean_ctor_get(x_31, 3); +lean_inc(x_32); +if (lean_obj_tag(x_32) == 0) { -lean_object* x_40; -lean_dec(x_32); -lean_dec(x_31); +lean_object* x_33; +lean_dec(x_25); +lean_dec(x_24); lean_dec(x_1); -x_40 = l_Lean_Parser_trailingLoop___main(x_17, x_2, x_38); -return x_40; +x_33 = l_Lean_Parser_trailingLoop___main(x_17, x_2, x_31); +return x_33; } else { -lean_object* x_41; lean_object* x_42; uint8_t x_43; -x_41 = lean_ctor_get(x_39, 0); -lean_inc(x_41); -lean_dec(x_39); -x_42 = lean_ctor_get(x_38, 1); -lean_inc(x_42); -x_43 = lean_nat_dec_eq(x_42, x_32); -lean_dec(x_42); -if (x_43 == 0) -{ -lean_dec(x_41); +lean_object* x_34; lean_object* x_35; uint8_t x_36; +x_34 = lean_ctor_get(x_32, 0); +lean_inc(x_34); lean_dec(x_32); -lean_dec(x_31); +x_35 = lean_ctor_get(x_31, 1); +lean_inc(x_35); +x_36 = lean_nat_dec_eq(x_35, x_25); +lean_dec(x_35); +if (x_36 == 0) +{ +lean_dec(x_34); +lean_dec(x_25); +lean_dec(x_24); lean_dec(x_17); lean_dec(x_2); lean_dec(x_1); -return x_38; +return x_31; } else { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; -lean_inc(x_32); -x_44 = l_Lean_Parser_ParserState_restore(x_38, x_31, x_32); -lean_dec(x_31); +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +lean_inc(x_25); +x_37 = l_Lean_Parser_ParserState_restore(x_31, x_24, x_25); +lean_dec(x_24); lean_inc(x_2); lean_inc(x_17); -x_45 = l_Lean_Parser_leadingParserAux(x_1, x_17, x_18, x_2, x_44); -x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_41, x_32); -lean_dec(x_32); -x_47 = lean_ctor_get(x_46, 3); -lean_inc(x_47); -if (lean_obj_tag(x_47) == 0) +x_38 = l_Lean_Parser_leadingParserAux(x_1, x_17, x_18, x_2, x_37); +x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_34, x_25); +lean_dec(x_25); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { -lean_object* x_48; -x_48 = l_Lean_Parser_trailingLoop___main(x_17, x_2, x_46); -return x_48; +lean_object* x_41; +x_41 = l_Lean_Parser_trailingLoop___main(x_17, x_2, x_39); +return x_41; } else { -lean_dec(x_47); +lean_dec(x_40); lean_dec(x_17); lean_dec(x_2); -return x_46; +return x_39; } } } } } -else -{ -lean_object* x_49; lean_object* x_50; -lean_dec(x_17); -lean_dec(x_2); -lean_dec(x_1); -x_49 = l_Lean_Parser_prattParser___closed__1; -x_50 = l_Lean_Parser_ParserState_mkUnexpectedError(x_22, x_49); -return x_50; -} -} } } lean_object* _init_l_Lean_Parser_setCategoryParserFnRef___closed__1() { @@ -35110,7 +33515,7 @@ x_5 = lean_ctor_get(x_4, 0); lean_inc(x_5); lean_dec(x_4); lean_inc(x_2); -x_6 = l___private_Lean_Parser_Parser_18__addTokenConfig(x_5, x_2); +x_6 = l___private_Lean_Parser_Parser_19__addTokenConfig(x_5, x_2); if (lean_obj_tag(x_6) == 0) { uint8_t x_7; @@ -35570,42 +33975,6 @@ lean_dec(x_1); return x_2; } } -lean_object* l_Lean_Parser_getTokenLbp_x3f(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; lean_object* x_4; lean_object* x_5; -x_3 = l_Lean_Parser_getTokenTable(x_1); -x_4 = lean_unsigned_to_nat(0u); -x_5 = l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(x_2, x_3, x_4); -if (lean_obj_tag(x_5) == 0) -{ -lean_object* x_6; -x_6 = lean_box(0); -return x_6; -} -else -{ -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_ctor_get(x_7, 1); -lean_inc(x_8); -lean_dec(x_7); -return x_8; -} -} -} -lean_object* l_Lean_Parser_getTokenLbp_x3f___boxed(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; -x_3 = l_Lean_Parser_getTokenLbp_x3f(x_1, x_2); -lean_dec(x_2); -lean_dec(x_1); -return x_3; -} -} lean_object* l_Lean_Parser_mkInputContext(lean_object* x_1, lean_object* x_2) { _start: { @@ -35945,7 +34314,7 @@ x_6 = l_Lean_Parser_declareBuiltinParser(x_1, x_5, x_2, x_3, x_4); return x_6; } } -lean_object* _init_l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__1() { +lean_object* _init_l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__1() { _start: { lean_object* x_1; @@ -35953,7 +34322,7 @@ x_1 = lean_mk_string("' (`Parser` or `TrailingParser` expected"); return x_1; } } -lean_object* _init_l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__2() { +lean_object* _init_l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__2() { _start: { lean_object* x_1; lean_object* x_2; @@ -35963,7 +34332,7 @@ lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, uint8_t x_6, lean_object* x_7) { +lean_object* l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, uint8_t x_6, lean_object* x_7) { _start: { uint8_t x_8; @@ -36003,7 +34372,7 @@ lean_object* x_28; lean_object* x_29; lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -x_28 = l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__2; +x_28 = l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__2; x_29 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_29, 0, x_28); lean_ctor_set(x_29, 1, x_7); @@ -36186,7 +34555,7 @@ x_20 = l_Lean_Name_toStringWithSep___main(x_19, x_4); x_21 = l_Lean_Parser_mkParserOfConstantUnsafe___closed__1; x_22 = lean_string_append(x_21, x_20); lean_dec(x_20); -x_23 = l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__1; +x_23 = l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__1; x_24 = lean_string_append(x_22, x_23); x_25 = lean_alloc_ctor(18, 1, 0); lean_ctor_set(x_25, 0, x_24); @@ -36219,13 +34588,13 @@ return x_63; } } } -lean_object* l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___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___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___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_6); lean_dec(x_6); -x_9 = l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add(x_1, x_2, x_3, x_4, x_5, x_8, x_7); +x_9 = l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add(x_1, x_2, x_3, x_4, x_5, x_8, x_7); lean_dec(x_5); return x_9; } @@ -36244,7 +34613,7 @@ _start: lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_inc(x_2); lean_inc(x_1); -x_5 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___boxed), 7, 2); +x_5 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___boxed), 7, 2); lean_closure_set(x_5, 0, x_1); lean_closure_set(x_5, 1, x_2); x_6 = l_Lean_Parser_registerBuiltinParserAttribute___closed__1; @@ -36254,7 +34623,7 @@ lean_ctor_set(x_8, 0, x_1); lean_ctor_set(x_8, 1, x_6); lean_ctor_set(x_8, 2, x_5); lean_ctor_set_uint8(x_8, sizeof(void*)*3, x_7); -x_9 = l___private_Lean_Parser_Parser_15__addBuiltinParserCategory(x_2, x_3, x_4); +x_9 = l___private_Lean_Parser_Parser_16__addBuiltinParserCategory(x_2, x_3, x_4); if (lean_obj_tag(x_9) == 0) { lean_object* x_10; lean_object* x_11; @@ -36299,7 +34668,7 @@ x_6 = l_Lean_Parser_registerBuiltinParserAttribute(x_1, x_2, x_5, x_4); return x_6; } } -lean_object* _init_l_List_foldlM___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__1___closed__1() { +lean_object* _init_l_List_foldlM___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__1___closed__1() { _start: { lean_object* x_1; @@ -36307,7 +34676,7 @@ x_1 = lean_mk_string("invalid parser '"); return x_1; } } -lean_object* l_List_foldlM___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_List_foldlM___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { if (lean_obj_tag(x_3) == 0) @@ -36337,7 +34706,7 @@ lean_inc(x_9); lean_dec(x_8); x_10 = l_Lean_Name_toString___closed__1; x_11 = l_Lean_Name_toStringWithSep___main(x_10, x_1); -x_12 = l_List_foldlM___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__1___closed__1; +x_12 = l_List_foldlM___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__1___closed__1; x_13 = lean_string_append(x_12, x_11); lean_dec(x_11); x_14 = l_Lean_registerTagAttribute___lambda__4___closed__4; @@ -36364,7 +34733,7 @@ goto _start; } } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { lean_object* x_5; uint8_t x_6; @@ -36401,7 +34770,7 @@ lean_object* x_13; lean_object* x_14; x_13 = lean_ctor_get(x_7, 0); lean_inc(x_13); lean_dec(x_7); -x_14 = l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__3(x_13, x_4); +x_14 = l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__3(x_13, x_4); lean_dec(x_13); x_3 = x_9; x_4 = x_14; @@ -36416,7 +34785,7 @@ goto _start; } } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { lean_object* x_5; uint8_t x_6; @@ -36442,7 +34811,7 @@ goto _start; } } } -lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__3(lean_object* x_1, lean_object* x_2) { +lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__3(lean_object* x_1, lean_object* x_2) { _start: { if (lean_obj_tag(x_1) == 0) @@ -36450,7 +34819,7 @@ if (lean_obj_tag(x_1) == 0) lean_object* x_3; lean_object* x_4; lean_object* x_5; x_3 = lean_ctor_get(x_1, 0); x_4 = lean_unsigned_to_nat(0u); -x_5 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__4(x_3, x_3, x_4, x_2); +x_5 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__4(x_3, x_3, x_4, x_2); return x_5; } else @@ -36458,21 +34827,21 @@ else lean_object* x_6; lean_object* x_7; lean_object* x_8; x_6 = lean_ctor_get(x_1, 0); x_7 = lean_unsigned_to_nat(0u); -x_8 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__5(x_6, x_6, x_7, x_2); +x_8 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__5(x_6, x_6, x_7, x_2); return x_8; } } } -lean_object* l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__2(lean_object* x_1, lean_object* x_2) { +lean_object* l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__2(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; lean_object* x_4; x_3 = lean_ctor_get(x_1, 0); -x_4 = l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__3(x_3, x_2); +x_4 = l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__3(x_3, x_2); return x_4; } } -lean_object* l___private_Lean_Parser_Parser_25__ParserAttribute_add(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, uint8_t x_6, lean_object* x_7) { +lean_object* l___private_Lean_Parser_Parser_26__ParserAttribute_add(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, uint8_t x_6, lean_object* x_7) { _start: { uint8_t x_8; @@ -36525,7 +34894,7 @@ lean_inc(x_20); x_21 = lean_box(0); x_22 = lean_apply_1(x_20, x_21); lean_inc(x_4); -x_23 = l_List_foldlM___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__1(x_4, x_3, x_22, x_7); +x_23 = l_List_foldlM___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__1(x_4, x_3, x_22, x_7); if (lean_obj_tag(x_23) == 0) { uint8_t x_24; @@ -36539,7 +34908,7 @@ lean_inc(x_26); lean_dec(x_19); x_27 = l_PersistentHashMap_empty___at_Lean_Parser_mkBuiltinSyntaxNodeKindSetRef___spec__1; x_28 = lean_apply_1(x_26, x_27); -x_29 = l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__2(x_28, x_25); +x_29 = l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__2(x_28, x_25); lean_dec(x_28); x_30 = lean_unbox(x_17); lean_inc(x_18); @@ -36591,7 +34960,7 @@ lean_inc(x_39); lean_dec(x_19); x_40 = l_PersistentHashMap_empty___at_Lean_Parser_mkBuiltinSyntaxNodeKindSetRef___spec__1; x_41 = lean_apply_1(x_39, x_40); -x_42 = l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__2(x_41, x_37); +x_42 = l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__2(x_41, x_37); lean_dec(x_41); x_43 = lean_unbox(x_17); lean_inc(x_18); @@ -36686,51 +35055,51 @@ return x_63; } } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__4___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_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__4(x_1, x_2, x_3, x_4); +x_5 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__4(x_1, x_2, x_3, x_4); lean_dec(x_2); lean_dec(x_1); return x_5; } } -lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__5___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_Array_iterateMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__5(x_1, x_2, x_3, x_4); +x_5 = l_Array_iterateMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__5(x_1, x_2, x_3, x_4); lean_dec(x_2); lean_dec(x_1); return x_5; } } -lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__3___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__3___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__3(x_1, x_2); +x_3 = l_PersistentHashMap_foldlMAux___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__3(x_1, x_2); lean_dec(x_1); return x_3; } } -lean_object* l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__2___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__2(x_1, x_2); +x_3 = l_PersistentHashMap_foldlM___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__2(x_1, x_2); lean_dec(x_1); return x_3; } } -lean_object* l___private_Lean_Parser_Parser_25__ParserAttribute_add___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___private_Lean_Parser_Parser_26__ParserAttribute_add___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_6); lean_dec(x_6); -x_9 = l___private_Lean_Parser_Parser_25__ParserAttribute_add(x_1, x_2, x_3, x_4, x_5, x_8, x_7); +x_9 = l___private_Lean_Parser_Parser_26__ParserAttribute_add(x_1, x_2, x_3, x_4, x_5, x_8, x_7); lean_dec(x_5); return x_9; } @@ -36739,7 +35108,7 @@ lean_object* l_Lean_Parser_mkParserAttributeImpl___elambda__1(lean_object* x_1, _start: { lean_object* x_8; -x_8 = l___private_Lean_Parser_Parser_25__ParserAttribute_add(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +x_8 = l___private_Lean_Parser_Parser_26__ParserAttribute_add(x_1, x_2, x_3, x_4, x_5, x_6, x_7); return x_8; } } @@ -36789,7 +35158,7 @@ x_5 = l_Lean_registerBuiltinAttribute(x_4, x_3); return x_5; } } -lean_object* _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__1() { +lean_object* _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__1() { _start: { lean_object* x_1; @@ -36797,23 +35166,23 @@ x_1 = lean_mk_string("invalid parser attribute implementation builder arguments" return x_1; } } -lean_object* _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2() { +lean_object* _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__1; +x_1 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__1; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1(lean_object* x_1) { +lean_object* l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) { lean_object* x_2; -x_2 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2; +x_2 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2; return x_2; } else @@ -36831,7 +35200,7 @@ if (lean_obj_tag(x_4) == 0) { lean_object* x_5; lean_dec(x_3); -x_5 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2; +x_5 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2; return x_5; } else @@ -36865,7 +35234,7 @@ lean_object* x_12; lean_dec(x_7); lean_dec(x_6); lean_dec(x_3); -x_12 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2; +x_12 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2; return x_12; } } @@ -36875,7 +35244,7 @@ lean_object* x_13; lean_dec(x_6); lean_dec(x_4); lean_dec(x_3); -x_13 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2; +x_13 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2; return x_13; } } @@ -36885,13 +35254,13 @@ else lean_object* x_14; lean_dec(x_3); lean_dec(x_1); -x_14 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2; +x_14 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2; return x_14; } } } } -lean_object* _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__1() { +lean_object* _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__1() { _start: { lean_object* x_1; @@ -36899,30 +35268,30 @@ x_1 = lean_mk_string("parserAttr"); return x_1; } } -lean_object* _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__2() { +lean_object* _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__1; +x_2 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__3() { +lean_object* _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__3() { _start: { lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1), 1, 0); +x_1 = lean_alloc_closure((void*)(l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1), 1, 0); return x_1; } } -lean_object* l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder(lean_object* x_1) { +lean_object* l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder(lean_object* x_1) { _start: { lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_2 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__2; -x_3 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__3; +x_2 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__2; +x_3 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__3; x_4 = l_Lean_registerAttributeImplBuilder(x_2, x_3, x_1); return x_4; } @@ -36954,7 +35323,7 @@ lean_ctor_set(x_13, 1, x_12); x_14 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_14, 0, x_10); lean_ctor_set(x_14, 1, x_13); -x_15 = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__2; +x_15 = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__2; x_16 = l_Lean_registerAttributeOfBuilder(x_8, x_15, x_14, x_9); return x_16; } @@ -38087,16 +36456,6 @@ if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); l_Lean_Parser_appPrec = _init_l_Lean_Parser_appPrec(); lean_mark_persistent(l_Lean_Parser_appPrec); -l_Lean_Parser_TokenConfig_HasBeq___closed__1 = _init_l_Lean_Parser_TokenConfig_HasBeq___closed__1(); -lean_mark_persistent(l_Lean_Parser_TokenConfig_HasBeq___closed__1); -l_Lean_Parser_TokenConfig_HasBeq = _init_l_Lean_Parser_TokenConfig_HasBeq(); -lean_mark_persistent(l_Lean_Parser_TokenConfig_HasBeq); -l_Lean_Parser_TokenConfig_toStr___closed__1 = _init_l_Lean_Parser_TokenConfig_toStr___closed__1(); -lean_mark_persistent(l_Lean_Parser_TokenConfig_toStr___closed__1); -l_Lean_Parser_TokenConfig_HasToString___closed__1 = _init_l_Lean_Parser_TokenConfig_HasToString___closed__1(); -lean_mark_persistent(l_Lean_Parser_TokenConfig_HasToString___closed__1); -l_Lean_Parser_TokenConfig_HasToString = _init_l_Lean_Parser_TokenConfig_HasToString(); -lean_mark_persistent(l_Lean_Parser_TokenConfig_HasToString); l_Lean_Parser_InputContext_inhabited___closed__1 = _init_l_Lean_Parser_InputContext_inhabited___closed__1(); lean_mark_persistent(l_Lean_Parser_InputContext_inhabited___closed__1); l_Lean_Parser_InputContext_inhabited = _init_l_Lean_Parser_InputContext_inhabited(); @@ -38191,8 +36550,6 @@ l_Lean_Parser_nonReservedSymbolInfo___closed__2 = _init_l_Lean_Parser_nonReserve lean_mark_persistent(l_Lean_Parser_nonReservedSymbolInfo___closed__2); l_Lean_Parser_nonReservedSymbolInfo___closed__3 = _init_l_Lean_Parser_nonReservedSymbolInfo___closed__3(); lean_mark_persistent(l_Lean_Parser_nonReservedSymbolInfo___closed__3); -l_Lean_Parser_nonReservedSymbolInfo___closed__4 = _init_l_Lean_Parser_nonReservedSymbolInfo___closed__4(); -lean_mark_persistent(l_Lean_Parser_nonReservedSymbolInfo___closed__4); l_Lean_Parser_symbolNoWsInfo___closed__1 = _init_l_Lean_Parser_symbolNoWsInfo___closed__1(); lean_mark_persistent(l_Lean_Parser_symbolNoWsInfo___closed__1); l_Lean_Parser_symbolNoWsFn___closed__1 = _init_l_Lean_Parser_symbolNoWsFn___closed__1(); @@ -38201,8 +36558,10 @@ l_Lean_Parser_unicodeSymbolInfo___closed__1 = _init_l_Lean_Parser_unicodeSymbolI lean_mark_persistent(l_Lean_Parser_unicodeSymbolInfo___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_leadingNodePrec___closed__1 = _init_l_Lean_Parser_leadingNodePrec___closed__1(); -lean_mark_persistent(l_Lean_Parser_leadingNodePrec___closed__1); +l___private_Lean_Parser_Parser_10__precErrorMsg___closed__1 = _init_l___private_Lean_Parser_Parser_10__precErrorMsg___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_10__precErrorMsg___closed__1); +l___private_Lean_Parser_Parser_10__precErrorMsg = _init_l___private_Lean_Parser_Parser_10__precErrorMsg(); +lean_mark_persistent(l___private_Lean_Parser_Parser_10__precErrorMsg); l_Lean_Parser_mkAtomicInfo___closed__1 = _init_l_Lean_Parser_mkAtomicInfo___closed__1(); lean_mark_persistent(l_Lean_Parser_mkAtomicInfo___closed__1); l_Lean_Parser_mkAtomicInfo___closed__2 = _init_l_Lean_Parser_mkAtomicInfo___closed__2(); @@ -38299,8 +36658,6 @@ l_Lean_Parser_ParserCategory_inhabited___closed__1 = _init_l_Lean_Parser_ParserC lean_mark_persistent(l_Lean_Parser_ParserCategory_inhabited___closed__1); l_Lean_Parser_ParserCategory_inhabited = _init_l_Lean_Parser_ParserCategory_inhabited(); lean_mark_persistent(l_Lean_Parser_ParserCategory_inhabited); -l_Lean_Parser_currLbp___closed__1 = _init_l_Lean_Parser_currLbp___closed__1(); -lean_mark_persistent(l_Lean_Parser_currLbp___closed__1); l_Lean_Parser_mkCategoryParserFnRef___closed__1 = _init_l_Lean_Parser_mkCategoryParserFnRef___closed__1(); lean_mark_persistent(l_Lean_Parser_mkCategoryParserFnRef___closed__1); res = l_Lean_Parser_mkCategoryParserFnRef(lean_io_mk_world()); @@ -38335,24 +36692,24 @@ l_Lean_Parser_dollarSymbol___elambda__1___closed__3 = _init_l_Lean_Parser_dollar 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___elambda__1___closed__5 = _init_l_Lean_Parser_dollarSymbol___elambda__1___closed__5(); +lean_mark_persistent(l_Lean_Parser_dollarSymbol___elambda__1___closed__5); 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_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_Lean_Parser_Parser_10__noImmediateColon___elambda__1___closed__1 = _init_l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1___closed__1(); -lean_mark_persistent(l___private_Lean_Parser_Parser_10__noImmediateColon___elambda__1___closed__1); -l___private_Lean_Parser_Parser_10__noImmediateColon___closed__1 = _init_l___private_Lean_Parser_Parser_10__noImmediateColon___closed__1(); -lean_mark_persistent(l___private_Lean_Parser_Parser_10__noImmediateColon___closed__1); -l___private_Lean_Parser_Parser_10__noImmediateColon___closed__2 = _init_l___private_Lean_Parser_Parser_10__noImmediateColon___closed__2(); -lean_mark_persistent(l___private_Lean_Parser_Parser_10__noImmediateColon___closed__2); -l___private_Lean_Parser_Parser_10__noImmediateColon = _init_l___private_Lean_Parser_Parser_10__noImmediateColon(); -lean_mark_persistent(l___private_Lean_Parser_Parser_10__noImmediateColon); +l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1___closed__1 = _init_l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_11__noImmediateColon___elambda__1___closed__1); +l___private_Lean_Parser_Parser_11__noImmediateColon___closed__1 = _init_l___private_Lean_Parser_Parser_11__noImmediateColon___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_11__noImmediateColon___closed__1); +l___private_Lean_Parser_Parser_11__noImmediateColon___closed__2 = _init_l___private_Lean_Parser_Parser_11__noImmediateColon___closed__2(); +lean_mark_persistent(l___private_Lean_Parser_Parser_11__noImmediateColon___closed__2); +l___private_Lean_Parser_Parser_11__noImmediateColon = _init_l___private_Lean_Parser_Parser_11__noImmediateColon(); +lean_mark_persistent(l___private_Lean_Parser_Parser_11__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(); @@ -38395,8 +36752,6 @@ l_Lean_Parser_antiquotNestedExpr___closed__7 = _init_l_Lean_Parser_antiquotNeste lean_mark_persistent(l_Lean_Parser_antiquotNestedExpr___closed__7); l_Lean_Parser_antiquotNestedExpr___closed__8 = _init_l_Lean_Parser_antiquotNestedExpr___closed__8(); lean_mark_persistent(l_Lean_Parser_antiquotNestedExpr___closed__8); -l_Lean_Parser_antiquotNestedExpr___closed__9 = _init_l_Lean_Parser_antiquotNestedExpr___closed__9(); -lean_mark_persistent(l_Lean_Parser_antiquotNestedExpr___closed__9); l_Lean_Parser_antiquotNestedExpr = _init_l_Lean_Parser_antiquotNestedExpr(); lean_mark_persistent(l_Lean_Parser_antiquotNestedExpr); l_Lean_Parser_antiquotExpr___closed__1 = _init_l_Lean_Parser_antiquotExpr___closed__1(); @@ -38531,8 +36886,6 @@ l_Lean_Parser_categoryParserOfStackFn___closed__1 = _init_l_Lean_Parser_category lean_mark_persistent(l_Lean_Parser_categoryParserOfStackFn___closed__1); l_Lean_Parser_categoryParserOfStackFn___closed__2 = _init_l_Lean_Parser_categoryParserOfStackFn___closed__2(); lean_mark_persistent(l_Lean_Parser_categoryParserOfStackFn___closed__2); -l_Lean_Parser_prattParser___closed__1 = _init_l_Lean_Parser_prattParser___closed__1(); -lean_mark_persistent(l_Lean_Parser_prattParser___closed__1); res = l_Lean_Parser_mkBuiltinTokenTable(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; l_Lean_Parser_builtinTokenTable = lean_io_result_get_value(res); @@ -38552,30 +36905,28 @@ if (lean_io_result_is_error(res)) return res; l_Lean_Parser_builtinParserCategoriesRef = lean_io_result_get_value(res); lean_mark_persistent(l_Lean_Parser_builtinParserCategoriesRef); lean_dec_ref(res); -l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__1 = _init_l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__1(); -lean_mark_persistent(l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__1); -l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__2 = _init_l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__2(); -lean_mark_persistent(l___private_Lean_Parser_Parser_13__throwParserCategoryAlreadyDefined___rarg___closed__2); +l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__1 = _init_l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__1); +l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__2 = _init_l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__2(); +lean_mark_persistent(l___private_Lean_Parser_Parser_14__throwParserCategoryAlreadyDefined___rarg___closed__2); l_Lean_Parser_ParserExtensionState_inhabited___closed__1 = _init_l_Lean_Parser_ParserExtensionState_inhabited___closed__1(); lean_mark_persistent(l_Lean_Parser_ParserExtensionState_inhabited___closed__1); l_Lean_Parser_ParserExtensionState_inhabited = _init_l_Lean_Parser_ParserExtensionState_inhabited(); lean_mark_persistent(l_Lean_Parser_ParserExtensionState_inhabited); -l___private_Lean_Parser_Parser_17__mergePrecendences___closed__1 = _init_l___private_Lean_Parser_Parser_17__mergePrecendences___closed__1(); -lean_mark_persistent(l___private_Lean_Parser_Parser_17__mergePrecendences___closed__1); -l___private_Lean_Parser_Parser_17__mergePrecendences___closed__2 = _init_l___private_Lean_Parser_Parser_17__mergePrecendences___closed__2(); -lean_mark_persistent(l___private_Lean_Parser_Parser_17__mergePrecendences___closed__2); -l___private_Lean_Parser_Parser_17__mergePrecendences___closed__3 = _init_l___private_Lean_Parser_Parser_17__mergePrecendences___closed__3(); -lean_mark_persistent(l___private_Lean_Parser_Parser_17__mergePrecendences___closed__3); -l___private_Lean_Parser_Parser_18__addTokenConfig___closed__1 = _init_l___private_Lean_Parser_Parser_18__addTokenConfig___closed__1(); -lean_mark_persistent(l___private_Lean_Parser_Parser_18__addTokenConfig___closed__1); -l___private_Lean_Parser_Parser_18__addTokenConfig___closed__2 = _init_l___private_Lean_Parser_Parser_18__addTokenConfig___closed__2(); -lean_mark_persistent(l___private_Lean_Parser_Parser_18__addTokenConfig___closed__2); -l___private_Lean_Parser_Parser_18__addTokenConfig___closed__3 = _init_l___private_Lean_Parser_Parser_18__addTokenConfig___closed__3(); -lean_mark_persistent(l___private_Lean_Parser_Parser_18__addTokenConfig___closed__3); +l___private_Lean_Parser_Parser_18__mergePrecendences___closed__1 = _init_l___private_Lean_Parser_Parser_18__mergePrecendences___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_18__mergePrecendences___closed__1); +l___private_Lean_Parser_Parser_18__mergePrecendences___closed__2 = _init_l___private_Lean_Parser_Parser_18__mergePrecendences___closed__2(); +lean_mark_persistent(l___private_Lean_Parser_Parser_18__mergePrecendences___closed__2); +l___private_Lean_Parser_Parser_18__mergePrecendences___closed__3 = _init_l___private_Lean_Parser_Parser_18__mergePrecendences___closed__3(); +lean_mark_persistent(l___private_Lean_Parser_Parser_18__mergePrecendences___closed__3); +l___private_Lean_Parser_Parser_19__addTokenConfig___closed__1 = _init_l___private_Lean_Parser_Parser_19__addTokenConfig___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_19__addTokenConfig___closed__1); +l___private_Lean_Parser_Parser_19__addTokenConfig___closed__2 = _init_l___private_Lean_Parser_Parser_19__addTokenConfig___closed__2(); +lean_mark_persistent(l___private_Lean_Parser_Parser_19__addTokenConfig___closed__2); l_Lean_Parser_throwUnknownParserCategory___rarg___closed__1 = _init_l_Lean_Parser_throwUnknownParserCategory___rarg___closed__1(); lean_mark_persistent(l_Lean_Parser_throwUnknownParserCategory___rarg___closed__1); -l___private_Lean_Parser_Parser_20__updateBuiltinTokens___closed__1 = _init_l___private_Lean_Parser_Parser_20__updateBuiltinTokens___closed__1(); -lean_mark_persistent(l___private_Lean_Parser_Parser_20__updateBuiltinTokens___closed__1); +l___private_Lean_Parser_Parser_21__updateBuiltinTokens___closed__1 = _init_l___private_Lean_Parser_Parser_21__updateBuiltinTokens___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_21__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(); @@ -38662,27 +37013,27 @@ l_Lean_Parser_declareTrailingBuiltinParser___closed__1 = _init_l_Lean_Parser_dec lean_mark_persistent(l_Lean_Parser_declareTrailingBuiltinParser___closed__1); l_Lean_Parser_declareTrailingBuiltinParser___closed__2 = _init_l_Lean_Parser_declareTrailingBuiltinParser___closed__2(); lean_mark_persistent(l_Lean_Parser_declareTrailingBuiltinParser___closed__2); -l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__1 = _init_l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__1(); -lean_mark_persistent(l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__1); -l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__2 = _init_l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__2(); -lean_mark_persistent(l___private_Lean_Parser_Parser_24__BuiltinParserAttribute_add___closed__2); +l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__1 = _init_l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__1); +l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__2 = _init_l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__2(); +lean_mark_persistent(l___private_Lean_Parser_Parser_25__BuiltinParserAttribute_add___closed__2); l_Lean_Parser_registerBuiltinParserAttribute___closed__1 = _init_l_Lean_Parser_registerBuiltinParserAttribute___closed__1(); lean_mark_persistent(l_Lean_Parser_registerBuiltinParserAttribute___closed__1); -l_List_foldlM___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__1___closed__1 = _init_l_List_foldlM___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__1___closed__1(); -lean_mark_persistent(l_List_foldlM___main___at___private_Lean_Parser_Parser_25__ParserAttribute_add___spec__1___closed__1); +l_List_foldlM___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__1___closed__1 = _init_l_List_foldlM___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__1___closed__1(); +lean_mark_persistent(l_List_foldlM___main___at___private_Lean_Parser_Parser_26__ParserAttribute_add___spec__1___closed__1); l_Lean_Parser_mkParserAttributeImpl___closed__1 = _init_l_Lean_Parser_mkParserAttributeImpl___closed__1(); lean_mark_persistent(l_Lean_Parser_mkParserAttributeImpl___closed__1); -l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__1 = _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__1(); -lean_mark_persistent(l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__1); -l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2 = _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2(); -lean_mark_persistent(l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___lambda__1___closed__2); -l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__1 = _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__1(); -lean_mark_persistent(l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__1); -l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__2 = _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__2(); -lean_mark_persistent(l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__2); -l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__3 = _init_l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__3(); -lean_mark_persistent(l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder___closed__3); -res = l___private_Lean_Parser_Parser_26__registerParserAttributeImplBuilder(lean_io_mk_world()); +l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__1 = _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__1); +l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2 = _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2(); +lean_mark_persistent(l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___lambda__1___closed__2); +l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__1 = _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__1(); +lean_mark_persistent(l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__1); +l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__2 = _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__2(); +lean_mark_persistent(l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__2); +l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__3 = _init_l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__3(); +lean_mark_persistent(l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder___closed__3); +res = l___private_Lean_Parser_Parser_27__registerParserAttributeImplBuilder(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); l_Lean_Parser_regBuiltinTermParserAttr___closed__1 = _init_l_Lean_Parser_regBuiltinTermParserAttr___closed__1(); diff --git a/stage0/stdlib/Lean/Parser/Syntax.c b/stage0/stdlib/Lean/Parser/Syntax.c index 212a59650a..a58058cfc5 100644 --- a/stage0/stdlib/Lean/Parser/Syntax.c +++ b/stage0/stdlib/Lean/Parser/Syntax.c @@ -17,9 +17,9 @@ 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(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_Syntax_cat___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; -extern lean_object* l_Lean_Parser_Tactic_orelse___closed__2; 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; @@ -38,6 +38,7 @@ lean_object* l_Lean_Parser_Command_macroTailTactic___closed__1; lean_object* l_Lean_Parser_precedence___elambda__1___closed__6; 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_Syntax_atom___closed__6; 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*); @@ -52,6 +53,7 @@ lean_object* l_Lean_Parser_Syntax_try___elambda__1___closed__1; 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* l_Lean_Parser_Syntax_str___elambda__1___closed__5; @@ -103,6 +105,7 @@ 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; +lean_object* l_Lean_Parser_checkRbpLtFn(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Syntax_sepBy; lean_object* l_Lean_Parser_Syntax_sepBy___closed__5; lean_object* l_Lean_Parser_Syntax_paren; @@ -163,7 +166,6 @@ extern lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__6; lean_object* l___regBuiltinParser_Lean_Parser_Command_reserve(lean_object*); lean_object* l_Lean_Parser_Command_identPrec; lean_object* l_Lean_Parser_Command_infixl___closed__2; -lean_object* l_Lean_Parser_Syntax_many1___closed__4; lean_object* l_Lean_Parser_precedence___elambda__1___closed__1; lean_object* l_Lean_Parser_Command_infixl___elambda__1___closed__1; lean_object* l_Lean_Parser_Command_strLitPrec___closed__2; @@ -199,6 +201,7 @@ 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; +extern lean_object* l_Lean_Parser_mkAntiquot___closed__5; lean_object* l_Lean_Parser_Command_macro__rules___elambda__1___closed__2; lean_object* l_Lean_Parser_Command_infix___closed__4; lean_object* l_Lean_Parser_Syntax_char___elambda__1___closed__3; @@ -249,10 +252,12 @@ lean_object* l_Lean_Parser_Syntax_sepBy1; lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1___closed__2; extern lean_object* l_Lean_Parser_quotedSymbol; lean_object* l_Lean_Parser_Syntax_num___elambda__1___closed__1; +extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__7; 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* l_Lean_Parser_Syntax_try___elambda__1___closed__4; +extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__1; lean_object* l_Lean_Parser_Command_postfix; lean_object* l_Lean_Parser_Command_infix___closed__2; extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__2; @@ -267,7 +272,6 @@ lean_object* l_Lean_Parser_Command_prefix___closed__1; lean_object* l_Lean_Parser_Command_infixl___elambda__1___closed__2; lean_object* l_Lean_Parser_nonReservedSymbolInfo(lean_object*, uint8_t); lean_object* l_Lean_Parser_Syntax_str___closed__2; -lean_object* l_Lean_Parser_Syntax_optional___closed__4; lean_object* l_Lean_Parser_Command_syntax___elambda__1___closed__7; lean_object* l_Lean_Parser_Command_syntax___closed__3; lean_object* l_Lean_Parser_Syntax_orelse___closed__3; @@ -300,7 +304,6 @@ 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; extern lean_object* l_Lean_Parser_Term_structInstArrayRef___closed__1; -extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__4; 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; @@ -327,6 +330,7 @@ lean_object* l_Lean_Parser_Syntax_cat; 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_paren___closed__8; lean_object* l_Lean_Parser_Syntax_lookahead___closed__3; lean_object* l_Lean_Parser_Command_mixfixSymbol___closed__2; lean_object* l_Lean_Parser_Command_macroTailTactic; @@ -347,6 +351,7 @@ lean_object* l_Lean_Parser_Command_reserve___elambda__1___closed__3; lean_object* l_Lean_Parser_precedenceLit___closed__1; lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__5; lean_object* l_Lean_Parser_Command_macroTailDefault___closed__3; +lean_object* l_Lean_Parser_Syntax_orelse___closed__6; extern lean_object* l_Lean_Parser_Command_docComment___elambda__1___closed__2; lean_object* l_Lean_Parser_Syntax_char___closed__1; lean_object* l_Lean_Parser_Syntax_ident___elambda__1___closed__5; @@ -458,6 +463,7 @@ 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; +extern lean_object* l___private_Lean_Parser_Parser_10__precErrorMsg; 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*); @@ -488,7 +494,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* l_Lean_Parser_Command_syntaxCat___elambda__1___closed__8; -lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolInfo(lean_object*); lean_object* l_Lean_Parser_maxPrec___elambda__1___closed__7; lean_object* l___regBuiltinParser_Lean_Parser_Command_mixfix(lean_object*); lean_object* l_Lean_Parser_Command_mixfix___closed__3; @@ -555,7 +561,6 @@ lean_object* l_Lean_Parser_Command_infixr___elambda__1___closed__1; 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_precedence___closed__6; 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; @@ -607,7 +612,6 @@ extern lean_object* l_Lean_Parser_regBuiltinTacticParserAttr___closed__4; 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; -extern lean_object* l_Lean_Syntax_decodeNatLitVal___closed__1; 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_Command_identPrec___closed__1; @@ -667,7 +671,9 @@ extern lean_object* l_Lean_Parser_Term_char___elambda__1___closed__1; lean_object* l_Lean_Parser_Command_macro___closed__2; lean_object* l_Lean_Parser_Command_prefix___elambda__1___closed__2; lean_object* l_Lean_Parser_Command_quotedSymbolPrec___closed__3; +extern lean_object* l_Lean_Parser_Level_addLit___closed__1; lean_object* l_Lean_Parser_Command_infixr___elambda__1___closed__4; +extern lean_object* l_Lean_Parser_Term_namedHole___closed__1; 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* l_Lean_Parser_Syntax_cat___elambda__1___closed__4; @@ -1361,48 +1367,38 @@ return x_49; lean_object* _init_l_Lean_Parser_precedence___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_mkAntiquot___closed__4; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +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_mkAntiquot___closed__5; +x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); +return x_4; } } lean_object* _init_l_Lean_Parser_precedence___closed__2() { _start: { -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_precedence___closed__1; -x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); -return x_4; -} -} -lean_object* _init_l_Lean_Parser_precedence___closed__3() { -_start: -{ lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_precedence___elambda__1___closed__2; -x_2 = l_Lean_Parser_precedence___closed__2; +x_2 = l_Lean_Parser_precedence___closed__1; x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Parser_precedence___closed__4() { +lean_object* _init_l_Lean_Parser_precedence___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_precedence___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_precedence___closed__3; +x_3 = l_Lean_Parser_precedence___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_precedence___closed__5() { +lean_object* _init_l_Lean_Parser_precedence___closed__4() { _start: { lean_object* x_1; @@ -1410,12 +1406,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_precedence___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_precedence___closed__6() { +lean_object* _init_l_Lean_Parser_precedence___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_precedence___closed__4; -x_2 = l_Lean_Parser_precedence___closed__5; +x_1 = l_Lean_Parser_precedence___closed__3; +x_2 = l_Lean_Parser_precedence___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); @@ -1426,7 +1422,7 @@ lean_object* _init_l_Lean_Parser_precedence() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_precedence___closed__6; +x_1 = l_Lean_Parser_precedence___closed__5; return x_1; } } @@ -1685,439 +1681,472 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_35; lean_object* x_51; lean_object* x_52; lean_object* x_53; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_51 = lean_ctor_get(x_2, 1); -lean_inc(x_51); -lean_inc(x_1); -x_52 = l_Lean_Parser_tokenFn(x_1, x_2); -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_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); -lean_dec(x_55); -x_57 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; -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_antiquotNestedExpr___elambda__1___closed__10; -x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_59, x_51); -x_35 = x_60; -goto block_50; -} -else -{ -lean_dec(x_51); -x_35 = x_52; -goto block_50; -} -} -else -{ -lean_object* x_61; lean_object* x_62; -lean_dec(x_55); -x_61 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_61, x_51); -x_35 = x_62; -goto block_50; -} -} -else -{ -lean_object* x_63; lean_object* x_64; -lean_dec(x_53); -x_63 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_63, x_51); -x_35 = x_64; -goto block_50; -} -block_34: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; -x_10 = lean_ctor_get(x_8, 1); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_39; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_10 = lean_ctor_get(x_8, 0); 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_Lean_Parser_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_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_18, x_10); -x_20 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_7); -return x_21; -} -else -{ -lean_object* x_22; lean_object* x_23; +x_11 = lean_array_get_size(x_10); lean_dec(x_10); -x_22 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_23 = l_Lean_Parser_ParserState_mkNode(x_11, x_22, x_7); -return x_23; +x_55 = lean_ctor_get(x_8, 1); +lean_inc(x_55); +lean_inc(x_1); +x_56 = l_Lean_Parser_tokenFn(x_1, x_8); +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); +x_59 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_antiquotNestedExpr___elambda__1___closed__3; +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_antiquotNestedExpr___elambda__1___closed__10; +x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_63, x_55); +x_39 = x_64; +goto block_54; +} +else +{ +lean_dec(x_55); +x_39 = x_56; +goto block_54; } } else { -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_object* x_65; lean_object* x_66; +lean_dec(x_59); +x_65 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_65, x_55); +x_39 = x_66; +goto block_54; +} +} +else +{ +lean_object* x_67; lean_object* x_68; +lean_dec(x_57); +x_67 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_56, x_67, x_55); +x_39 = x_68; +goto block_54; +} +block_38: +{ +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; +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +x_15 = l_Lean_Parser_tokenFn(x_1, 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_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); +lean_dec(x_18); +x_20 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; +x_21 = lean_string_dec_eq(x_19, x_20); +lean_dec(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); +x_24 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; +x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_11); +return x_25; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_dec(x_14); -x_24 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_24, x_10); x_26 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_7); +x_27 = l_Lean_Parser_ParserState_mkNode(x_15, x_26, x_11); return x_27; } } else { lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_12); +lean_dec(x_18); x_28 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_28, x_10); +x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_28, x_14); x_30 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_7); +x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_11); return x_31; } } else { -lean_object* x_32; lean_object* x_33; +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_dec(x_16); +x_32 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_32, x_14); +x_34 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_11); +return x_35; +} +} +else +{ +lean_object* x_36; lean_object* x_37; +lean_dec(x_13); +lean_dec(x_1); +x_36 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; +x_37 = l_Lean_Parser_ParserState_mkNode(x_12, x_36, x_11); +return x_37; +} +} +block_54: +{ +lean_object* x_40; +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 = lean_ctor_get(x_39, 0); +lean_inc(x_41); +x_42 = lean_array_get_size(x_41); +lean_dec(x_41); +x_43 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4; +x_44 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_45 = l_Lean_Parser_categoryParser___elambda__1(x_43, x_44, x_1, x_39); +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_inc(x_1); +x_47 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(x_1, x_45); +x_48 = l_Lean_nullKind; +x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_42); +x_12 = x_49; +goto block_38; +} +else +{ +lean_object* x_50; lean_object* x_51; +lean_dec(x_46); +x_50 = l_Lean_nullKind; +x_51 = l_Lean_Parser_ParserState_mkNode(x_45, x_50, x_42); +x_12 = x_51; +goto block_38; +} +} +else +{ +lean_object* x_52; lean_object* x_53; +lean_dec(x_40); +lean_dec(x_1); +x_52 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; +x_53 = l_Lean_Parser_ParserState_mkNode(x_39, x_52, x_11); +return x_53; +} +} +} +else +{ lean_dec(x_9); lean_dec(x_1); -x_32 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_33 = l_Lean_Parser_ParserState_mkNode(x_8, x_32, x_7); -return x_33; -} -} -block_50: -{ -lean_object* x_36; -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_object* x_41; lean_object* x_42; -x_37 = lean_ctor_get(x_35, 0); -lean_inc(x_37); -x_38 = lean_array_get_size(x_37); -lean_dec(x_37); -x_39 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4; -x_40 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_41 = l_Lean_Parser_categoryParser___elambda__1(x_39, x_40, x_1, x_35); -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_inc(x_1); -x_43 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(x_1, x_41); -x_44 = l_Lean_nullKind; -x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_38); -x_8 = x_45; -goto block_34; -} -else -{ -lean_object* x_46; lean_object* x_47; -lean_dec(x_42); -x_46 = l_Lean_nullKind; -x_47 = l_Lean_Parser_ParserState_mkNode(x_41, x_46, x_38); -x_8 = x_47; -goto block_34; +return x_8; } } else { -lean_object* x_48; lean_object* x_49; -lean_dec(x_36); -lean_dec(x_1); -x_48 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_49 = l_Lean_Parser_ParserState_mkNode(x_35, x_48, x_7); -return x_49; -} -} -} -else -{ -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_2, 0); -lean_inc(x_65); -x_66 = lean_array_get_size(x_65); -lean_dec(x_65); -x_67 = lean_ctor_get(x_2, 1); -lean_inc(x_67); -lean_inc(x_1); -x_68 = lean_apply_2(x_4, x_1, x_2); -x_69 = lean_ctor_get(x_68, 3); +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_69 = lean_ctor_get(x_2, 0); lean_inc(x_69); -if (lean_obj_tag(x_69) == 0) -{ -lean_dec(x_67); -lean_dec(x_66); -lean_dec(x_1); -return x_68; -} -else -{ -lean_object* x_70; lean_object* x_71; uint8_t x_72; -x_70 = lean_ctor_get(x_69, 0); -lean_inc(x_70); +x_70 = lean_array_get_size(x_69); lean_dec(x_69); -x_71 = lean_ctor_get(x_68, 1); +x_71 = lean_ctor_get(x_2, 1); lean_inc(x_71); -x_72 = lean_nat_dec_eq(x_71, x_67); -lean_dec(x_71); -if (x_72 == 0) +lean_inc(x_1); +x_72 = lean_apply_2(x_4, x_1, x_2); +x_73 = lean_ctor_get(x_72, 3); +lean_inc(x_73); +if (lean_obj_tag(x_73) == 0) { +lean_dec(x_71); lean_dec(x_70); -lean_dec(x_67); -lean_dec(x_66); lean_dec(x_1); -return x_68; +return x_72; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_108; lean_object* x_125; lean_object* x_126; -lean_inc(x_67); -x_73 = l_Lean_Parser_ParserState_restore(x_68, x_66, x_67); -lean_dec(x_66); +lean_object* x_74; lean_object* x_75; uint8_t x_76; x_74 = lean_ctor_get(x_73, 0); lean_inc(x_74); -x_75 = lean_array_get_size(x_74); +lean_dec(x_73); +x_75 = lean_ctor_get(x_72, 1); +lean_inc(x_75); +x_76 = lean_nat_dec_eq(x_75, x_71); +lean_dec(x_75); +if (x_76 == 0) +{ lean_dec(x_74); +lean_dec(x_71); +lean_dec(x_70); +lean_dec(x_1); +return x_72; +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +lean_inc(x_71); +x_77 = l_Lean_Parser_ParserState_restore(x_72, x_70, x_71); +lean_dec(x_70); +x_78 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_79 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_80 = l_Lean_Parser_checkRbpLtFn(x_78, x_79, x_1, x_77); +x_81 = lean_ctor_get(x_80, 3); +lean_inc(x_81); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_116; lean_object* x_133; lean_object* x_134; lean_object* x_135; +x_82 = lean_ctor_get(x_80, 0); +lean_inc(x_82); +x_83 = lean_array_get_size(x_82); +lean_dec(x_82); +x_133 = lean_ctor_get(x_80, 1); +lean_inc(x_133); lean_inc(x_1); -x_125 = l_Lean_Parser_tokenFn(x_1, x_73); -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 = lean_ctor_get(x_125, 0); -lean_inc(x_127); -x_128 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_127); -lean_dec(x_127); -if (lean_obj_tag(x_128) == 2) -{ -lean_object* x_129; lean_object* x_130; uint8_t x_131; -x_129 = lean_ctor_get(x_128, 1); -lean_inc(x_129); -lean_dec(x_128); -x_130 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; -x_131 = lean_string_dec_eq(x_129, x_130); -lean_dec(x_129); -if (x_131 == 0) -{ -lean_object* x_132; lean_object* x_133; -x_132 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_67); -x_133 = l_Lean_Parser_ParserState_mkErrorsAt(x_125, x_132, x_67); -x_108 = x_133; -goto block_124; -} -else -{ -x_108 = x_125; -goto block_124; -} -} -else -{ -lean_object* x_134; lean_object* x_135; -lean_dec(x_128); -x_134 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_67); -x_135 = l_Lean_Parser_ParserState_mkErrorsAt(x_125, x_134, x_67); -x_108 = x_135; -goto block_124; -} -} -else +x_134 = l_Lean_Parser_tokenFn(x_1, x_80); +x_135 = lean_ctor_get(x_134, 3); +lean_inc(x_135); +if (lean_obj_tag(x_135) == 0) { lean_object* x_136; lean_object* x_137; -lean_dec(x_126); -x_136 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_67); -x_137 = l_Lean_Parser_ParserState_mkErrorsAt(x_125, x_136, x_67); -x_108 = x_137; -goto block_124; -} -block_107: +x_136 = lean_ctor_get(x_134, 0); +lean_inc(x_136); +x_137 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_136); +lean_dec(x_136); +if (lean_obj_tag(x_137) == 2) { -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_138; lean_object* x_139; uint8_t x_140; +x_138 = lean_ctor_get(x_137, 1); +lean_inc(x_138); +lean_dec(x_137); +x_139 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; +x_140 = lean_string_dec_eq(x_138, x_139); +lean_dec(x_138); +if (x_140 == 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); -x_79 = l_Lean_Parser_tokenFn(x_1, 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_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_antiquotNestedExpr___elambda__1___closed__4; -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_antiquotNestedExpr___elambda__1___closed__7; -x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_78); -x_88 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_75); -x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_70, x_67); -lean_dec(x_67); -return x_90; +lean_object* x_141; lean_object* x_142; +x_141 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_142 = l_Lean_Parser_ParserState_mkErrorsAt(x_134, x_141, x_133); +x_116 = x_142; +goto block_132; } else { -lean_object* x_91; lean_object* x_92; lean_object* x_93; -lean_dec(x_78); -x_91 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_92 = l_Lean_Parser_ParserState_mkNode(x_79, x_91, x_75); -x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_70, x_67); -lean_dec(x_67); -return x_93; +lean_dec(x_133); +x_116 = x_134; +goto block_132; } } else { +lean_object* x_143; lean_object* x_144; +lean_dec(x_137); +x_143 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_144 = l_Lean_Parser_ParserState_mkErrorsAt(x_134, x_143, x_133); +x_116 = x_144; +goto block_132; +} +} +else +{ +lean_object* x_145; lean_object* x_146; +lean_dec(x_135); +x_145 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_146 = l_Lean_Parser_ParserState_mkErrorsAt(x_134, x_145, x_133); +x_116 = x_146; +goto block_132; +} +block_115: +{ +lean_object* x_85; +x_85 = lean_ctor_get(x_84, 3); +lean_inc(x_85); +if (lean_obj_tag(x_85) == 0) +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_86 = lean_ctor_get(x_84, 1); +lean_inc(x_86); +x_87 = l_Lean_Parser_tokenFn(x_1, x_84); +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_antiquotNestedExpr___elambda__1___closed__4; +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; lean_object* x_96; lean_object* x_97; lean_object* x_98; -lean_dec(x_82); x_94 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_94, x_78); +x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_87, x_94, x_86); x_96 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_97 = l_Lean_Parser_ParserState_mkNode(x_95, x_96, x_75); -x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_70, x_67); -lean_dec(x_67); +x_97 = l_Lean_Parser_ParserState_mkNode(x_95, x_96, x_83); +x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_74, x_71); +lean_dec(x_71); return x_98; } -} 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_antiquotNestedExpr___elambda__1___closed__7; -x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_99, x_78); -x_101 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_75); -x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_70, x_67); -lean_dec(x_67); -return x_103; +lean_object* x_99; lean_object* x_100; lean_object* x_101; +lean_dec(x_86); +x_99 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; +x_100 = l_Lean_Parser_ParserState_mkNode(x_87, x_99, x_83); +x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_74, x_71); +lean_dec(x_71); +return x_101; } } else { -lean_object* x_104; lean_object* x_105; lean_object* x_106; -lean_dec(x_77); -lean_dec(x_1); +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; +lean_dec(x_90); +x_102 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_103 = l_Lean_Parser_ParserState_mkErrorsAt(x_87, x_102, x_86); x_104 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_105 = l_Lean_Parser_ParserState_mkNode(x_76, x_104, x_75); -x_106 = l_Lean_Parser_mergeOrElseErrors(x_105, x_70, x_67); -lean_dec(x_67); +x_105 = l_Lean_Parser_ParserState_mkNode(x_103, x_104, x_83); +x_106 = l_Lean_Parser_mergeOrElseErrors(x_105, x_74, x_71); +lean_dec(x_71); return x_106; } } -block_124: -{ -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_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; -x_110 = lean_ctor_get(x_108, 0); -lean_inc(x_110); -x_111 = lean_array_get_size(x_110); -lean_dec(x_110); -x_112 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4; -x_113 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_114 = l_Lean_Parser_categoryParser___elambda__1(x_112, x_113, x_1, x_108); -x_115 = lean_ctor_get(x_114, 3); -lean_inc(x_115); -if (lean_obj_tag(x_115) == 0) -{ -lean_object* x_116; lean_object* x_117; lean_object* x_118; -lean_inc(x_1); -x_116 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(x_1, x_114); -x_117 = l_Lean_nullKind; -x_118 = l_Lean_Parser_ParserState_mkNode(x_116, x_117, x_111); -x_76 = x_118; -goto block_107; -} else { -lean_object* x_119; lean_object* x_120; -lean_dec(x_115); -x_119 = l_Lean_nullKind; -x_120 = l_Lean_Parser_ParserState_mkNode(x_114, x_119, x_111); -x_76 = x_120; -goto block_107; +lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +lean_dec(x_88); +x_107 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_108 = l_Lean_Parser_ParserState_mkErrorsAt(x_87, x_107, x_86); +x_109 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; +x_110 = l_Lean_Parser_ParserState_mkNode(x_108, x_109, x_83); +x_111 = l_Lean_Parser_mergeOrElseErrors(x_110, x_74, x_71); +lean_dec(x_71); +return x_111; } } else { -lean_object* x_121; lean_object* x_122; lean_object* x_123; -lean_dec(x_109); +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_dec(x_85); lean_dec(x_1); -x_121 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; -x_122 = l_Lean_Parser_ParserState_mkNode(x_108, x_121, x_75); -x_123 = l_Lean_Parser_mergeOrElseErrors(x_122, x_70, x_67); -lean_dec(x_67); -return x_123; +x_112 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; +x_113 = l_Lean_Parser_ParserState_mkNode(x_84, x_112, x_83); +x_114 = l_Lean_Parser_mergeOrElseErrors(x_113, x_74, x_71); +lean_dec(x_71); +return x_114; } } +block_132: +{ +lean_object* x_117; +x_117 = lean_ctor_get(x_116, 3); +lean_inc(x_117); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_118 = lean_ctor_get(x_116, 0); +lean_inc(x_118); +x_119 = lean_array_get_size(x_118); +lean_dec(x_118); +x_120 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4; +x_121 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_122 = l_Lean_Parser_categoryParser___elambda__1(x_120, x_121, x_1, x_116); +x_123 = lean_ctor_get(x_122, 3); +lean_inc(x_123); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; lean_object* x_125; lean_object* x_126; +lean_inc(x_1); +x_124 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Syntax_paren___elambda__1___spec__1(x_1, x_122); +x_125 = l_Lean_nullKind; +x_126 = l_Lean_Parser_ParserState_mkNode(x_124, x_125, x_119); +x_84 = x_126; +goto block_115; +} +else +{ +lean_object* x_127; lean_object* x_128; +lean_dec(x_123); +x_127 = l_Lean_nullKind; +x_128 = l_Lean_Parser_ParserState_mkNode(x_122, x_127, x_119); +x_84 = x_128; +goto block_115; +} +} +else +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; +lean_dec(x_117); +lean_dec(x_1); +x_129 = l_Lean_Parser_Syntax_paren___elambda__1___closed__3; +x_130 = l_Lean_Parser_ParserState_mkNode(x_116, x_129, x_83); +x_131 = l_Lean_Parser_mergeOrElseErrors(x_130, x_74, x_71); +lean_dec(x_71); +return x_131; +} +} +} +else +{ +lean_object* x_147; +lean_dec(x_81); +lean_dec(x_1); +x_147 = l_Lean_Parser_mergeOrElseErrors(x_80, x_74, x_71); +lean_dec(x_71); +return x_147; +} } } } @@ -2140,7 +2169,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_Lean_Parser_antiquotNestedExpr___closed__4; +x_3 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } @@ -2149,7 +2178,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_Lean_Parser_antiquotNestedExpr___closed__2; +x_1 = l_Lean_Parser_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; @@ -2168,16 +2197,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Syntax_paren___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Syntax_paren___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Syntax_paren___closed__6() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Syntax_paren___elambda__1___closed__5; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Syntax_paren___closed__4; +x_3 = l_Lean_Parser_Syntax_paren___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Syntax_paren___closed__6() { +lean_object* _init_l_Lean_Parser_Syntax_paren___closed__7() { _start: { lean_object* x_1; @@ -2185,12 +2224,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_paren___elambda__1), 2, 0) return x_1; } } -lean_object* _init_l_Lean_Parser_Syntax_paren___closed__7() { +lean_object* _init_l_Lean_Parser_Syntax_paren___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Syntax_paren___closed__5; -x_2 = l_Lean_Parser_Syntax_paren___closed__6; +x_1 = l_Lean_Parser_Syntax_paren___closed__6; +x_2 = l_Lean_Parser_Syntax_paren___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); @@ -2201,7 +2240,7 @@ lean_object* _init_l_Lean_Parser_Syntax_paren() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Syntax_paren___closed__7; +x_1 = l_Lean_Parser_Syntax_paren___closed__8; return x_1; } } @@ -2270,104 +2309,137 @@ if (x_5 == 0) { lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -lean_inc(x_1); -x_8 = l_Lean_Parser_ident___elambda__1(x_1, x_2); +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; -x_10 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_8); -x_11 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2; -x_12 = l_Lean_Parser_ParserState_mkNode(x_10, x_11, x_7); -return x_12; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +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_12 = l_Lean_Parser_ident___elambda__1(x_1, x_8); +x_13 = lean_ctor_get(x_12, 3); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_12); +x_15 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2; +x_16 = l_Lean_Parser_ParserState_mkNode(x_14, x_15, x_11); +return x_16; +} +else +{ +lean_object* x_17; lean_object* x_18; +lean_dec(x_13); +lean_dec(x_1); +x_17 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_12, x_17, x_11); +return x_18; +} } else { -lean_object* x_13; lean_object* x_14; lean_dec(x_9); lean_dec(x_1); -x_13 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_8, x_13, x_7); -return x_14; +return x_8; } } else { -lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_15 = lean_ctor_get(x_2, 0); -lean_inc(x_15); -x_16 = lean_array_get_size(x_15); -lean_dec(x_15); -x_17 = lean_ctor_get(x_2, 1); -lean_inc(x_17); -lean_inc(x_1); -x_18 = lean_apply_2(x_4, x_1, x_2); -x_19 = lean_ctor_get(x_18, 3); +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_2, 0); lean_inc(x_19); -if (lean_obj_tag(x_19) == 0) -{ -lean_dec(x_17); -lean_dec(x_16); -lean_dec(x_1); -return x_18; -} -else -{ -lean_object* x_20; lean_object* x_21; uint8_t x_22; -x_20 = lean_ctor_get(x_19, 0); -lean_inc(x_20); +x_20 = lean_array_get_size(x_19); lean_dec(x_19); -x_21 = lean_ctor_get(x_18, 1); +x_21 = lean_ctor_get(x_2, 1); lean_inc(x_21); -x_22 = lean_nat_dec_eq(x_21, x_17); -lean_dec(x_21); -if (x_22 == 0) +lean_inc(x_1); +x_22 = lean_apply_2(x_4, x_1, x_2); +x_23 = lean_ctor_get(x_22, 3); +lean_inc(x_23); +if (lean_obj_tag(x_23) == 0) { +lean_dec(x_21); lean_dec(x_20); -lean_dec(x_17); -lean_dec(x_16); lean_dec(x_1); -return x_18; +return x_22; } else { -lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; -lean_inc(x_17); -x_23 = l_Lean_Parser_ParserState_restore(x_18, x_16, x_17); -lean_dec(x_16); +lean_object* x_24; lean_object* x_25; uint8_t x_26; x_24 = lean_ctor_get(x_23, 0); lean_inc(x_24); -x_25 = lean_array_get_size(x_24); -lean_dec(x_24); -lean_inc(x_1); -x_26 = l_Lean_Parser_ident___elambda__1(x_1, x_23); -x_27 = lean_ctor_get(x_26, 3); -lean_inc(x_27); -if (lean_obj_tag(x_27) == 0) +lean_dec(x_23); +x_25 = lean_ctor_get(x_22, 1); +lean_inc(x_25); +x_26 = lean_nat_dec_eq(x_25, x_21); +lean_dec(x_25); +if (x_26 == 0) { -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -x_28 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_26); -x_29 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2; -x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_25); -x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_20, x_17); -lean_dec(x_17); -return x_31; +lean_dec(x_24); +lean_dec(x_21); +lean_dec(x_20); +lean_dec(x_1); +return x_22; } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_27); +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +lean_inc(x_21); +x_27 = l_Lean_Parser_ParserState_restore(x_22, x_20, x_21); +lean_dec(x_20); +x_28 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_29 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_30 = l_Lean_Parser_checkRbpLtFn(x_28, x_29, x_1, x_27); +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; lean_object* x_35; +x_32 = lean_ctor_get(x_30, 0); +lean_inc(x_32); +x_33 = lean_array_get_size(x_32); +lean_dec(x_32); +lean_inc(x_1); +x_34 = l_Lean_Parser_ident___elambda__1(x_1, x_30); +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; lean_object* x_39; +x_36 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_34); +x_37 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2; +x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_33); +x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_24, x_21); +lean_dec(x_21); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; +lean_dec(x_35); lean_dec(x_1); -x_32 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2; -x_33 = l_Lean_Parser_ParserState_mkNode(x_26, x_32, x_25); -x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_20, x_17); -lean_dec(x_17); -return x_34; +x_40 = l_Lean_Parser_Syntax_cat___elambda__1___closed__2; +x_41 = l_Lean_Parser_ParserState_mkNode(x_34, x_40, x_33); +x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_24, x_21); +lean_dec(x_21); +return x_42; +} +} +else +{ +lean_object* x_43; +lean_dec(x_31); +lean_dec(x_1); +x_43 = l_Lean_Parser_mergeOrElseErrors(x_30, x_24, x_21); +lean_dec(x_21); +return x_43; } } } @@ -2401,16 +2473,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Syntax_cat___closed__3() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Syntax_cat___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Syntax_cat___closed__4() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Syntax_cat___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Syntax_cat___closed__2; +x_3 = l_Lean_Parser_Syntax_cat___closed__3; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Syntax_cat___closed__4() { +lean_object* _init_l_Lean_Parser_Syntax_cat___closed__5() { _start: { lean_object* x_1; @@ -2418,12 +2500,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_cat___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Syntax_cat___closed__5() { +lean_object* _init_l_Lean_Parser_Syntax_cat___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Syntax_cat___closed__3; -x_2 = l_Lean_Parser_Syntax_cat___closed__4; +x_1 = l_Lean_Parser_Syntax_cat___closed__4; +x_2 = l_Lean_Parser_Syntax_cat___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); @@ -2434,7 +2516,7 @@ lean_object* _init_l_Lean_Parser_Syntax_cat() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Syntax_cat___closed__5; +x_1 = l_Lean_Parser_Syntax_cat___closed__6; return x_1; } } @@ -2503,104 +2585,137 @@ if (x_5 == 0) { lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -lean_inc(x_1); -x_8 = l_Lean_Parser_strLit___elambda__1(x_1, x_2); +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; -x_10 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_8); -x_11 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2; -x_12 = l_Lean_Parser_ParserState_mkNode(x_10, x_11, x_7); -return x_12; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +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_12 = l_Lean_Parser_strLit___elambda__1(x_1, x_8); +x_13 = lean_ctor_get(x_12, 3); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_12); +x_15 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2; +x_16 = l_Lean_Parser_ParserState_mkNode(x_14, x_15, x_11); +return x_16; +} +else +{ +lean_object* x_17; lean_object* x_18; +lean_dec(x_13); +lean_dec(x_1); +x_17 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_12, x_17, x_11); +return x_18; +} } else { -lean_object* x_13; lean_object* x_14; lean_dec(x_9); lean_dec(x_1); -x_13 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_8, x_13, x_7); -return x_14; +return x_8; } } else { -lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_15 = lean_ctor_get(x_2, 0); -lean_inc(x_15); -x_16 = lean_array_get_size(x_15); -lean_dec(x_15); -x_17 = lean_ctor_get(x_2, 1); -lean_inc(x_17); -lean_inc(x_1); -x_18 = lean_apply_2(x_4, x_1, x_2); -x_19 = lean_ctor_get(x_18, 3); +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_2, 0); lean_inc(x_19); -if (lean_obj_tag(x_19) == 0) -{ -lean_dec(x_17); -lean_dec(x_16); -lean_dec(x_1); -return x_18; -} -else -{ -lean_object* x_20; lean_object* x_21; uint8_t x_22; -x_20 = lean_ctor_get(x_19, 0); -lean_inc(x_20); +x_20 = lean_array_get_size(x_19); lean_dec(x_19); -x_21 = lean_ctor_get(x_18, 1); +x_21 = lean_ctor_get(x_2, 1); lean_inc(x_21); -x_22 = lean_nat_dec_eq(x_21, x_17); -lean_dec(x_21); -if (x_22 == 0) +lean_inc(x_1); +x_22 = lean_apply_2(x_4, x_1, x_2); +x_23 = lean_ctor_get(x_22, 3); +lean_inc(x_23); +if (lean_obj_tag(x_23) == 0) { +lean_dec(x_21); lean_dec(x_20); -lean_dec(x_17); -lean_dec(x_16); lean_dec(x_1); -return x_18; +return x_22; } else { -lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; -lean_inc(x_17); -x_23 = l_Lean_Parser_ParserState_restore(x_18, x_16, x_17); -lean_dec(x_16); +lean_object* x_24; lean_object* x_25; uint8_t x_26; x_24 = lean_ctor_get(x_23, 0); lean_inc(x_24); -x_25 = lean_array_get_size(x_24); -lean_dec(x_24); -lean_inc(x_1); -x_26 = l_Lean_Parser_strLit___elambda__1(x_1, x_23); -x_27 = lean_ctor_get(x_26, 3); -lean_inc(x_27); -if (lean_obj_tag(x_27) == 0) +lean_dec(x_23); +x_25 = lean_ctor_get(x_22, 1); +lean_inc(x_25); +x_26 = lean_nat_dec_eq(x_25, x_21); +lean_dec(x_25); +if (x_26 == 0) { -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -x_28 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_26); -x_29 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2; -x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_25); -x_31 = l_Lean_Parser_mergeOrElseErrors(x_30, x_20, x_17); -lean_dec(x_17); -return x_31; +lean_dec(x_24); +lean_dec(x_21); +lean_dec(x_20); +lean_dec(x_1); +return x_22; } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_27); +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +lean_inc(x_21); +x_27 = l_Lean_Parser_ParserState_restore(x_22, x_20, x_21); +lean_dec(x_20); +x_28 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_29 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_30 = l_Lean_Parser_checkRbpLtFn(x_28, x_29, x_1, x_27); +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; lean_object* x_35; +x_32 = lean_ctor_get(x_30, 0); +lean_inc(x_32); +x_33 = lean_array_get_size(x_32); +lean_dec(x_32); +lean_inc(x_1); +x_34 = l_Lean_Parser_strLit___elambda__1(x_1, x_30); +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; lean_object* x_39; +x_36 = l_Lean_Parser_optPrecedence___elambda__1(x_1, x_34); +x_37 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2; +x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_33); +x_39 = l_Lean_Parser_mergeOrElseErrors(x_38, x_24, x_21); +lean_dec(x_21); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; +lean_dec(x_35); lean_dec(x_1); -x_32 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2; -x_33 = l_Lean_Parser_ParserState_mkNode(x_26, x_32, x_25); -x_34 = l_Lean_Parser_mergeOrElseErrors(x_33, x_20, x_17); -lean_dec(x_17); -return x_34; +x_40 = l_Lean_Parser_Syntax_atom___elambda__1___closed__2; +x_41 = l_Lean_Parser_ParserState_mkNode(x_34, x_40, x_33); +x_42 = l_Lean_Parser_mergeOrElseErrors(x_41, x_24, x_21); +lean_dec(x_21); +return x_42; +} +} +else +{ +lean_object* x_43; +lean_dec(x_31); +lean_dec(x_1); +x_43 = l_Lean_Parser_mergeOrElseErrors(x_30, x_24, x_21); +lean_dec(x_21); +return x_43; } } } @@ -2634,16 +2749,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Syntax_atom___closed__3() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Syntax_atom___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Syntax_atom___closed__4() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Syntax_atom___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Syntax_atom___closed__2; +x_3 = l_Lean_Parser_Syntax_atom___closed__3; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Syntax_atom___closed__4() { +lean_object* _init_l_Lean_Parser_Syntax_atom___closed__5() { _start: { lean_object* x_1; @@ -2651,12 +2776,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_atom___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Syntax_atom___closed__5() { +lean_object* _init_l_Lean_Parser_Syntax_atom___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Syntax_atom___closed__3; -x_2 = l_Lean_Parser_Syntax_atom___closed__4; +x_1 = l_Lean_Parser_Syntax_atom___closed__4; +x_2 = l_Lean_Parser_Syntax_atom___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); @@ -2667,7 +2792,7 @@ lean_object* _init_l_Lean_Parser_Syntax_atom() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Syntax_atom___closed__5; +x_1 = l_Lean_Parser_Syntax_atom___closed__6; return x_1; } } @@ -4885,23 +5010,13 @@ lean_object* _init_l_Lean_Parser_Syntax_optional___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_Term_namedHole___elambda__1___closed__5; -x_3 = l_Lean_Parser_symbolInfo(x_2, x_1); -return x_3; -} -} -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___closed__2; -x_2 = l_Lean_Parser_Syntax_optional___closed__1; +x_2 = l_Lean_Parser_Term_namedHole___closed__1; x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Parser_Syntax_optional___closed__3() { +lean_object* _init_l_Lean_Parser_Syntax_optional___closed__2() { _start: { lean_object* x_1; @@ -4909,12 +5024,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_optional___elambda__1), 2, return x_1; } } -lean_object* _init_l_Lean_Parser_Syntax_optional___closed__4() { +lean_object* _init_l_Lean_Parser_Syntax_optional___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Syntax_optional___closed__2; -x_2 = l_Lean_Parser_Syntax_optional___closed__3; +x_1 = l_Lean_Parser_Syntax_optional___closed__1; +x_2 = l_Lean_Parser_Syntax_optional___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); @@ -4925,7 +5040,7 @@ lean_object* _init_l_Lean_Parser_Syntax_optional() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Syntax_optional___closed__4; +x_1 = l_Lean_Parser_Syntax_optional___closed__3; return x_1; } } @@ -5211,23 +5326,13 @@ lean_object* _init_l_Lean_Parser_Syntax_many1___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_Level_addLit___elambda__1___closed__3; -x_3 = l_Lean_Parser_symbolInfo(x_2, x_1); -return x_3; -} -} -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___closed__2; -x_2 = l_Lean_Parser_Syntax_many1___closed__1; +x_2 = l_Lean_Parser_Level_addLit___closed__1; x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Parser_Syntax_many1___closed__3() { +lean_object* _init_l_Lean_Parser_Syntax_many1___closed__2() { _start: { lean_object* x_1; @@ -5235,12 +5340,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_many1___elambda__1), 2, 0) return x_1; } } -lean_object* _init_l_Lean_Parser_Syntax_many1___closed__4() { +lean_object* _init_l_Lean_Parser_Syntax_many1___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Syntax_many1___closed__2; -x_2 = l_Lean_Parser_Syntax_many1___closed__3; +x_1 = l_Lean_Parser_Syntax_many1___closed__1; +x_2 = l_Lean_Parser_Syntax_many1___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); @@ -5251,7 +5356,7 @@ lean_object* _init_l_Lean_Parser_Syntax_many1() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Syntax_many1___closed__4; +x_1 = l_Lean_Parser_Syntax_many1___closed__3; return x_1; } } @@ -5280,93 +5385,108 @@ return x_3; 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; -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_15 = lean_ctor_get(x_2, 1); -lean_inc(x_15); -lean_inc(x_1); -x_16 = l_Lean_Parser_tokenFn(x_1, x_2); -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); -x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18); -lean_dec(x_18); -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_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___closed__5; -x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_15); -x_5 = x_24; -goto block_14; -} -else -{ -lean_dec(x_15); -x_5 = x_16; -goto block_14; -} -} -else -{ -lean_object* x_25; lean_object* x_26; -lean_dec(x_19); -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; -} -} -else -{ -lean_object* x_27; lean_object* x_28; -lean_dec(x_17); -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; -} -block_14: -{ -lean_object* x_6; +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = lean_unsigned_to_nat(2u); +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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) { -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_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; +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_19; lean_object* x_20; lean_object* x_21; +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_19 = lean_ctor_get(x_5, 1); +lean_inc(x_19); +lean_inc(x_1); +x_20 = l_Lean_Parser_tokenFn(x_1, x_5); +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; +x_22 = lean_ctor_get(x_20, 0); +lean_inc(x_22); +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); +lean_dec(x_23); +x_25 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__2; +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; +x_27 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5; +x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_27, x_19); +x_9 = x_28; +goto block_18; +} +else +{ +lean_dec(x_19); +x_9 = x_20; +goto block_18; +} +} +else +{ +lean_object* x_29; lean_object* x_30; +lean_dec(x_23); +x_29 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5; +x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_29, x_19); +x_9 = x_30; +goto block_18; +} +} +else +{ +lean_object* x_31; lean_object* x_32; +lean_dec(x_21); +x_31 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5; +x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_31, x_19); +x_9 = x_32; +goto block_18; +} +block_18: +{ +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_object* x_13; lean_object* x_14; lean_object* x_15; +x_11 = l_Lean_Parser_regBuiltinSyntaxParserAttr___closed__4; +x_12 = lean_unsigned_to_nat(1u); +x_13 = l_Lean_Parser_categoryParser___elambda__1(x_11, x_12, x_1, x_9); +x_14 = l_Lean_Parser_Syntax_orelse___elambda__1___closed__1; +x_15 = l_Lean_Parser_ParserState_mkTrailingNode(x_13, x_14, x_8); +lean_dec(x_8); +return x_15; +} +else +{ +lean_object* x_16; lean_object* x_17; +lean_dec(x_10); +lean_dec(x_1); +x_16 = l_Lean_Parser_Syntax_orelse___elambda__1___closed__1; +x_17 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_16, x_8); +lean_dec(x_8); +return x_17; +} +} } 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___closed__1; -x_13 = l_Lean_Parser_ParserState_mkTrailingNode(x_5, x_12, x_4); -lean_dec(x_4); -return x_13; -} +return x_5; } } } @@ -5387,7 +5507,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Syntax_orelse___closed__1; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Tactic_orelse___closed__2; +x_3 = l_Lean_Parser_Tactic_orelse___closed__1; x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); return x_4; } @@ -5405,17 +5525,27 @@ return x_3; 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), 2, 0); -return x_1; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Syntax_orelse___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Syntax_orelse___closed__5() { _start: { +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Syntax_orelse___elambda__1), 2, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Parser_Syntax_orelse___closed__6() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Syntax_orelse___closed__3; -x_2 = l_Lean_Parser_Syntax_orelse___closed__4; +x_1 = l_Lean_Parser_Syntax_orelse___closed__4; +x_2 = l_Lean_Parser_Syntax_orelse___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); @@ -5426,7 +5556,7 @@ lean_object* _init_l_Lean_Parser_Syntax_orelse() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Syntax_orelse___closed__5; +x_1 = l_Lean_Parser_Syntax_orelse___closed__6; return x_1; } } @@ -5944,11 +6074,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_prefix___closed__1() { _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_Command_prefix___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_prefix___closed__2() { @@ -6284,11 +6413,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_infix___closed__1() { _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_Command_infix___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_infix___closed__2() { @@ -6624,11 +6752,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_infixl___closed__1() { _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_Command_infixl___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_infixl___closed__2() { @@ -6964,11 +7091,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_infixr___closed__1() { _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_Command_infixr___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_infixr___closed__2() { @@ -7304,11 +7430,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Command_postfix___closed__1() { _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_Command_postfix___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_postfix___closed__2() { @@ -7997,11 +8122,10 @@ return x_58; lean_object* _init_l_Lean_Parser_Command_reserve___closed__1() { _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_Command_reserve___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_reserve___closed__2() { @@ -8660,7 +8784,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Command_mixfix___closed__1; @@ -10197,11 +10321,10 @@ return x_143; lean_object* _init_l_Lean_Parser_Command_notation___closed__1() { _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_Command_notation___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_notation___closed__2() { @@ -10683,11 +10806,10 @@ return x_60; lean_object* _init_l_Lean_Parser_Command_macro__rules___closed__1() { _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_Command_macro__rules___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_macro__rules___closed__2() { @@ -11355,11 +11477,10 @@ return x_134; lean_object* _init_l_Lean_Parser_Command_syntax___closed__1() { _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_Command_syntax___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_syntax___closed__2() { @@ -11795,11 +11916,10 @@ return x_49; lean_object* _init_l_Lean_Parser_Command_syntaxCat___closed__1() { _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_Command_syntaxCat___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_syntaxCat___closed__2() { @@ -12505,7 +12625,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_precedence___closed__1; +x_3 = l_Lean_Parser_mkAntiquot___closed__5; x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); return x_4; } @@ -13811,7 +13931,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_Lean_Parser_antiquotNestedExpr___closed__4; +x_3 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } @@ -14297,7 +14417,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_Lean_Parser_antiquotNestedExpr___closed__4; +x_3 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } @@ -14316,7 +14436,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Command_macroTailDefault___closed__3; @@ -14998,11 +15118,10 @@ return x_75; lean_object* _init_l_Lean_Parser_Command_macro___closed__1() { _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_Command_macro___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Command_macro___closed__2() { @@ -15194,8 +15313,6 @@ l_Lean_Parser_precedence___closed__4 = _init_l_Lean_Parser_precedence___closed__ lean_mark_persistent(l_Lean_Parser_precedence___closed__4); l_Lean_Parser_precedence___closed__5 = _init_l_Lean_Parser_precedence___closed__5(); lean_mark_persistent(l_Lean_Parser_precedence___closed__5); -l_Lean_Parser_precedence___closed__6 = _init_l_Lean_Parser_precedence___closed__6(); -lean_mark_persistent(l_Lean_Parser_precedence___closed__6); l_Lean_Parser_precedence = _init_l_Lean_Parser_precedence(); lean_mark_persistent(l_Lean_Parser_precedence); l_Lean_Parser_optPrecedence___closed__1 = _init_l_Lean_Parser_optPrecedence___closed__1(); @@ -15230,6 +15347,8 @@ l_Lean_Parser_Syntax_paren___closed__6 = _init_l_Lean_Parser_Syntax_paren___clos lean_mark_persistent(l_Lean_Parser_Syntax_paren___closed__6); l_Lean_Parser_Syntax_paren___closed__7 = _init_l_Lean_Parser_Syntax_paren___closed__7(); lean_mark_persistent(l_Lean_Parser_Syntax_paren___closed__7); +l_Lean_Parser_Syntax_paren___closed__8 = _init_l_Lean_Parser_Syntax_paren___closed__8(); +lean_mark_persistent(l_Lean_Parser_Syntax_paren___closed__8); l_Lean_Parser_Syntax_paren = _init_l_Lean_Parser_Syntax_paren(); lean_mark_persistent(l_Lean_Parser_Syntax_paren); res = l___regBuiltinParser_Lean_Parser_Syntax_paren(lean_io_mk_world()); @@ -15253,6 +15372,8 @@ l_Lean_Parser_Syntax_cat___closed__4 = _init_l_Lean_Parser_Syntax_cat___closed__ lean_mark_persistent(l_Lean_Parser_Syntax_cat___closed__4); l_Lean_Parser_Syntax_cat___closed__5 = _init_l_Lean_Parser_Syntax_cat___closed__5(); lean_mark_persistent(l_Lean_Parser_Syntax_cat___closed__5); +l_Lean_Parser_Syntax_cat___closed__6 = _init_l_Lean_Parser_Syntax_cat___closed__6(); +lean_mark_persistent(l_Lean_Parser_Syntax_cat___closed__6); l_Lean_Parser_Syntax_cat = _init_l_Lean_Parser_Syntax_cat(); lean_mark_persistent(l_Lean_Parser_Syntax_cat); res = l___regBuiltinParser_Lean_Parser_Syntax_cat(lean_io_mk_world()); @@ -15276,6 +15397,8 @@ l_Lean_Parser_Syntax_atom___closed__4 = _init_l_Lean_Parser_Syntax_atom___closed lean_mark_persistent(l_Lean_Parser_Syntax_atom___closed__4); l_Lean_Parser_Syntax_atom___closed__5 = _init_l_Lean_Parser_Syntax_atom___closed__5(); lean_mark_persistent(l_Lean_Parser_Syntax_atom___closed__5); +l_Lean_Parser_Syntax_atom___closed__6 = _init_l_Lean_Parser_Syntax_atom___closed__6(); +lean_mark_persistent(l_Lean_Parser_Syntax_atom___closed__6); l_Lean_Parser_Syntax_atom = _init_l_Lean_Parser_Syntax_atom(); lean_mark_persistent(l_Lean_Parser_Syntax_atom); res = l___regBuiltinParser_Lean_Parser_Syntax_atom(lean_io_mk_world()); @@ -15535,8 +15658,6 @@ l_Lean_Parser_Syntax_optional___closed__2 = _init_l_Lean_Parser_Syntax_optional_ lean_mark_persistent(l_Lean_Parser_Syntax_optional___closed__2); l_Lean_Parser_Syntax_optional___closed__3 = _init_l_Lean_Parser_Syntax_optional___closed__3(); lean_mark_persistent(l_Lean_Parser_Syntax_optional___closed__3); -l_Lean_Parser_Syntax_optional___closed__4 = _init_l_Lean_Parser_Syntax_optional___closed__4(); -lean_mark_persistent(l_Lean_Parser_Syntax_optional___closed__4); l_Lean_Parser_Syntax_optional = _init_l_Lean_Parser_Syntax_optional(); lean_mark_persistent(l_Lean_Parser_Syntax_optional); res = l___regBuiltinParser_Lean_Parser_Syntax_optional(lean_io_mk_world()); @@ -15573,8 +15694,6 @@ l_Lean_Parser_Syntax_many1___closed__2 = _init_l_Lean_Parser_Syntax_many1___clos lean_mark_persistent(l_Lean_Parser_Syntax_many1___closed__2); l_Lean_Parser_Syntax_many1___closed__3 = _init_l_Lean_Parser_Syntax_many1___closed__3(); lean_mark_persistent(l_Lean_Parser_Syntax_many1___closed__3); -l_Lean_Parser_Syntax_many1___closed__4 = _init_l_Lean_Parser_Syntax_many1___closed__4(); -lean_mark_persistent(l_Lean_Parser_Syntax_many1___closed__4); l_Lean_Parser_Syntax_many1 = _init_l_Lean_Parser_Syntax_many1(); lean_mark_persistent(l_Lean_Parser_Syntax_many1); res = l___regBuiltinParser_Lean_Parser_Syntax_many1(lean_io_mk_world()); @@ -15592,6 +15711,8 @@ l_Lean_Parser_Syntax_orelse___closed__4 = _init_l_Lean_Parser_Syntax_orelse___cl lean_mark_persistent(l_Lean_Parser_Syntax_orelse___closed__4); l_Lean_Parser_Syntax_orelse___closed__5 = _init_l_Lean_Parser_Syntax_orelse___closed__5(); lean_mark_persistent(l_Lean_Parser_Syntax_orelse___closed__5); +l_Lean_Parser_Syntax_orelse___closed__6 = _init_l_Lean_Parser_Syntax_orelse___closed__6(); +lean_mark_persistent(l_Lean_Parser_Syntax_orelse___closed__6); l_Lean_Parser_Syntax_orelse = _init_l_Lean_Parser_Syntax_orelse(); lean_mark_persistent(l_Lean_Parser_Syntax_orelse); res = l___regBuiltinParser_Lean_Parser_Syntax_orelse(lean_io_mk_world()); diff --git a/stage0/stdlib/Lean/Parser/Tactic.c b/stage0/stdlib/Lean/Parser/Tactic.c index a37138ce1c..5d7ecbd608 100644 --- a/stage0/stdlib/Lean/Parser/Tactic.c +++ b/stage0/stdlib/Lean/Parser/Tactic.c @@ -92,7 +92,9 @@ lean_object* l_Lean_Parser_Tactic_induction___elambda__1(lean_object*, lean_obje lean_object* l_Lean_Parser_Tactic_failIfSuccess___closed__2; lean_object* l_Lean_Parser_Tactic_underscore___closed__1; lean_object* l_Lean_Parser_Tactic_usingRec___closed__2; +lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__7; lean_object* l_Lean_Parser_Tactic_skip___closed__2; +lean_object* l_Lean_Parser_checkRbpLtFn(lean_object*, lean_object*, lean_object*, lean_object*); 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_Tactic_allGoals___elambda__1___closed__6; @@ -182,6 +184,7 @@ lean_object* l_Lean_Parser_Tactic_assumption; lean_object* l_Lean_Parser_Tactic_intros___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_Tactic_cases___elambda__1___closed__1; lean_object* l_Lean_Parser_Tactic_subst___closed__2; +extern lean_object* l_Lean_Parser_Term_hole___closed__4; extern lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__5; lean_object* l_Lean_Parser_Tactic_generalizingVars___elambda__1___closed__3; lean_object* l_Lean_Parser_Tactic_usingRec___elambda__1___closed__4; @@ -226,12 +229,13 @@ lean_object* l_Lean_Parser_Tactic_case___elambda__1___closed__5; lean_object* l_Lean_Parser_nodeInfo(lean_object*, lean_object*); lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1___closed__5; lean_object* l_Lean_Parser_Tactic_assumption___closed__1; -lean_object* l_Lean_Parser_Tactic_generalize___closed__12; lean_object* l_Lean_Parser_Tactic_apply___closed__3; lean_object* l_Lean_Parser_Tactic_clear___closed__5; +extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__7; lean_object* lean_nat_sub(lean_object*, lean_object*); lean_object* l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__7(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__1; lean_object* l_Lean_Parser_Tactic_revert; lean_object* l_Lean_Parser_Tactic_generalize; lean_object* l_Lean_Parser_Tactic_failIfSuccess___closed__3; @@ -264,7 +268,6 @@ lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1___closed__7; lean_object* l_Lean_Parser_optionaInfo(lean_object*); lean_object* l_Lean_Parser_Tactic_cases___closed__2; lean_object* l_Lean_Parser_Tactic_generalize___elambda__1(lean_object*, lean_object*); -extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__4; lean_object* l_Lean_Parser_Tactic_induction___closed__7; lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Tactic_revert___closed__5; @@ -328,7 +331,6 @@ lean_object* l_Lean_Parser_Tactic_induction___elambda__1___closed__5; lean_object* l_Lean_Parser_Tactic_majorPremise___elambda__1___closed__2; lean_object* l_Lean_Parser_Tactic_exact___elambda__1___closed__5; lean_object* l_Lean_Parser_Tactic_injection___closed__3; -extern lean_object* l_Lean_Parser_Term_namedHole___closed__5; extern lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2; lean_object* l_Lean_Parser_Tactic_nestedTacticBlock; extern lean_object* l_Lean_Parser_Term_explicitUniv___closed__4; @@ -411,6 +413,7 @@ lean_object* l_Lean_Parser_Tactic_induction___elambda__1___closed__2; lean_object* l_Lean_Parser_Tactic_generalize___elambda__1___closed__8; lean_object* l___regBuiltinParser_Lean_Parser_Tactic_allGoals(lean_object*); lean_object* l_Lean_Parser_Tactic_induction___closed__6; +extern lean_object* l___private_Lean_Parser_Parser_10__precErrorMsg; lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Tactic_withAlts___elambda__1(lean_object*, lean_object*); lean_object* l___regBuiltinParser_Lean_Parser_Tactic_cases(lean_object*); @@ -435,12 +438,13 @@ lean_object* l_Lean_Parser_Tactic_generalizingVars___closed__1; lean_object* l_Lean_Parser_Tactic_generalizingVars; lean_object* l_Lean_Parser_Tactic_inductionAlt___closed__9; lean_object* l_Lean_Parser_Tactic_induction___closed__3; -lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolInfo(lean_object*); lean_object* l_Lean_Parser_Tactic_revert___elambda__1___closed__5; lean_object* l_Lean_Parser_Tactic_apply___elambda__1___closed__6; lean_object* l_Lean_Parser_Tactic_clear___elambda__1___closed__1; lean_object* l_Lean_Parser_Tactic_cases___elambda__1___closed__4; lean_object* l_Lean_Parser_Tactic_clear___elambda__1___closed__8; +extern lean_object* l_Lean_Parser_epsilonInfo; 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; @@ -498,12 +502,13 @@ lean_object* l_Lean_Parser_Tactic_exact___closed__2; lean_object* l_Lean_Parser_Tactic_intro___closed__2; lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__4(lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__17; +extern lean_object* l_Lean_Parser_Term_namedHole___closed__6; 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_Tactic_cases___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_Tactic_underscoreFn___closed__1; lean_object* l_Lean_Parser_Tactic_failIfSuccess___elambda__1___closed__4; lean_object* l_Lean_Parser_Tactic_assumption___elambda__1___closed__7; -extern lean_object* l_Lean_Parser_Term_hole___closed__3; lean_object* l_Lean_Parser_Tactic_failIfSuccess___elambda__1___closed__8; lean_object* l_Lean_Parser_Tactic_revert___elambda__1___closed__8; lean_object* l_Lean_Parser_Tactic_underscoreFn___closed__3; @@ -528,7 +533,6 @@ lean_object* l_Lean_Parser_Tactic_revert___elambda__1___closed__1; lean_object* l_Lean_Parser_Tactic_orelse___closed__6; lean_object* l_Lean_Parser_Tactic_intro___closed__5; lean_object* l_Lean_Parser_Tactic_generalize___elambda__1___closed__1; -extern lean_object* l_Lean_Syntax_decodeNatLitVal___closed__1; lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_inductionAlts___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_Tactic_exact___elambda__1___closed__7; lean_object* l___regBuiltinParser_Lean_Parser_Tactic_skip(lean_object*); @@ -579,6 +583,7 @@ lean_object* l_Lean_Parser_Tactic_induction___elambda__1___closed__3; lean_object* l_Lean_Parser_Tactic_case___elambda__1___closed__6; lean_object* l_Lean_Parser_Tactic_generalize___elambda__1___closed__2; lean_object* l_Lean_Parser_Tactic_traceState___elambda__1(lean_object*, lean_object*); +lean_object* l_Lean_Parser_Tactic_paren___closed__7; extern lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; lean_object* l_Lean_Parser_Tactic_allGoals___elambda__1___closed__4; uint8_t lean_string_dec_eq(lean_object*, lean_object*); @@ -3072,7 +3077,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Tactic_apply___closed__1; @@ -3358,7 +3363,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Tactic_exact___closed__1; @@ -3644,7 +3649,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Tactic_refine___closed__1; @@ -6304,51 +6309,50 @@ lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__3() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = lean_unsigned_to_nat(50u); -x_2 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_2, 0, x_1); +x_1 = l_Lean_Parser_Tactic_generalize___elambda__1___closed__6; +x_2 = l_Lean_Parser_symbolInfo(x_1); return x_2; } } lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__4() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Tactic_generalize___elambda__1___closed__6; -x_2 = l_Lean_Parser_Tactic_generalize___closed__3; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_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_generalize___closed__3; +x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); +return x_4; } } lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_ident; +x_1 = l_Lean_Parser_Tactic_generalize___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Tactic_generalize___closed__4; -x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); +x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } } lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__6() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Tactic_generalize___closed__2; -x_2 = lean_ctor_get(x_1, 0); -lean_inc(x_2); -x_3 = l_Lean_Parser_Tactic_generalize___closed__5; -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_optIdent___closed__2; +x_2 = l_Lean_Parser_Tactic_generalize___closed__5; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_optIdent___closed__2; +x_1 = l_Lean_Parser_Tactic_generalize___closed__1; x_2 = l_Lean_Parser_Tactic_generalize___closed__6; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; @@ -6358,35 +6362,25 @@ lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Tactic_generalize___closed__1; +x_1 = l_Lean_Parser_Tactic_generalize___elambda__1___closed__2; x_2 = l_Lean_Parser_Tactic_generalize___closed__7; -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_Tactic_generalize___closed__9() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Tactic_generalize___elambda__1___closed__2; -x_2 = l_Lean_Parser_Tactic_generalize___closed__8; -x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__10() { -_start: -{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Tactic_generalize___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Tactic_generalize___closed__9; +x_3 = l_Lean_Parser_Tactic_generalize___closed__8; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__11() { +lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__10() { _start: { lean_object* x_1; @@ -6394,12 +6388,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_generalize___elambda__1), return x_1; } } -lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__12() { +lean_object* _init_l_Lean_Parser_Tactic_generalize___closed__11() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Tactic_generalize___closed__10; -x_2 = l_Lean_Parser_Tactic_generalize___closed__11; +x_1 = l_Lean_Parser_Tactic_generalize___closed__9; +x_2 = l_Lean_Parser_Tactic_generalize___closed__10; x_3 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_3, 0, x_1); lean_ctor_set(x_3, 1, x_2); @@ -6410,7 +6404,7 @@ lean_object* _init_l_Lean_Parser_Tactic_generalize() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Tactic_generalize___closed__12; +x_1 = l_Lean_Parser_Tactic_generalize___closed__11; return x_1; } } @@ -7058,7 +7052,7 @@ lean_object* _init_l_Lean_Parser_Tactic_majorPremise___closed__1() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_optIdent___closed__2; @@ -7174,7 +7168,7 @@ lean_object* _init_l_Lean_Parser_Tactic_inductionAlt___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_namedHole___closed__5; +x_1 = l_Lean_Parser_Term_namedHole___closed__6; x_2 = l_Lean_Parser_Tactic_inductionAlt___closed__5; x_3 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn), 4, 2); lean_closure_set(x_3, 0, x_1); @@ -7198,7 +7192,7 @@ lean_object* _init_l_Lean_Parser_Tactic_inductionAlt___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_hole___closed__3; +x_1 = l_Lean_Parser_Term_hole___closed__4; x_2 = l_Lean_Parser_Tactic_inductionAlt___closed__6; x_3 = lean_alloc_closure((void*)(l_Lean_Parser_orelseFn), 4, 2); lean_closure_set(x_3, 0, x_1); @@ -9672,11 +9666,10 @@ return x_25; lean_object* _init_l_Lean_Parser_Tactic_usingRec___closed__1() { _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_Tactic_usingRec___elambda__1___closed__2; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Tactic_usingRec___closed__2() { @@ -9971,11 +9964,10 @@ return x_37; lean_object* _init_l_Lean_Parser_Tactic_generalizingVars___closed__1() { _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_Tactic_generalizingVars___elambda__1___closed__2; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Tactic_generalizingVars___closed__2() { @@ -11275,7 +11267,7 @@ lean_object* _init_l_Lean_Parser_Tactic_injection___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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Tactic_withIds; @@ -11400,377 +11392,410 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_39 = lean_ctor_get(x_2, 1); -lean_inc(x_39); -lean_inc(x_1); -x_40 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -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); -lean_dec(x_43); -x_45 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; -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_antiquotNestedExpr___elambda__1___closed__10; -x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_47, x_39); -x_8 = x_48; -goto block_38; -} -else -{ -lean_dec(x_39); -x_8 = x_40; -goto block_38; -} -} -else -{ -lean_object* x_49; lean_object* x_50; -lean_dec(x_43); -x_49 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_49, x_39); -x_8 = x_50; -goto block_38; -} -} -else -{ -lean_object* x_51; lean_object* x_52; -lean_dec(x_41); -x_51 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_51, x_39); -x_8 = x_52; -goto block_38; -} -block_38: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_43; lean_object* x_44; lean_object* x_45; +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_43 = lean_ctor_get(x_8, 1); +lean_inc(x_43); lean_inc(x_1); -x_10 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_8); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 0) +x_44 = l_Lean_Parser_tokenFn(x_1, x_8); +x_45 = lean_ctor_get(x_44, 3); +lean_inc(x_45); +if (lean_obj_tag(x_45) == 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_1, x_10); -x_14 = lean_ctor_get(x_13, 3); -lean_inc(x_14); -if (lean_obj_tag(x_14) == 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_15; lean_object* x_16; -x_15 = lean_ctor_get(x_13, 0); +lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_48 = lean_ctor_get(x_47, 1); +lean_inc(x_48); +lean_dec(x_47); +x_49 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; +x_50 = lean_string_dec_eq(x_48, x_49); +lean_dec(x_48); +if (x_50 == 0) +{ +lean_object* x_51; lean_object* x_52; +x_51 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_51, x_43); +x_12 = x_52; +goto block_42; +} +else +{ +lean_dec(x_43); +x_12 = x_44; +goto block_42; +} +} +else +{ +lean_object* x_53; lean_object* x_54; +lean_dec(x_47); +x_53 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_53, x_43); +x_12 = x_54; +goto block_42; +} +} +else +{ +lean_object* x_55; lean_object* x_56; +lean_dec(x_45); +x_55 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_55, x_43); +x_12 = x_56; +goto block_42; +} +block_42: +{ +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_inc(x_1); +x_14 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_12); +x_15 = lean_ctor_get(x_14, 3); lean_inc(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) +if (lean_obj_tag(x_15) == 0) { -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_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -x_19 = lean_string_dec_eq(x_17, x_18); -lean_dec(x_17); -if (x_19 == 0) +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +x_17 = l_Lean_Parser_tokenFn(x_1, 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_23; -x_20 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); -x_22 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_7); -return x_23; +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_checkStackTopFn___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_antiquotNestedExpr___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; +x_24 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); +x_26 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; +x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_11); +return x_27; } else { -lean_object* x_24; lean_object* x_25; -lean_dec(x_12); -x_24 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_25 = l_Lean_Parser_ParserState_mkNode(x_13, 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_28; lean_object* x_29; lean_dec(x_16); -x_26 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_17, x_28, x_11); return x_29; } } else { lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; -lean_dec(x_14); +lean_dec(x_20); x_30 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_30, x_16); x_32 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_7); +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); return x_33; } } else { -lean_object* x_34; lean_object* x_35; -lean_dec(x_11); -lean_dec(x_1); -x_34 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_35 = l_Lean_Parser_ParserState_mkNode(x_10, x_34, x_7); -return x_35; -} -} -else -{ -lean_object* x_36; lean_object* x_37; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_dec(x_18); +x_34 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_34, x_16); x_36 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_37 = l_Lean_Parser_ParserState_mkNode(x_8, x_36, x_7); +x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_11); return x_37; } } +else +{ +lean_object* x_38; lean_object* x_39; +lean_dec(x_15); +lean_dec(x_1); +x_38 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; +x_39 = l_Lean_Parser_ParserState_mkNode(x_14, x_38, x_11); +return x_39; +} } else { -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_2, 0); -lean_inc(x_53); -x_54 = lean_array_get_size(x_53); -lean_dec(x_53); -x_55 = lean_ctor_get(x_2, 1); -lean_inc(x_55); -lean_inc(x_1); -x_56 = lean_apply_2(x_4, x_1, x_2); -x_57 = lean_ctor_get(x_56, 3); +lean_object* x_40; lean_object* x_41; +lean_dec(x_13); +lean_dec(x_1); +x_40 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; +x_41 = l_Lean_Parser_ParserState_mkNode(x_12, x_40, x_11); +return x_41; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = lean_ctor_get(x_2, 0); lean_inc(x_57); -if (lean_obj_tag(x_57) == 0) -{ -lean_dec(x_55); -lean_dec(x_54); -lean_dec(x_1); -return x_56; -} -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); +x_58 = lean_array_get_size(x_57); lean_dec(x_57); -x_59 = lean_ctor_get(x_56, 1); +x_59 = lean_ctor_get(x_2, 1); lean_inc(x_59); -x_60 = lean_nat_dec_eq(x_59, x_55); -lean_dec(x_59); -if (x_60 == 0) +lean_inc(x_1); +x_60 = lean_apply_2(x_4, x_1, x_2); +x_61 = lean_ctor_get(x_60, 3); +lean_inc(x_61); +if (lean_obj_tag(x_61) == 0) { +lean_dec(x_59); lean_dec(x_58); -lean_dec(x_55); -lean_dec(x_54); lean_dec(x_1); -return x_56; +return x_60; } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_101; lean_object* x_102; -lean_inc(x_55); -x_61 = l_Lean_Parser_ParserState_restore(x_56, x_54, x_55); -lean_dec(x_54); +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_63 = lean_array_get_size(x_62); +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_59); +lean_dec(x_63); +if (x_64 == 0) +{ lean_dec(x_62); +lean_dec(x_59); +lean_dec(x_58); +lean_dec(x_1); +return x_60; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_inc(x_59); +x_65 = l_Lean_Parser_ParserState_restore(x_60, x_58, x_59); +lean_dec(x_58); +x_66 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_67 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_68 = l_Lean_Parser_checkRbpLtFn(x_66, x_67, 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; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_70 = lean_ctor_get(x_68, 0); +lean_inc(x_70); +x_71 = lean_array_get_size(x_70); +lean_dec(x_70); +x_109 = lean_ctor_get(x_68, 1); +lean_inc(x_109); lean_inc(x_1); -x_101 = l_Lean_Parser_tokenFn(x_1, x_61); -x_102 = lean_ctor_get(x_101, 3); -lean_inc(x_102); -if (lean_obj_tag(x_102) == 0) -{ -lean_object* x_103; lean_object* x_104; -x_103 = lean_ctor_get(x_101, 0); -lean_inc(x_103); -x_104 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_103); -lean_dec(x_103); -if (lean_obj_tag(x_104) == 2) -{ -lean_object* x_105; lean_object* x_106; uint8_t x_107; -x_105 = lean_ctor_get(x_104, 1); -lean_inc(x_105); -lean_dec(x_104); -x_106 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; -x_107 = lean_string_dec_eq(x_105, x_106); -lean_dec(x_105); -if (x_107 == 0) -{ -lean_object* x_108; lean_object* x_109; -x_108 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_55); -x_109 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_108, x_55); -x_64 = x_109; -goto block_100; -} -else -{ -x_64 = x_101; -goto block_100; -} -} -else -{ -lean_object* x_110; lean_object* x_111; -lean_dec(x_104); -x_110 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_55); -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_110, x_55); -x_64 = x_111; -goto block_100; -} -} -else +x_110 = l_Lean_Parser_tokenFn(x_1, x_68); +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_102); -x_112 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_55); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_112, x_55); -x_64 = x_113; -goto block_100; +x_112 = lean_ctor_get(x_110, 0); +lean_inc(x_112); +x_113 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_112); +lean_dec(x_112); +if (lean_obj_tag(x_113) == 2) +{ +lean_object* x_114; lean_object* x_115; uint8_t x_116; +x_114 = lean_ctor_get(x_113, 1); +lean_inc(x_114); +lean_dec(x_113); +x_115 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; +x_116 = lean_string_dec_eq(x_114, x_115); +lean_dec(x_114); +if (x_116 == 0) +{ +lean_object* x_117; lean_object* x_118; +x_117 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_118 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_117, x_109); +x_72 = x_118; +goto block_108; } -block_100: +else { -lean_object* x_65; -x_65 = lean_ctor_get(x_64, 3); -lean_inc(x_65); -if (lean_obj_tag(x_65) == 0) +lean_dec(x_109); +x_72 = x_110; +goto block_108; +} +} +else { -lean_object* x_66; lean_object* x_67; -lean_inc(x_1); -x_66 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_64); -x_67 = lean_ctor_get(x_66, 3); -lean_inc(x_67); -if (lean_obj_tag(x_67) == 0) +lean_object* x_119; lean_object* x_120; +lean_dec(x_113); +x_119 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_119, x_109); +x_72 = x_120; +goto block_108; +} +} +else { -lean_object* x_68; lean_object* x_69; lean_object* x_70; -x_68 = lean_ctor_get(x_66, 1); -lean_inc(x_68); -x_69 = l_Lean_Parser_tokenFn(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_121; lean_object* x_122; +lean_dec(x_111); +x_121 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_121, x_109); +x_72 = x_122; +goto block_108; +} +block_108: { -lean_object* x_71; lean_object* x_72; -x_71 = lean_ctor_get(x_69, 0); -lean_inc(x_71); -x_72 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_71); -lean_dec(x_71); -if (lean_obj_tag(x_72) == 2) -{ -lean_object* x_73; lean_object* x_74; uint8_t x_75; -x_73 = lean_ctor_get(x_72, 1); +lean_object* x_73; +x_73 = lean_ctor_get(x_72, 3); lean_inc(x_73); -lean_dec(x_72); -x_74 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -x_75 = lean_string_dec_eq(x_73, x_74); -lean_dec(x_73); -if (x_75 == 0) +if (lean_obj_tag(x_73) == 0) { -lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; -x_76 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_76, x_68); -x_78 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_79 = l_Lean_Parser_ParserState_mkNode(x_77, x_78, x_63); -x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_58, x_55); -lean_dec(x_55); -return x_80; -} -else +lean_object* x_74; lean_object* x_75; +lean_inc(x_1); +x_74 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_72); +x_75 = lean_ctor_get(x_74, 3); +lean_inc(x_75); +if (lean_obj_tag(x_75) == 0) { -lean_object* x_81; lean_object* x_82; lean_object* x_83; -lean_dec(x_68); -x_81 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_82 = l_Lean_Parser_ParserState_mkNode(x_69, x_81, x_63); -x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_58, x_55); -lean_dec(x_55); -return x_83; -} -} -else +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_74, 1); +lean_inc(x_76); +x_77 = l_Lean_Parser_tokenFn(x_1, x_74); +x_78 = lean_ctor_get(x_77, 3); +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_checkStackTopFn___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_antiquotNestedExpr___elambda__1___closed__4; +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; lean_object* x_86; lean_object* x_87; lean_object* x_88; -lean_dec(x_72); x_84 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_84, x_68); +x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_84, x_76); x_86 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_87 = l_Lean_Parser_ParserState_mkNode(x_85, x_86, x_63); -x_88 = l_Lean_Parser_mergeOrElseErrors(x_87, x_58, x_55); -lean_dec(x_55); +x_87 = l_Lean_Parser_ParserState_mkNode(x_85, x_86, x_71); +x_88 = l_Lean_Parser_mergeOrElseErrors(x_87, x_62, x_59); +lean_dec(x_59); return x_88; } -} else { -lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; -lean_dec(x_70); -x_89 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_90 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_89, x_68); -x_91 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_92 = l_Lean_Parser_ParserState_mkNode(x_90, x_91, x_63); -x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_58, x_55); -lean_dec(x_55); -return x_93; +lean_object* x_89; lean_object* x_90; lean_object* x_91; +lean_dec(x_76); +x_89 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; +x_90 = l_Lean_Parser_ParserState_mkNode(x_77, x_89, x_71); +x_91 = l_Lean_Parser_mergeOrElseErrors(x_90, x_62, x_59); +lean_dec(x_59); +return x_91; } } else { -lean_object* x_94; lean_object* x_95; lean_object* x_96; -lean_dec(x_67); -lean_dec(x_1); +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_80); +x_92 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_92, x_76); x_94 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_95 = l_Lean_Parser_ParserState_mkNode(x_66, x_94, x_63); -x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_58, x_55); -lean_dec(x_55); +x_95 = l_Lean_Parser_ParserState_mkNode(x_93, x_94, x_71); +x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_62, x_59); +lean_dec(x_59); return x_96; } } else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; -lean_dec(x_65); -lean_dec(x_1); -x_97 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; -x_98 = l_Lean_Parser_ParserState_mkNode(x_64, x_97, x_63); -x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_58, x_55); -lean_dec(x_55); -return x_99; +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +lean_dec(x_78); +x_97 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_98 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_97, x_76); +x_99 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; +x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_71); +x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_62, x_59); +lean_dec(x_59); +return x_101; } } +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +lean_dec(x_75); +lean_dec(x_1); +x_102 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; +x_103 = l_Lean_Parser_ParserState_mkNode(x_74, x_102, x_71); +x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_62, x_59); +lean_dec(x_59); +return x_104; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_73); +lean_dec(x_1); +x_105 = l_Lean_Parser_Tactic_paren___elambda__1___closed__1; +x_106 = l_Lean_Parser_ParserState_mkNode(x_72, x_105, x_71); +x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_62, x_59); +lean_dec(x_59); +return x_107; +} +} +} +else +{ +lean_object* x_123; +lean_dec(x_69); +lean_dec(x_1); +x_123 = l_Lean_Parser_mergeOrElseErrors(x_68, x_62, x_59); +lean_dec(x_59); +return x_123; +} } } } @@ -11783,7 +11808,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_Lean_Parser_antiquotNestedExpr___closed__4; +x_3 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } @@ -11792,7 +11817,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_Lean_Parser_antiquotNestedExpr___closed__2; +x_1 = l_Lean_Parser_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; @@ -11811,16 +11836,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Tactic_paren___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Tactic_paren___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Tactic_paren___closed__5() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Tactic_paren___elambda__1___closed__3; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Tactic_paren___closed__3; +x_3 = l_Lean_Parser_Tactic_paren___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Tactic_paren___closed__5() { +lean_object* _init_l_Lean_Parser_Tactic_paren___closed__6() { _start: { lean_object* x_1; @@ -11828,12 +11863,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_paren___elambda__1), 2, 0) return x_1; } } -lean_object* _init_l_Lean_Parser_Tactic_paren___closed__6() { +lean_object* _init_l_Lean_Parser_Tactic_paren___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Tactic_paren___closed__4; -x_2 = l_Lean_Parser_Tactic_paren___closed__5; +x_1 = l_Lean_Parser_Tactic_paren___closed__5; +x_2 = l_Lean_Parser_Tactic_paren___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); @@ -11844,7 +11879,7 @@ lean_object* _init_l_Lean_Parser_Tactic_paren() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Tactic_paren___closed__6; +x_1 = l_Lean_Parser_Tactic_paren___closed__7; return x_1; } } @@ -11911,377 +11946,410 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_39 = lean_ctor_get(x_2, 1); -lean_inc(x_39); -lean_inc(x_1); -x_40 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -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); -lean_dec(x_43); -x_45 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__6; -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_tacticBlock___elambda__1___closed__14; -x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_47, x_39); -x_8 = x_48; -goto block_38; -} -else -{ -lean_dec(x_39); -x_8 = x_40; -goto block_38; -} -} -else -{ -lean_object* x_49; lean_object* x_50; -lean_dec(x_43); -x_49 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_49, x_39); -x_8 = x_50; -goto block_38; -} -} -else -{ -lean_object* x_51; lean_object* x_52; -lean_dec(x_41); -x_51 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_51, x_39); -x_8 = x_52; -goto block_38; -} -block_38: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_43; lean_object* x_44; lean_object* x_45; +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_43 = lean_ctor_get(x_8, 1); +lean_inc(x_43); lean_inc(x_1); -x_10 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_8); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 0) +x_44 = l_Lean_Parser_tokenFn(x_1, x_8); +x_45 = lean_ctor_get(x_44, 3); +lean_inc(x_45); +if (lean_obj_tag(x_45) == 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_1, x_10); -x_14 = lean_ctor_get(x_13, 3); -lean_inc(x_14); -if (lean_obj_tag(x_14) == 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_15; lean_object* x_16; -x_15 = lean_ctor_get(x_13, 0); +lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_48 = lean_ctor_get(x_47, 1); +lean_inc(x_48); +lean_dec(x_47); +x_49 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__6; +x_50 = lean_string_dec_eq(x_48, x_49); +lean_dec(x_48); +if (x_50 == 0) +{ +lean_object* x_51; lean_object* x_52; +x_51 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_51, x_43); +x_12 = x_52; +goto block_42; +} +else +{ +lean_dec(x_43); +x_12 = x_44; +goto block_42; +} +} +else +{ +lean_object* x_53; lean_object* x_54; +lean_dec(x_47); +x_53 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_53, x_43); +x_12 = x_54; +goto block_42; +} +} +else +{ +lean_object* x_55; lean_object* x_56; +lean_dec(x_45); +x_55 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_55, x_43); +x_12 = x_56; +goto block_42; +} +block_42: +{ +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_inc(x_1); +x_14 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_12); +x_15 = lean_ctor_get(x_14, 3); lean_inc(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) +if (lean_obj_tag(x_15) == 0) { -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_Lean_Parser_Term_tacticBlock___elambda__1___closed__8; -x_19 = lean_string_dec_eq(x_17, x_18); -lean_dec(x_17); -if (x_19 == 0) +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +x_17 = l_Lean_Parser_tokenFn(x_1, 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_23; -x_20 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); -x_22 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_7); -return x_23; +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_checkStackTopFn___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_tacticBlock___elambda__1___closed__8; +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; +x_24 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; +x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); +x_26 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; +x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_11); +return x_27; } else { -lean_object* x_24; lean_object* x_25; -lean_dec(x_12); -x_24 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_13, 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_28; lean_object* x_29; lean_dec(x_16); -x_26 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_17, x_28, x_11); return x_29; } } else { lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; -lean_dec(x_14); +lean_dec(x_20); x_30 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_30, x_16); x_32 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_7); +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); return x_33; } } else { -lean_object* x_34; lean_object* x_35; -lean_dec(x_11); -lean_dec(x_1); -x_34 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_35 = l_Lean_Parser_ParserState_mkNode(x_10, x_34, x_7); -return x_35; -} -} -else -{ -lean_object* x_36; lean_object* x_37; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_dec(x_18); +x_34 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_34, x_16); x_36 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_37 = l_Lean_Parser_ParserState_mkNode(x_8, x_36, x_7); +x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_11); return x_37; } } +else +{ +lean_object* x_38; lean_object* x_39; +lean_dec(x_15); +lean_dec(x_1); +x_38 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; +x_39 = l_Lean_Parser_ParserState_mkNode(x_14, x_38, x_11); +return x_39; +} } else { -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_2, 0); -lean_inc(x_53); -x_54 = lean_array_get_size(x_53); -lean_dec(x_53); -x_55 = lean_ctor_get(x_2, 1); -lean_inc(x_55); -lean_inc(x_1); -x_56 = lean_apply_2(x_4, x_1, x_2); -x_57 = lean_ctor_get(x_56, 3); +lean_object* x_40; lean_object* x_41; +lean_dec(x_13); +lean_dec(x_1); +x_40 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; +x_41 = l_Lean_Parser_ParserState_mkNode(x_12, x_40, x_11); +return x_41; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = lean_ctor_get(x_2, 0); lean_inc(x_57); -if (lean_obj_tag(x_57) == 0) -{ -lean_dec(x_55); -lean_dec(x_54); -lean_dec(x_1); -return x_56; -} -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); +x_58 = lean_array_get_size(x_57); lean_dec(x_57); -x_59 = lean_ctor_get(x_56, 1); +x_59 = lean_ctor_get(x_2, 1); lean_inc(x_59); -x_60 = lean_nat_dec_eq(x_59, x_55); -lean_dec(x_59); -if (x_60 == 0) +lean_inc(x_1); +x_60 = lean_apply_2(x_4, x_1, x_2); +x_61 = lean_ctor_get(x_60, 3); +lean_inc(x_61); +if (lean_obj_tag(x_61) == 0) { +lean_dec(x_59); lean_dec(x_58); -lean_dec(x_55); -lean_dec(x_54); lean_dec(x_1); -return x_56; +return x_60; } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_101; lean_object* x_102; -lean_inc(x_55); -x_61 = l_Lean_Parser_ParserState_restore(x_56, x_54, x_55); -lean_dec(x_54); +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_63 = lean_array_get_size(x_62); +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_59); +lean_dec(x_63); +if (x_64 == 0) +{ lean_dec(x_62); +lean_dec(x_59); +lean_dec(x_58); +lean_dec(x_1); +return x_60; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_inc(x_59); +x_65 = l_Lean_Parser_ParserState_restore(x_60, x_58, x_59); +lean_dec(x_58); +x_66 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_67 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_68 = l_Lean_Parser_checkRbpLtFn(x_66, x_67, 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; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_70 = lean_ctor_get(x_68, 0); +lean_inc(x_70); +x_71 = lean_array_get_size(x_70); +lean_dec(x_70); +x_109 = lean_ctor_get(x_68, 1); +lean_inc(x_109); lean_inc(x_1); -x_101 = l_Lean_Parser_tokenFn(x_1, x_61); -x_102 = lean_ctor_get(x_101, 3); -lean_inc(x_102); -if (lean_obj_tag(x_102) == 0) -{ -lean_object* x_103; lean_object* x_104; -x_103 = lean_ctor_get(x_101, 0); -lean_inc(x_103); -x_104 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_103); -lean_dec(x_103); -if (lean_obj_tag(x_104) == 2) -{ -lean_object* x_105; lean_object* x_106; uint8_t x_107; -x_105 = lean_ctor_get(x_104, 1); -lean_inc(x_105); -lean_dec(x_104); -x_106 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__6; -x_107 = lean_string_dec_eq(x_105, x_106); -lean_dec(x_105); -if (x_107 == 0) -{ -lean_object* x_108; lean_object* x_109; -x_108 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -lean_inc(x_55); -x_109 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_108, x_55); -x_64 = x_109; -goto block_100; -} -else -{ -x_64 = x_101; -goto block_100; -} -} -else -{ -lean_object* x_110; lean_object* x_111; -lean_dec(x_104); -x_110 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -lean_inc(x_55); -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_110, x_55); -x_64 = x_111; -goto block_100; -} -} -else +x_110 = l_Lean_Parser_tokenFn(x_1, x_68); +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_102); -x_112 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -lean_inc(x_55); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_112, x_55); -x_64 = x_113; -goto block_100; +x_112 = lean_ctor_get(x_110, 0); +lean_inc(x_112); +x_113 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_112); +lean_dec(x_112); +if (lean_obj_tag(x_113) == 2) +{ +lean_object* x_114; lean_object* x_115; uint8_t x_116; +x_114 = lean_ctor_get(x_113, 1); +lean_inc(x_114); +lean_dec(x_113); +x_115 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__6; +x_116 = lean_string_dec_eq(x_114, x_115); +lean_dec(x_114); +if (x_116 == 0) +{ +lean_object* x_117; lean_object* x_118; +x_117 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_118 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_117, x_109); +x_72 = x_118; +goto block_108; } -block_100: +else { -lean_object* x_65; -x_65 = lean_ctor_get(x_64, 3); -lean_inc(x_65); -if (lean_obj_tag(x_65) == 0) +lean_dec(x_109); +x_72 = x_110; +goto block_108; +} +} +else { -lean_object* x_66; lean_object* x_67; -lean_inc(x_1); -x_66 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_64); -x_67 = lean_ctor_get(x_66, 3); -lean_inc(x_67); -if (lean_obj_tag(x_67) == 0) +lean_object* x_119; lean_object* x_120; +lean_dec(x_113); +x_119 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_119, x_109); +x_72 = x_120; +goto block_108; +} +} +else { -lean_object* x_68; lean_object* x_69; lean_object* x_70; -x_68 = lean_ctor_get(x_66, 1); -lean_inc(x_68); -x_69 = l_Lean_Parser_tokenFn(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_121; lean_object* x_122; +lean_dec(x_111); +x_121 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_121, x_109); +x_72 = x_122; +goto block_108; +} +block_108: { -lean_object* x_71; lean_object* x_72; -x_71 = lean_ctor_get(x_69, 0); -lean_inc(x_71); -x_72 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_71); -lean_dec(x_71); -if (lean_obj_tag(x_72) == 2) -{ -lean_object* x_73; lean_object* x_74; uint8_t x_75; -x_73 = lean_ctor_get(x_72, 1); +lean_object* x_73; +x_73 = lean_ctor_get(x_72, 3); lean_inc(x_73); -lean_dec(x_72); -x_74 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__8; -x_75 = lean_string_dec_eq(x_73, x_74); -lean_dec(x_73); -if (x_75 == 0) +if (lean_obj_tag(x_73) == 0) { -lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; -x_76 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_76, x_68); -x_78 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_79 = l_Lean_Parser_ParserState_mkNode(x_77, x_78, x_63); -x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_58, x_55); -lean_dec(x_55); -return x_80; -} -else +lean_object* x_74; lean_object* x_75; +lean_inc(x_1); +x_74 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_72); +x_75 = lean_ctor_get(x_74, 3); +lean_inc(x_75); +if (lean_obj_tag(x_75) == 0) { -lean_object* x_81; lean_object* x_82; lean_object* x_83; -lean_dec(x_68); -x_81 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_82 = l_Lean_Parser_ParserState_mkNode(x_69, x_81, x_63); -x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_58, x_55); -lean_dec(x_55); -return x_83; -} -} -else +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_74, 1); +lean_inc(x_76); +x_77 = l_Lean_Parser_tokenFn(x_1, x_74); +x_78 = lean_ctor_get(x_77, 3); +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_checkStackTopFn___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_Term_tacticBlock___elambda__1___closed__8; +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; lean_object* x_86; lean_object* x_87; lean_object* x_88; -lean_dec(x_72); x_84 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_84, x_68); +x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_84, x_76); x_86 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_87 = l_Lean_Parser_ParserState_mkNode(x_85, x_86, x_63); -x_88 = l_Lean_Parser_mergeOrElseErrors(x_87, x_58, x_55); -lean_dec(x_55); +x_87 = l_Lean_Parser_ParserState_mkNode(x_85, x_86, x_71); +x_88 = l_Lean_Parser_mergeOrElseErrors(x_87, x_62, x_59); +lean_dec(x_59); return x_88; } -} else { -lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; -lean_dec(x_70); -x_89 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_90 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_89, x_68); -x_91 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_92 = l_Lean_Parser_ParserState_mkNode(x_90, x_91, x_63); -x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_58, x_55); -lean_dec(x_55); -return x_93; +lean_object* x_89; lean_object* x_90; lean_object* x_91; +lean_dec(x_76); +x_89 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; +x_90 = l_Lean_Parser_ParserState_mkNode(x_77, x_89, x_71); +x_91 = l_Lean_Parser_mergeOrElseErrors(x_90, x_62, x_59); +lean_dec(x_59); +return x_91; } } else { -lean_object* x_94; lean_object* x_95; lean_object* x_96; -lean_dec(x_67); -lean_dec(x_1); +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_80); +x_92 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; +x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_92, x_76); x_94 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_95 = l_Lean_Parser_ParserState_mkNode(x_66, x_94, x_63); -x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_58, x_55); -lean_dec(x_55); +x_95 = l_Lean_Parser_ParserState_mkNode(x_93, x_94, x_71); +x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_62, x_59); +lean_dec(x_59); return x_96; } } else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; -lean_dec(x_65); -lean_dec(x_1); -x_97 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; -x_98 = l_Lean_Parser_ParserState_mkNode(x_64, x_97, x_63); -x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_58, x_55); -lean_dec(x_55); -return x_99; +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +lean_dec(x_78); +x_97 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; +x_98 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_97, x_76); +x_99 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; +x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_71); +x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_62, x_59); +lean_dec(x_59); +return x_101; } } +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +lean_dec(x_75); +lean_dec(x_1); +x_102 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; +x_103 = l_Lean_Parser_ParserState_mkNode(x_74, x_102, x_71); +x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_62, x_59); +lean_dec(x_59); +return x_104; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_73); +lean_dec(x_1); +x_105 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__2; +x_106 = l_Lean_Parser_ParserState_mkNode(x_72, x_105, x_71); +x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_62, x_59); +lean_dec(x_59); +return x_107; +} +} +} +else +{ +lean_object* x_123; +lean_dec(x_69); +lean_dec(x_1); +x_123 = l_Lean_Parser_mergeOrElseErrors(x_68, x_62, x_59); +lean_dec(x_59); +return x_123; +} } } } @@ -12300,16 +12368,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock___closed__2() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Tactic_nestedTacticBlock___closed__1; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock___closed__3() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Tactic_nestedTacticBlock___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Tactic_nestedTacticBlock___closed__1; +x_3 = l_Lean_Parser_Tactic_nestedTacticBlock___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock___closed__3() { +lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock___closed__4() { _start: { lean_object* x_1; @@ -12317,12 +12395,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_nestedTacticBlock___elambd return x_1; } } -lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock___closed__4() { +lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Tactic_nestedTacticBlock___closed__2; -x_2 = l_Lean_Parser_Tactic_nestedTacticBlock___closed__3; +x_1 = l_Lean_Parser_Tactic_nestedTacticBlock___closed__3; +x_2 = l_Lean_Parser_Tactic_nestedTacticBlock___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); @@ -12333,7 +12411,7 @@ lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlock() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Tactic_nestedTacticBlock___closed__4; +x_1 = l_Lean_Parser_Tactic_nestedTacticBlock___closed__5; return x_1; } } @@ -12400,377 +12478,410 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_39 = lean_ctor_get(x_2, 1); -lean_inc(x_39); -lean_inc(x_1); -x_40 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -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); -lean_dec(x_43); -x_45 = l_Lean_Parser_Term_structInst___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_structInst___elambda__1___closed__17; -x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_47, x_39); -x_8 = x_48; -goto block_38; -} -else -{ -lean_dec(x_39); -x_8 = x_40; -goto block_38; -} -} -else -{ -lean_object* x_49; lean_object* x_50; -lean_dec(x_43); -x_49 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_49, x_39); -x_8 = x_50; -goto block_38; -} -} -else -{ -lean_object* x_51; lean_object* x_52; -lean_dec(x_41); -x_51 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_51, x_39); -x_8 = x_52; -goto block_38; -} -block_38: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_43; lean_object* x_44; lean_object* x_45; +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_43 = lean_ctor_get(x_8, 1); +lean_inc(x_43); lean_inc(x_1); -x_10 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_8); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 0) +x_44 = l_Lean_Parser_tokenFn(x_1, x_8); +x_45 = lean_ctor_get(x_44, 3); +lean_inc(x_45); +if (lean_obj_tag(x_45) == 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_1, x_10); -x_14 = lean_ctor_get(x_13, 3); -lean_inc(x_14); -if (lean_obj_tag(x_14) == 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_15; lean_object* x_16; -x_15 = lean_ctor_get(x_13, 0); +lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_48 = lean_ctor_get(x_47, 1); +lean_inc(x_48); +lean_dec(x_47); +x_49 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; +x_50 = lean_string_dec_eq(x_48, x_49); +lean_dec(x_48); +if (x_50 == 0) +{ +lean_object* x_51; lean_object* x_52; +x_51 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_51, x_43); +x_12 = x_52; +goto block_42; +} +else +{ +lean_dec(x_43); +x_12 = x_44; +goto block_42; +} +} +else +{ +lean_object* x_53; lean_object* x_54; +lean_dec(x_47); +x_53 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_53, x_43); +x_12 = x_54; +goto block_42; +} +} +else +{ +lean_object* x_55; lean_object* x_56; +lean_dec(x_45); +x_55 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_55, x_43); +x_12 = x_56; +goto block_42; +} +block_42: +{ +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_inc(x_1); +x_14 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_12); +x_15 = lean_ctor_get(x_14, 3); lean_inc(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) +if (lean_obj_tag(x_15) == 0) { -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_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; -x_19 = lean_string_dec_eq(x_17, x_18); -lean_dec(x_17); -if (x_19 == 0) +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +x_17 = l_Lean_Parser_tokenFn(x_1, 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_23; -x_20 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); -x_22 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_7); -return x_23; +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_checkStackTopFn___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_explicitUniv___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; +x_24 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); +x_26 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; +x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_11); +return x_27; } else { -lean_object* x_24; lean_object* x_25; -lean_dec(x_12); -x_24 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_13, 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_28; lean_object* x_29; lean_dec(x_16); -x_26 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_17, x_28, x_11); return x_29; } } else { lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; -lean_dec(x_14); +lean_dec(x_20); x_30 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_30, x_16); x_32 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_7); +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); return x_33; } } else { -lean_object* x_34; lean_object* x_35; -lean_dec(x_11); -lean_dec(x_1); -x_34 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_35 = l_Lean_Parser_ParserState_mkNode(x_10, x_34, x_7); -return x_35; -} -} -else -{ -lean_object* x_36; lean_object* x_37; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_dec(x_18); +x_34 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_34, x_16); x_36 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_37 = l_Lean_Parser_ParserState_mkNode(x_8, x_36, x_7); +x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_11); return x_37; } } +else +{ +lean_object* x_38; lean_object* x_39; +lean_dec(x_15); +lean_dec(x_1); +x_38 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; +x_39 = l_Lean_Parser_ParserState_mkNode(x_14, x_38, x_11); +return x_39; +} } else { -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_2, 0); -lean_inc(x_53); -x_54 = lean_array_get_size(x_53); -lean_dec(x_53); -x_55 = lean_ctor_get(x_2, 1); -lean_inc(x_55); -lean_inc(x_1); -x_56 = lean_apply_2(x_4, x_1, x_2); -x_57 = lean_ctor_get(x_56, 3); +lean_object* x_40; lean_object* x_41; +lean_dec(x_13); +lean_dec(x_1); +x_40 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; +x_41 = l_Lean_Parser_ParserState_mkNode(x_12, x_40, x_11); +return x_41; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = lean_ctor_get(x_2, 0); lean_inc(x_57); -if (lean_obj_tag(x_57) == 0) -{ -lean_dec(x_55); -lean_dec(x_54); -lean_dec(x_1); -return x_56; -} -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); +x_58 = lean_array_get_size(x_57); lean_dec(x_57); -x_59 = lean_ctor_get(x_56, 1); +x_59 = lean_ctor_get(x_2, 1); lean_inc(x_59); -x_60 = lean_nat_dec_eq(x_59, x_55); -lean_dec(x_59); -if (x_60 == 0) +lean_inc(x_1); +x_60 = lean_apply_2(x_4, x_1, x_2); +x_61 = lean_ctor_get(x_60, 3); +lean_inc(x_61); +if (lean_obj_tag(x_61) == 0) { +lean_dec(x_59); lean_dec(x_58); -lean_dec(x_55); -lean_dec(x_54); lean_dec(x_1); -return x_56; +return x_60; } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_101; lean_object* x_102; -lean_inc(x_55); -x_61 = l_Lean_Parser_ParserState_restore(x_56, x_54, x_55); -lean_dec(x_54); +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_63 = lean_array_get_size(x_62); +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_59); +lean_dec(x_63); +if (x_64 == 0) +{ lean_dec(x_62); +lean_dec(x_59); +lean_dec(x_58); +lean_dec(x_1); +return x_60; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_inc(x_59); +x_65 = l_Lean_Parser_ParserState_restore(x_60, x_58, x_59); +lean_dec(x_58); +x_66 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_67 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_68 = l_Lean_Parser_checkRbpLtFn(x_66, x_67, 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; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_70 = lean_ctor_get(x_68, 0); +lean_inc(x_70); +x_71 = lean_array_get_size(x_70); +lean_dec(x_70); +x_109 = lean_ctor_get(x_68, 1); +lean_inc(x_109); lean_inc(x_1); -x_101 = l_Lean_Parser_tokenFn(x_1, x_61); -x_102 = lean_ctor_get(x_101, 3); -lean_inc(x_102); -if (lean_obj_tag(x_102) == 0) -{ -lean_object* x_103; lean_object* x_104; -x_103 = lean_ctor_get(x_101, 0); -lean_inc(x_103); -x_104 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_103); -lean_dec(x_103); -if (lean_obj_tag(x_104) == 2) -{ -lean_object* x_105; lean_object* x_106; uint8_t x_107; -x_105 = lean_ctor_get(x_104, 1); -lean_inc(x_105); -lean_dec(x_104); -x_106 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; -x_107 = lean_string_dec_eq(x_105, x_106); -lean_dec(x_105); -if (x_107 == 0) -{ -lean_object* x_108; lean_object* x_109; -x_108 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_55); -x_109 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_108, x_55); -x_64 = x_109; -goto block_100; -} -else -{ -x_64 = x_101; -goto block_100; -} -} -else -{ -lean_object* x_110; lean_object* x_111; -lean_dec(x_104); -x_110 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_55); -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_110, x_55); -x_64 = x_111; -goto block_100; -} -} -else +x_110 = l_Lean_Parser_tokenFn(x_1, x_68); +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_102); -x_112 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_55); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_112, x_55); -x_64 = x_113; -goto block_100; +x_112 = lean_ctor_get(x_110, 0); +lean_inc(x_112); +x_113 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_112); +lean_dec(x_112); +if (lean_obj_tag(x_113) == 2) +{ +lean_object* x_114; lean_object* x_115; uint8_t x_116; +x_114 = lean_ctor_get(x_113, 1); +lean_inc(x_114); +lean_dec(x_113); +x_115 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; +x_116 = lean_string_dec_eq(x_114, x_115); +lean_dec(x_114); +if (x_116 == 0) +{ +lean_object* x_117; lean_object* x_118; +x_117 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_118 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_117, x_109); +x_72 = x_118; +goto block_108; } -block_100: +else { -lean_object* x_65; -x_65 = lean_ctor_get(x_64, 3); -lean_inc(x_65); -if (lean_obj_tag(x_65) == 0) +lean_dec(x_109); +x_72 = x_110; +goto block_108; +} +} +else { -lean_object* x_66; lean_object* x_67; -lean_inc(x_1); -x_66 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_64); -x_67 = lean_ctor_get(x_66, 3); -lean_inc(x_67); -if (lean_obj_tag(x_67) == 0) +lean_object* x_119; lean_object* x_120; +lean_dec(x_113); +x_119 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_119, x_109); +x_72 = x_120; +goto block_108; +} +} +else { -lean_object* x_68; lean_object* x_69; lean_object* x_70; -x_68 = lean_ctor_get(x_66, 1); -lean_inc(x_68); -x_69 = l_Lean_Parser_tokenFn(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_121; lean_object* x_122; +lean_dec(x_111); +x_121 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_121, x_109); +x_72 = x_122; +goto block_108; +} +block_108: { -lean_object* x_71; lean_object* x_72; -x_71 = lean_ctor_get(x_69, 0); -lean_inc(x_71); -x_72 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_71); -lean_dec(x_71); -if (lean_obj_tag(x_72) == 2) -{ -lean_object* x_73; lean_object* x_74; uint8_t x_75; -x_73 = lean_ctor_get(x_72, 1); +lean_object* x_73; +x_73 = lean_ctor_get(x_72, 3); lean_inc(x_73); -lean_dec(x_72); -x_74 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; -x_75 = lean_string_dec_eq(x_73, x_74); -lean_dec(x_73); -if (x_75 == 0) +if (lean_obj_tag(x_73) == 0) { -lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; -x_76 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_76, x_68); -x_78 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_79 = l_Lean_Parser_ParserState_mkNode(x_77, x_78, x_63); -x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_58, x_55); -lean_dec(x_55); -return x_80; -} -else +lean_object* x_74; lean_object* x_75; +lean_inc(x_1); +x_74 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_72); +x_75 = lean_ctor_get(x_74, 3); +lean_inc(x_75); +if (lean_obj_tag(x_75) == 0) { -lean_object* x_81; lean_object* x_82; lean_object* x_83; -lean_dec(x_68); -x_81 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_82 = l_Lean_Parser_ParserState_mkNode(x_69, x_81, x_63); -x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_58, x_55); -lean_dec(x_55); -return x_83; -} -} -else +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_74, 1); +lean_inc(x_76); +x_77 = l_Lean_Parser_tokenFn(x_1, x_74); +x_78 = lean_ctor_get(x_77, 3); +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_checkStackTopFn___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_Term_explicitUniv___elambda__1___closed__7; +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; lean_object* x_86; lean_object* x_87; lean_object* x_88; -lean_dec(x_72); x_84 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_84, x_68); +x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_84, x_76); x_86 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_87 = l_Lean_Parser_ParserState_mkNode(x_85, x_86, x_63); -x_88 = l_Lean_Parser_mergeOrElseErrors(x_87, x_58, x_55); -lean_dec(x_55); +x_87 = l_Lean_Parser_ParserState_mkNode(x_85, x_86, x_71); +x_88 = l_Lean_Parser_mergeOrElseErrors(x_87, x_62, x_59); +lean_dec(x_59); return x_88; } -} else { -lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; -lean_dec(x_70); -x_89 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_90 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_89, x_68); -x_91 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_92 = l_Lean_Parser_ParserState_mkNode(x_90, x_91, x_63); -x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_58, x_55); -lean_dec(x_55); -return x_93; +lean_object* x_89; lean_object* x_90; lean_object* x_91; +lean_dec(x_76); +x_89 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; +x_90 = l_Lean_Parser_ParserState_mkNode(x_77, x_89, x_71); +x_91 = l_Lean_Parser_mergeOrElseErrors(x_90, x_62, x_59); +lean_dec(x_59); +return x_91; } } else { -lean_object* x_94; lean_object* x_95; lean_object* x_96; -lean_dec(x_67); -lean_dec(x_1); +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_80); +x_92 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_92, x_76); x_94 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_95 = l_Lean_Parser_ParserState_mkNode(x_66, x_94, x_63); -x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_58, x_55); -lean_dec(x_55); +x_95 = l_Lean_Parser_ParserState_mkNode(x_93, x_94, x_71); +x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_62, x_59); +lean_dec(x_59); return x_96; } } else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; -lean_dec(x_65); -lean_dec(x_1); -x_97 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; -x_98 = l_Lean_Parser_ParserState_mkNode(x_64, x_97, x_63); -x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_58, x_55); -lean_dec(x_55); -return x_99; +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +lean_dec(x_78); +x_97 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_98 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_97, x_76); +x_99 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; +x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_71); +x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_62, x_59); +lean_dec(x_59); +return x_101; } } +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +lean_dec(x_75); +lean_dec(x_1); +x_102 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; +x_103 = l_Lean_Parser_ParserState_mkNode(x_74, x_102, x_71); +x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_62, x_59); +lean_dec(x_59); +return x_104; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_73); +lean_dec(x_1); +x_105 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__2; +x_106 = l_Lean_Parser_ParserState_mkNode(x_72, x_105, x_71); +x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_62, x_59); +lean_dec(x_59); +return x_107; +} +} +} +else +{ +lean_object* x_123; +lean_dec(x_69); +lean_dec(x_1); +x_123 = l_Lean_Parser_mergeOrElseErrors(x_68, x_62, x_59); +lean_dec(x_59); +return x_123; +} } } } @@ -12811,16 +12922,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__5() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__3; +x_3 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__5() { +lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__6() { _start: { lean_object* x_1; @@ -12828,12 +12949,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Tactic_nestedTacticBlockCurly___e return x_1; } } -lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__6() { +lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__4; -x_2 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__5; +x_1 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__5; +x_2 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___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); @@ -12844,7 +12965,7 @@ lean_object* _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__6; +x_1 = l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__7; return x_1; } } @@ -12914,93 +13035,108 @@ return x_3; 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; -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_15 = lean_ctor_get(x_2, 1); -lean_inc(x_15); -lean_inc(x_1); -x_16 = l_Lean_Parser_tokenFn(x_1, x_2); -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); -x_19 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_18); -lean_dec(x_18); -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_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___closed__5; -x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_15); -x_5 = x_24; -goto block_14; -} -else -{ -lean_dec(x_15); -x_5 = x_16; -goto block_14; -} -} -else -{ -lean_object* x_25; lean_object* x_26; -lean_dec(x_19); -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; -} -} -else -{ -lean_object* x_27; lean_object* x_28; -lean_dec(x_17); -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; -} -block_14: -{ -lean_object* x_6; +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = lean_unsigned_to_nat(2u); +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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) { -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_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; +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_19; lean_object* x_20; lean_object* x_21; +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_19 = lean_ctor_get(x_5, 1); +lean_inc(x_19); +lean_inc(x_1); +x_20 = l_Lean_Parser_tokenFn(x_1, x_5); +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; +x_22 = lean_ctor_get(x_20, 0); +lean_inc(x_22); +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); +lean_dec(x_23); +x_25 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__2; +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; +x_27 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5; +x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_27, x_19); +x_9 = x_28; +goto block_18; +} +else +{ +lean_dec(x_19); +x_9 = x_20; +goto block_18; +} +} +else +{ +lean_object* x_29; lean_object* x_30; +lean_dec(x_23); +x_29 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5; +x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_29, x_19); +x_9 = x_30; +goto block_18; +} +} +else +{ +lean_object* x_31; lean_object* x_32; +lean_dec(x_21); +x_31 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__5; +x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_20, x_31, x_19); +x_9 = x_32; +goto block_18; +} +block_18: +{ +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_object* x_13; lean_object* x_14; lean_object* x_15; +x_11 = l_Lean_Parser_regBuiltinTacticParserAttr___closed__4; +x_12 = lean_unsigned_to_nat(1u); +x_13 = l_Lean_Parser_categoryParser___elambda__1(x_11, x_12, x_1, x_9); +x_14 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__1; +x_15 = l_Lean_Parser_ParserState_mkTrailingNode(x_13, x_14, x_8); +lean_dec(x_8); +return x_15; +} +else +{ +lean_object* x_16; lean_object* x_17; +lean_dec(x_10); +lean_dec(x_1); +x_16 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__1; +x_17 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_16, x_8); +lean_dec(x_8); +return x_17; +} +} } 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___closed__1; -x_13 = l_Lean_Parser_ParserState_mkTrailingNode(x_5, x_12, x_4); -lean_dec(x_4); -return x_13; -} +return x_5; } } } @@ -13008,9 +13144,8 @@ lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__1() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = lean_unsigned_to_nat(2u); -x_2 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_2, 0, x_1); +x_1 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__2; +x_2 = l_Lean_Parser_symbolInfo(x_1); return x_2; } } @@ -13018,41 +13153,41 @@ lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__2; -x_2 = l_Lean_Parser_Tactic_orelse___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__3() { -_start: -{ -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__4() { +lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Tactic_orelse___closed__3; +x_1 = l_Lean_Parser_Tactic_orelse___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Tactic_orelse___closed__2; +x_3 = l_Lean_Parser_Tactic_orelse___closed__1; x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); return x_4; } } +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___closed__1; +x_2 = l_Lean_Parser_Tactic_orelse___closed__3; +x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); +return x_3; +} +} lean_object* _init_l_Lean_Parser_Tactic_orelse___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Tactic_orelse___elambda__1___closed__1; +x_1 = l_Lean_Parser_epsilonInfo; x_2 = l_Lean_Parser_Tactic_orelse___closed__4; -x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } } @@ -13625,8 +13760,6 @@ l_Lean_Parser_Tactic_generalize___closed__10 = _init_l_Lean_Parser_Tactic_genera lean_mark_persistent(l_Lean_Parser_Tactic_generalize___closed__10); l_Lean_Parser_Tactic_generalize___closed__11 = _init_l_Lean_Parser_Tactic_generalize___closed__11(); lean_mark_persistent(l_Lean_Parser_Tactic_generalize___closed__11); -l_Lean_Parser_Tactic_generalize___closed__12 = _init_l_Lean_Parser_Tactic_generalize___closed__12(); -lean_mark_persistent(l_Lean_Parser_Tactic_generalize___closed__12); l_Lean_Parser_Tactic_generalize = _init_l_Lean_Parser_Tactic_generalize(); lean_mark_persistent(l_Lean_Parser_Tactic_generalize); res = l___regBuiltinParser_Lean_Parser_Tactic_generalize(lean_io_mk_world()); @@ -13889,6 +14022,8 @@ l_Lean_Parser_Tactic_paren___closed__5 = _init_l_Lean_Parser_Tactic_paren___clos lean_mark_persistent(l_Lean_Parser_Tactic_paren___closed__5); l_Lean_Parser_Tactic_paren___closed__6 = _init_l_Lean_Parser_Tactic_paren___closed__6(); lean_mark_persistent(l_Lean_Parser_Tactic_paren___closed__6); +l_Lean_Parser_Tactic_paren___closed__7 = _init_l_Lean_Parser_Tactic_paren___closed__7(); +lean_mark_persistent(l_Lean_Parser_Tactic_paren___closed__7); l_Lean_Parser_Tactic_paren = _init_l_Lean_Parser_Tactic_paren(); lean_mark_persistent(l_Lean_Parser_Tactic_paren); res = l___regBuiltinParser_Lean_Parser_Tactic_paren(lean_io_mk_world()); @@ -13910,6 +14045,8 @@ l_Lean_Parser_Tactic_nestedTacticBlock___closed__3 = _init_l_Lean_Parser_Tactic_ lean_mark_persistent(l_Lean_Parser_Tactic_nestedTacticBlock___closed__3); l_Lean_Parser_Tactic_nestedTacticBlock___closed__4 = _init_l_Lean_Parser_Tactic_nestedTacticBlock___closed__4(); lean_mark_persistent(l_Lean_Parser_Tactic_nestedTacticBlock___closed__4); +l_Lean_Parser_Tactic_nestedTacticBlock___closed__5 = _init_l_Lean_Parser_Tactic_nestedTacticBlock___closed__5(); +lean_mark_persistent(l_Lean_Parser_Tactic_nestedTacticBlock___closed__5); l_Lean_Parser_Tactic_nestedTacticBlock = _init_l_Lean_Parser_Tactic_nestedTacticBlock(); lean_mark_persistent(l_Lean_Parser_Tactic_nestedTacticBlock); res = l___regBuiltinParser_Lean_Parser_Tactic_nestedTacticBlock(lean_io_mk_world()); @@ -13935,6 +14072,8 @@ l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__5 = _init_l_Lean_Parser_Ta lean_mark_persistent(l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__5); l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__6 = _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__6(); lean_mark_persistent(l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__6); +l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__7 = _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__7(); +lean_mark_persistent(l_Lean_Parser_Tactic_nestedTacticBlockCurly___closed__7); l_Lean_Parser_Tactic_nestedTacticBlockCurly = _init_l_Lean_Parser_Tactic_nestedTacticBlockCurly(); lean_mark_persistent(l_Lean_Parser_Tactic_nestedTacticBlockCurly); res = l___regBuiltinParser_Lean_Parser_Tactic_nestedTacticBlockCurly(lean_io_mk_world()); diff --git a/stage0/stdlib/Lean/Parser/Term.c b/stage0/stdlib/Lean/Parser/Term.c index b9e1b2f05b..bc4d5c9200 100644 --- a/stage0/stdlib/Lean/Parser/Term.c +++ b/stage0/stdlib/Lean/Parser/Term.c @@ -35,12 +35,14 @@ 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_decide___elambda__1___closed__3; +lean_object* l_Lean_Parser_Term_levelStxQuot___closed__6; lean_object* l_Lean_Parser_Term_infixL___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__1; lean_object* l_Lean_Parser_Term_tacticStxQuot___closed__4; lean_object* l___private_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___regBuiltinParser_Lean_Parser_Term_iff(lean_object*); lean_object* l___regBuiltinParser_Lean_Parser_Term_suffices(lean_object*); +lean_object* l_Lean_Parser_Term_tacticStxQuot___closed__7; 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; @@ -112,6 +114,7 @@ lean_object* l_Lean_Parser_Term_matchAlt___closed__3; lean_object* l_Lean_Parser_Term_inaccessible___closed__2; lean_object* l_Lean_Parser_Term_structInst___closed__1; lean_object* l_Lean_Parser_Term_andM___elambda__1(lean_object*, lean_object*); +lean_object* l_Lean_Parser_Term_sorry___closed__6; lean_object* l_Lean_Parser_Term_proj; lean_object* l_Lean_Parser_Term_dollar___elambda__1(lean_object*, lean_object*); extern lean_object* l_addParenHeuristic___closed__2; @@ -204,6 +207,7 @@ 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; lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1___closed__4; +lean_object* l_Lean_Parser_Term_do___closed__8; 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; @@ -264,6 +268,7 @@ lean_object* l_Lean_Parser_Term_band___elambda__1___closed__3; lean_object* l_Lean_Parser_Term_funBinderStxQuot___closed__2; 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_arrayLit___closed__7; 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*); @@ -284,6 +289,7 @@ lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__2; lean_object* l_Lean_Parser_Term_type___closed__6; 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_funBinderStxQuot___closed__7; lean_object* l_Lean_Parser_Term_byTactic; lean_object* l_Lean_Parser_Term_have___closed__3; lean_object* l_Lean_Parser_ParserState_pushSyntax(lean_object*, lean_object*); @@ -301,7 +307,6 @@ extern lean_object* l_Sigma_HasRepr___rarg___closed__1; lean_object* l_Lean_Parser_Term_listLit___closed__1; 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_subst___closed__6; extern lean_object* l_Lean_Parser_ident; lean_object* l___private_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*); @@ -313,6 +318,7 @@ 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; +lean_object* l_Lean_Parser_checkRbpLtFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_subtype___closed__1; lean_object* l_Lean_Parser_Term_decide___elambda__1___closed__1; lean_object* l_Lean_Parser_Term_anonymousCtor___closed__4; @@ -361,6 +367,7 @@ lean_object* l_Lean_Parser_Term_letPatDecl___closed__4; lean_object* l_Lean_Parser_Term_if___elambda__1___closed__7; lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__6; lean_object* l_Lean_Parser_Term_or___elambda__1___closed__4; +lean_object* l_Lean_Parser_Term_quotedName___closed__5; lean_object* l_Lean_Parser_Term_nativeDecide___elambda__1___closed__2; lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__12; lean_object* l_Lean_Parser_Term_match__syntax___closed__3; @@ -421,6 +428,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* l_Lean_Parser_Term_sorry___closed__2; +lean_object* l_Lean_Parser_Term_nomatch___closed__7; lean_object* l_Lean_Parser_Term_if___closed__11; lean_object* l_Lean_Parser_Term_num___elambda__1___closed__1; lean_object* l_Lean_Parser_Term_checkIsSort___closed__1; @@ -433,6 +441,7 @@ lean_object* l_Lean_Parser_Term_let_x21___elambda__1___closed__9; lean_object* l_Lean_Parser_Term_show___closed__6; lean_object* l_Lean_Parser_Term_nomatch___elambda__1___closed__9; lean_object* l_Lean_Parser_Term_listLit___closed__4; +lean_object* l_Lean_Parser_Term_hole___closed__5; lean_object* l_Lean_Parser_Term_gt___elambda__1___closed__2; lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__4; @@ -454,6 +463,7 @@ lean_object* l_Lean_Parser_Term_parenSpecial___closed__1; lean_object* l_Lean_Parser_Term_not___elambda__1___closed__5; lean_object* l_Lean_Parser_Tactic_seq___closed__6; lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__3; +lean_object* l_Lean_Parser_Term_listLit___closed__9; lean_object* l_Lean_Parser_Term_structInstLVal___closed__9; lean_object* l_Lean_Parser_Term_namedPattern___elambda__1___closed__3; lean_object* l_Lean_Parser_Term_show___elambda__1___closed__3; @@ -467,7 +477,6 @@ extern lean_object* l_List_repr___rarg___closed__3; lean_object* l_Lean_Parser_Term_liftMethod___elambda__1___closed__3; 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_forall___elambda__1___closed__13; lean_object* l_Lean_Parser_Term_anonymousCtor___closed__9; lean_object* l_Lean_Parser_Term_sorry___closed__1; lean_object* l_Lean_Parser_Term_funBinderStxQuot___elambda__1___closed__1; @@ -480,6 +489,7 @@ lean_object* l_Lean_Parser_Term_parser_x21___closed__5; lean_object* l_Lean_Parser_Tactic_nonEmptySeq; 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_bnot___closed__7; lean_object* lean_string_utf8_byte_size(lean_object*); lean_object* l_Lean_Parser_Term_if; lean_object* l_Lean_Parser_Term_paren; @@ -498,6 +508,7 @@ 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_parser_x21___closed__7; 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_liftMethod___closed__4; @@ -693,6 +704,7 @@ lean_object* l_Lean_Parser_Term_mapRev___closed__1; lean_object* l_Lean_Parser_Term_do___closed__2; lean_object* l_Lean_Parser_Term_structInst___closed__17; uint8_t lean_nat_dec_eq(lean_object*, lean_object*); +lean_object* l_Lean_Parser_Term_let___closed__9; lean_object* l_Lean_Parser_Term_gt___closed__2; lean_object* l_Lean_Parser_Term_orelse___elambda__1___closed__3; lean_object* l_Lean_Parser_Term_ge___elambda__1___closed__3; @@ -756,16 +768,17 @@ 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* l_Lean_Parser_Term_ge___elambda__1___closed__5; lean_object* l_Lean_Parser_Term_have___closed__11; +extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__7; lean_object* l_Lean_Parser_Term_doSeq___closed__1; 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_Lean_Parser_Term_paren___closed__9; 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_decide___elambda__1___closed__8; -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*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*); lean_object* l___private_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*); @@ -816,6 +829,7 @@ 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* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__3; +lean_object* l_Lean_Parser_Term_where___closed__9; lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___closed__3; lean_object* l_Lean_Parser_Term_bracketedDoSeq___closed__4; lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1(lean_object*, lean_object*, lean_object*); @@ -855,6 +869,7 @@ lean_object* l_Lean_Parser_Term_show___elambda__1___closed__7; lean_object* l_Lean_Parser_Term_type___closed__7; lean_object* l_Lean_Parser_Term_arrayRef; lean_object* l_Lean_Parser_Term_cdot; +lean_object* l_Lean_Parser_Term_depArrow___closed__9; lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__3; lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_nonEmptySeq___elambda__1___spec__1(uint8_t, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_nativeRefl___closed__6; @@ -921,6 +936,7 @@ lean_object* l_Lean_Parser_Term_depArrow___closed__2; lean_object* l_Lean_Parser_Term_levelStxQuot___elambda__1___closed__4; 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_str___closed__5; 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; @@ -983,7 +999,6 @@ lean_object* l_Lean_Parser_strAux___main(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; -extern lean_object* l_Lean_Parser_antiquotNestedExpr___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, lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_num___closed__1; @@ -1009,6 +1024,7 @@ lean_object* l_Lean_Parser_Term_quotedName___elambda__1(lean_object*, lean_objec lean_object* l_Lean_Parser_Term_doSeq___closed__2; lean_object* l_Lean_Parser_Term_structInstLVal___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_doElem___closed__1; +lean_object* l_Lean_Parser_Term_let_x21___closed__7; lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__13; lean_object* l_Lean_Parser_Term_ne___closed__1; lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__5; @@ -1042,6 +1058,7 @@ lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__2; lean_object* l_Lean_Parser_Term_or___elambda__1(lean_object*, lean_object*); lean_object* l___regBuiltinParser_Lean_Parser_Term_seq(lean_object*); lean_object* l_Lean_Parser_Term_sub___elambda__1___closed__3; +lean_object* l_Lean_Parser_Term_bracketedDoSeq___closed__7; lean_object* l_Lean_Parser_Term_bindOp___closed__2; lean_object* l_Lean_Parser_Term_structInst___closed__18; lean_object* l_Lean_Parser_Term_uminus___elambda__1___closed__2; @@ -1060,7 +1077,6 @@ lean_object* l_Lean_Parser_Term_fcomp___elambda__1___closed__1; 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*); -lean_object* l_Lean_Parser_checkRbpLe(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_Lean_Parser_Term_nativeDecide___closed__2; @@ -1068,6 +1084,7 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_anonymousCtor(lean_object*); lean_object* l_Lean_Parser_Term_lt___closed__1; lean_object* l_Lean_Parser_Term_bindOp___closed__1; lean_object* l_Lean_Parser_Term_seq; +lean_object* l_Lean_Parser_Term_show___closed__8; 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; @@ -1147,12 +1164,13 @@ 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* l_Lean_Parser_Term_let___elambda__1___closed__8; lean_object* l_Lean_Parser_Term_namedHole___closed__5; +lean_object* l_Lean_Parser_Term_byTactic___closed__7; 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___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2; lean_object* l_Lean_Parser_Term_match___closed__1; -lean_object* l_Lean_Parser_symbolNoWsInfo(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolNoWsInfo(lean_object*); lean_object* l_Lean_Parser_Term_nativeDecide___elambda__1___closed__7; lean_object* l_Lean_Parser_Term_liftMethod___closed__1; lean_object* l_Lean_Parser_Term_explicitUniv___closed__4; @@ -1207,6 +1225,7 @@ lean_object* l_Lean_Parser_Term_namedArgument___closed__2; 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_liftMethod___closed__6; lean_object* l_Lean_Parser_Term_dollarProj___closed__2; lean_object* l_Lean_Parser_Term_bnot___elambda__1___closed__9; lean_object* l_Lean_Parser_Term_binderDefault___closed__1; @@ -1270,7 +1289,10 @@ 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*, 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_Lean_Parser_Term_tacticBlock___closed__9; lean_object* l_Lean_Parser_Term_have___closed__10; +lean_object* l_Lean_Parser_Term_cdot___closed__6; +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; @@ -1337,7 +1359,6 @@ 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_structInstLVal___closed__2; lean_object* l_Lean_Parser_Term_if___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__1; @@ -1345,6 +1366,7 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot___closed__2; lean_object* l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__10; 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_Term_fun___closed__9; 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_anonymousCtor___elambda__1___closed__3; @@ -1353,6 +1375,7 @@ 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; @@ -1381,6 +1404,7 @@ lean_object* l_Lean_Parser_Term_beq___closed__3; lean_object* l_Lean_Parser_Term_id___closed__1; lean_object* l_Lean_Parser_Term_haveAssign___closed__6; lean_object* l_Lean_Parser_Term_arrayRef___closed__2; +lean_object* l_Lean_Parser_Term_namedHole___closed__7; 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; @@ -1427,8 +1451,10 @@ lean_object* l_Lean_Parser_Term_infixL___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_binderTactic___closed__2; lean_object* l_Lean_Parser_Term_if___elambda__1___closed__9; lean_object* l_Lean_Parser_Term_div___closed__1; +lean_object* l_Lean_Parser_Term_match__syntax___closed__8; 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_num___closed__5; 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*); @@ -1456,6 +1482,7 @@ lean_object* l_Lean_Parser_Term_bor___closed__2; lean_object* l_Lean_Parser_Term_cdot___elambda__1___closed__4; lean_object* l_Lean_Parser_Term_dollar___closed__3; lean_object* l_Lean_Parser_Term_bne___closed__1; +lean_object* l_Lean_Parser_Term_id___closed__8; lean_object* l_Lean_Parser_Term_matchAlt___closed__4; lean_object* l_Lean_Parser_Term_mapConst___closed__1; lean_object* l_Lean_Parser_Term_have___closed__9; @@ -1502,8 +1529,10 @@ lean_object* l___regBuiltinParser_Lean_Parser_Term_orelse(lean_object*); lean_object* l_Lean_Parser_Term_match___elambda__1___closed__2; lean_object* l___private_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_tupleTail___closed__6; +extern lean_object* l___private_Lean_Parser_Parser_10__precErrorMsg; 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_uminus___closed__8; 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*); @@ -1529,6 +1558,7 @@ 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; lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_subst___elambda__1___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Parser_Term_inaccessible___closed__7; lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__12; lean_object* l_Lean_Parser_Term_let___elambda__1___closed__1; lean_object* l_Lean_Parser_Term_type___elambda__1___closed__4; @@ -1590,6 +1620,7 @@ lean_object* l_Lean_Parser_Term_div___closed__2; lean_object* l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__4; lean_object* l_Lean_Parser_Term_mapConst___closed__2; lean_object* l_Lean_Parser_Term_emptyC___closed__3; +lean_object* l_Lean_Parser_Term_tparser_x21___closed__7; lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__5; lean_object* l_Lean_Parser_Term_sub___closed__3; lean_object* l_Lean_Parser_Term_typeSpec___closed__3; @@ -1597,7 +1628,7 @@ lean_object* l_Lean_Parser_Term_iff___closed__1; lean_object* l_Lean_Parser_Term_orelse___closed__3; lean_object* l_Lean_Parser_Term_fun___closed__3; lean_object* l_Lean_Parser_Term_tacticBlock___closed__8; -lean_object* l_Lean_Parser_symbolInfo(lean_object*, lean_object*); +lean_object* l_Lean_Parser_symbolInfo(lean_object*); lean_object* l_Lean_Parser_Term_match___closed__9; lean_object* l_Lean_Parser_Term_tupleTail___closed__5; lean_object* l_Lean_Parser_Term_mapRev___elambda__1___closed__2; @@ -1616,10 +1647,12 @@ lean_object* l_Lean_Parser_Term_have___closed__4; lean_object* l_Lean_Parser_Term_byTactic___elambda__1___closed__3; lean_object* l_Lean_Parser_Term_mod___elambda__1___closed__3; lean_object* l_Lean_Parser_Term_append___elambda__1___closed__2; +lean_object* l_Lean_Parser_Term_anonymousCtor___closed__10; lean_object* l_Lean_Parser_Term_num___closed__3; lean_object* l_Lean_Parser_Term_letIdDecl___closed__5; lean_object* l_Lean_Parser_Term_match___closed__4; 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; @@ -1726,6 +1759,7 @@ 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_dollarProj___closed__6; 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; @@ -1757,9 +1791,12 @@ lean_object* l_Lean_Parser_Term_bindOp___elambda__1___closed__4; 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_Lean_Parser_Term_not___closed__8; +lean_object* l_Lean_Parser_Term_match___closed__11; lean_object* l_Lean_Parser_Term_implicitBinder___boxed(lean_object*); lean_object* l_Lean_Parser_Term_nativeRefl___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_mapConst___elambda__1___closed__2; +lean_object* l_Lean_Parser_Term_char___closed__5; 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; @@ -1799,6 +1836,7 @@ lean_object* l_Lean_Parser_Term_doPat___elambda__1___closed__9; lean_object* l_Lean_Parser_Term_heq___closed__1; lean_object* l_Lean_Parser_Term_borrowed___closed__6; lean_object* l_Lean_Parser_Term_mapRev___closed__3; +lean_object* l_Lean_Parser_Term_forall___closed__10; lean_object* l_Lean_Parser_Term_matchAlt___closed__1; lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__12; lean_object* l_Lean_Parser_Term_checkIsSort___closed__2; @@ -1933,9 +1971,11 @@ 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___closed__2; +lean_object* l_Lean_Parser_Term_explicit___closed__5; lean_object* l_Lean_Parser_Term_do___elambda__1___closed__5; lean_object* l_Lean_Parser_regBuiltinTacticParserAttr___closed__4; lean_object* l_Lean_Parser_Term_mapConstRev___closed__2; +lean_object* l_Lean_Parser_Term_have___closed__12; lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__7; lean_object* l_Lean_Parser_Term_tupleTail___closed__4; lean_object* l_Lean_Parser_Term_funBinderStxQuot___elambda__1___closed__5; @@ -1943,14 +1983,15 @@ lean_object* l_Lean_Parser_Term_nativeRefl___elambda__1___closed__3; lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_orelse___elambda__1___closed__2; lean_object* l_Lean_Parser_Term_gt___closed__3; -lean_object* l_Lean_Parser_unicodeSymbolInfo(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Parser_unicodeSymbolInfo(lean_object*, lean_object*); +lean_object* l_Lean_Parser_Term_borrowed___closed__8; lean_object* l_Lean_Parser_Term_type___elambda__1___closed__1; lean_object* l_Lean_Parser_Term_borrowed___closed__2; +lean_object* l_Lean_Parser_Term_emptyC___closed__6; lean_object* l_Lean_Parser_Term_mapRev___elambda__1___closed__4; lean_object* l_Lean_Parser_Term_tacticBlock___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; -extern lean_object* l_Lean_Syntax_decodeNatLitVal___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* l_Lean_Parser_Term_mapConstRev; @@ -1958,7 +1999,6 @@ lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parse 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*); -extern lean_object* l_Lean_Parser_leadingNodePrec___closed__1; lean_object* l_Lean_Parser_Term_letIdLhs; lean_object* l_Lean_Parser_Term_namedHole___closed__4; lean_object* l_Lean_Parser_Term_show___elambda__1___closed__9; @@ -2073,13 +2113,16 @@ 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_structInst___closed__19; lean_object* l_Lean_Parser_Term_doId___closed__6; +lean_object* l_Lean_Parser_Term_sort___closed__7; 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_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_nativeRefl___elambda__1___closed__9; +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_Lean_Parser_Term_levelStxQuot___closed__2; lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__7; @@ -2095,7 +2138,6 @@ 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; -extern lean_object* l_Lean_Parser_Level_addLit___closed__1; lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__4; 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*); @@ -2109,6 +2151,7 @@ lean_object* l_Lean_Parser_Term_unicodeInfixR(lean_object*, lean_object*, lean_o lean_object* l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; lean_object* l_Lean_Parser_Term_let_x21___closed__2; lean_object* l___private_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_suffices___closed__10; lean_object* l_Lean_Parser_Term_forall___closed__6; lean_object* l_Lean_Parser_Term_mod___elambda__1___closed__2; lean_object* l_Lean_Parser_Term_modN___closed__1; @@ -2116,6 +2159,7 @@ lean_object* l_Lean_Parser_Tactic_seq___closed__4; 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_prop___closed__6; lean_object* l_Lean_Parser_Term_char___elambda__1___closed__3; extern lean_object* l_Lean_Parser_Level_paren___closed__1; lean_object* l_Lean_Parser_Term_where___closed__7; @@ -2125,6 +2169,7 @@ lean_object* l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__8; lean_object* l_Lean_Parser_Term_typeSpec___elambda__1___closed__4; lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; lean_object* l_Lean_Parser_Term_hole___closed__1; +lean_object* l_Lean_Parser_Term_type___closed__9; lean_object* l_Lean_Parser_Term_match___elambda__1___closed__13; lean_object* l_Lean_Parser_Term_letEqnsDecl___closed__4; lean_object* l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; @@ -2567,11 +2612,10 @@ return x_3; lean_object* _init_l_Lean_Parser_Tactic_seq___closed__2() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; +lean_object* x_1; lean_object* x_2; x_1 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Tactic_seq___closed__3() { @@ -2848,11 +2892,10 @@ return x_16; 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_1; lean_object* x_2; x_1 = l_Lean_Parser_darrow___elambda__1___closed__2; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_darrow___closed__2() { @@ -2909,38 +2952,45 @@ 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; 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_4; 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; +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; lean_inc(x_3); -x_4 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_4, 0, x_3); -x_5 = l_String_trim(x_1); -x_6 = l_String_trim(x_2); +x_5 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLtFn___boxed), 4, 2); +lean_closure_set(x_5, 0, x_3); +lean_closure_set(x_5, 1, x_4); +x_6 = l_String_trim(x_1); +x_7 = l_String_trim(x_2); +lean_inc(x_7); 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___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); +x_8 = l_Lean_Parser_unicodeSymbolInfo(x_6, x_7); +x_9 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___boxed), 4, 2); +lean_closure_set(x_9, 0, x_6); +lean_closure_set(x_9, 1, x_7); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_sub(x_3, x_10); lean_dec(x_3); -x_11 = l_Lean_Parser_termParser___closed__2; -lean_inc(x_10); -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; +x_12 = l_Lean_Parser_termParser___closed__2; +lean_inc(x_11); +x_13 = l_Lean_Parser_categoryParser(x_12, x_11); +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +lean_dec(x_13); +x_15 = l_Lean_Parser_andthenInfo(x_8, x_14); +x_16 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 2); +lean_closure_set(x_16, 0, x_12); +lean_closure_set(x_16, 1, x_11); +x_17 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2); +lean_closure_set(x_17, 0, x_9); +lean_closure_set(x_17, 1, x_16); +x_18 = l_Lean_Parser_epsilonInfo; +x_19 = l_Lean_Parser_andthenInfo(x_18, x_15); +x_20 = lean_alloc_closure((void*)(l_Lean_Parser_Term_unicodeInfixR___elambda__1), 4, 2); +lean_closure_set(x_20, 0, x_5); +lean_closure_set(x_20, 1, x_17); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +return x_21; } } lean_object* l_Lean_Parser_Term_unicodeInfixR___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { @@ -2979,35 +3029,42 @@ 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; 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_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; +x_3 = l___private_Lean_Parser_Parser_10__precErrorMsg; 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___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); +x_4 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLtFn___boxed), 4, 2); +lean_closure_set(x_4, 0, x_2); +lean_closure_set(x_4, 1, x_3); +x_5 = l_String_trim(x_1); +lean_inc(x_5); +x_6 = l_Lean_Parser_symbolInfo(x_5); +x_7 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1); +lean_closure_set(x_7, 0, x_5); +x_8 = lean_unsigned_to_nat(1u); +x_9 = lean_nat_sub(x_2, x_8); lean_dec(x_2); -x_9 = l_Lean_Parser_termParser___closed__2; -lean_inc(x_8); -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; +x_10 = l_Lean_Parser_termParser___closed__2; +lean_inc(x_9); +x_11 = l_Lean_Parser_categoryParser(x_10, x_9); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +lean_dec(x_11); +x_13 = l_Lean_Parser_andthenInfo(x_6, x_12); +x_14 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 2); +lean_closure_set(x_14, 0, x_10); +lean_closure_set(x_14, 1, x_9); +x_15 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2); +lean_closure_set(x_15, 0, x_7); +lean_closure_set(x_15, 1, x_14); +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_Term_infixR___elambda__1), 4, 2); +lean_closure_set(x_18, 0, x_4); +lean_closure_set(x_18, 1, x_15); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +return x_19; } } lean_object* l_Lean_Parser_Term_infixR___boxed(lean_object* x_1, lean_object* x_2) { @@ -3045,35 +3102,42 @@ 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; 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_4; 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; +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; lean_inc(x_3); -x_4 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_4, 0, x_3); -x_5 = l_String_trim(x_1); -x_6 = l_String_trim(x_2); +x_5 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLtFn___boxed), 4, 2); +lean_closure_set(x_5, 0, x_3); +lean_closure_set(x_5, 1, x_4); +x_6 = l_String_trim(x_1); +x_7 = l_String_trim(x_2); +lean_inc(x_7); 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___boxed), 4, 2); -lean_closure_set(x_8, 0, x_5); -lean_closure_set(x_8, 1, x_6); -x_9 = l_Lean_Parser_termParser___closed__2; +x_8 = l_Lean_Parser_unicodeSymbolInfo(x_6, x_7); +x_9 = lean_alloc_closure((void*)(l_Lean_Parser_unicodeSymbolFn___boxed), 4, 2); +lean_closure_set(x_9, 0, x_6); +lean_closure_set(x_9, 1, x_7); +x_10 = l_Lean_Parser_termParser___closed__2; lean_inc(x_3); -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; +x_11 = l_Lean_Parser_categoryParser(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_8, x_12); +x_14 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 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_andthenFn), 4, 2); +lean_closure_set(x_15, 0, x_9); +lean_closure_set(x_15, 1, x_14); +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_Term_unicodeInfixL___elambda__1), 4, 2); +lean_closure_set(x_18, 0, x_5); +lean_closure_set(x_18, 1, x_15); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +return x_19; } } lean_object* l_Lean_Parser_Term_unicodeInfixL___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { @@ -3112,32 +3176,39 @@ 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; 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; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_3 = l___private_Lean_Parser_Parser_10__precErrorMsg; 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___boxed), 3, 1); -lean_closure_set(x_6, 0, x_4); -x_7 = l_Lean_Parser_termParser___closed__2; +x_4 = lean_alloc_closure((void*)(l_Lean_Parser_checkRbpLtFn___boxed), 4, 2); +lean_closure_set(x_4, 0, x_2); +lean_closure_set(x_4, 1, x_3); +x_5 = l_String_trim(x_1); +lean_inc(x_5); +x_6 = l_Lean_Parser_symbolInfo(x_5); +x_7 = lean_alloc_closure((void*)(l_Lean_Parser_symbolFn___boxed), 3, 1); +lean_closure_set(x_7, 0, x_5); +x_8 = l_Lean_Parser_termParser___closed__2; lean_inc(x_2); -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; +x_9 = l_Lean_Parser_categoryParser(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_6, x_10); +x_12 = lean_alloc_closure((void*)(l_Lean_Parser_categoryParser___elambda__1), 4, 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_andthenFn), 4, 2); +lean_closure_set(x_13, 0, x_7); +lean_closure_set(x_13, 1, x_12); +x_14 = l_Lean_Parser_epsilonInfo; +x_15 = l_Lean_Parser_andthenInfo(x_14, x_11); +x_16 = lean_alloc_closure((void*)(l_Lean_Parser_Term_infixL___elambda__1), 4, 2); +lean_closure_set(x_16, 0, x_4); +lean_closure_set(x_16, 1, x_13); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_16); +return x_17; } } lean_object* l_Lean_Parser_Term_infixL___boxed(lean_object* x_1, lean_object* x_2) { @@ -3979,21 +4050,19 @@ return x_6; lean_object* _init_l_Lean_Parser_Term_explicitUniv___closed__1() { _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_explicitUniv___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_explicitUniv___closed__2() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; +lean_object* x_1; lean_object* x_2; x_1 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_explicitUniv___closed__3() { @@ -4011,11 +4080,10 @@ return x_4; lean_object* _init_l_Lean_Parser_Term_explicitUniv___closed__4() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; +lean_object* x_1; lean_object* x_2; x_1 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_explicitUniv___closed__5() { @@ -4476,11 +4544,10 @@ return x_6; lean_object* _init_l_Lean_Parser_Term_namedPattern___closed__1() { _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_namedPattern___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_namedPattern___closed__2() { @@ -4600,106 +4667,114 @@ if (x_5 == 0) { lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -lean_inc(x_1); -x_8 = l_Lean_Parser_ident___elambda__1(x_1, x_2); +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 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_1); -x_13 = l_Lean_Parser_Term_explicitUniv___elambda__1(x_1, x_8); -x_14 = lean_ctor_get(x_13, 3); +x_12 = l_Lean_Parser_ident___elambda__1(x_1, x_8); +x_13 = lean_ctor_get(x_12, 3); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_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); -if (lean_obj_tag(x_14) == 0) -{ -lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; -lean_dec(x_12); -lean_dec(x_1); -x_15 = l_Lean_nullKind; -x_16 = l_Lean_Parser_ParserState_mkNode(x_13, x_15, x_11); -x_17 = l_Lean_mkTermIdFromIdent___closed__2; -x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_7); -return x_18; -} -else -{ -lean_object* x_19; lean_object* x_20; uint8_t x_21; -x_19 = lean_ctor_get(x_14, 0); -lean_inc(x_19); +x_15 = lean_array_get_size(x_14); lean_dec(x_14); -x_20 = lean_ctor_get(x_13, 1); -lean_inc(x_20); -x_21 = lean_nat_dec_eq(x_20, x_12); -lean_dec(x_20); -if (x_21 == 0) +x_16 = lean_ctor_get(x_12, 1); +lean_inc(x_16); +lean_inc(x_1); +x_17 = l_Lean_Parser_Term_explicitUniv___elambda__1(x_1, x_12); +x_18 = lean_ctor_get(x_17, 3); +lean_inc(x_18); +if (lean_obj_tag(x_18) == 0) { -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; -lean_dec(x_19); -lean_dec(x_12); +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +lean_dec(x_16); lean_dec(x_1); -x_22 = l_Lean_nullKind; -x_23 = l_Lean_Parser_ParserState_mkNode(x_13, x_22, x_11); -x_24 = l_Lean_mkTermIdFromIdent___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); -return x_25; +x_19 = l_Lean_nullKind; +x_20 = l_Lean_Parser_ParserState_mkNode(x_17, x_19, x_15); +x_21 = l_Lean_mkTermIdFromIdent___closed__2; +x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_11); +return x_22; } else { +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_18, 0); +lean_inc(x_23); +lean_dec(x_18); +x_24 = lean_ctor_get(x_17, 1); +lean_inc(x_24); +x_25 = lean_nat_dec_eq(x_24, x_16); +lean_dec(x_24); +if (x_25 == 0) +{ lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -lean_inc(x_12); -x_26 = l_Lean_Parser_ParserState_restore(x_13, x_11, x_12); -x_27 = l_Lean_Parser_Term_namedPattern___elambda__1(x_1, x_26); -x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_19, x_12); -x_29 = lean_ctor_get(x_28, 3); -lean_inc(x_29); -if (lean_obj_tag(x_29) == 0) +lean_dec(x_23); +lean_dec(x_16); +lean_dec(x_1); +x_26 = l_Lean_nullKind; +x_27 = l_Lean_Parser_ParserState_mkNode(x_17, x_26, x_15); +x_28 = l_Lean_mkTermIdFromIdent___closed__2; +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); +return x_29; +} +else { lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; -lean_dec(x_12); -x_30 = l_Lean_nullKind; -x_31 = l_Lean_Parser_ParserState_mkNode(x_28, x_30, x_11); -x_32 = l_Lean_mkTermIdFromIdent___closed__2; -x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_7); -return x_33; +lean_inc(x_16); +x_30 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16); +x_31 = l_Lean_Parser_Term_namedPattern___elambda__1(x_1, x_30); +x_32 = l_Lean_Parser_mergeOrElseErrors(x_31, x_23, x_16); +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_object* x_37; +lean_dec(x_16); +x_34 = l_Lean_nullKind; +x_35 = l_Lean_Parser_ParserState_mkNode(x_32, x_34, x_15); +x_36 = l_Lean_mkTermIdFromIdent___closed__2; +x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_11); +return x_37; } else { -lean_object* x_34; uint8_t x_35; -lean_dec(x_29); -x_34 = lean_ctor_get(x_28, 1); -lean_inc(x_34); -x_35 = lean_nat_dec_eq(x_34, x_12); -lean_dec(x_34); -if (x_35 == 0) +lean_object* x_38; uint8_t x_39; +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_16); +lean_dec(x_38); +if (x_39 == 0) { -lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; -lean_dec(x_12); -x_36 = l_Lean_nullKind; -x_37 = l_Lean_Parser_ParserState_mkNode(x_28, x_36, x_11); -x_38 = l_Lean_mkTermIdFromIdent___closed__2; -x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_7); -return x_39; +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_dec(x_16); +x_40 = l_Lean_nullKind; +x_41 = l_Lean_Parser_ParserState_mkNode(x_32, x_40, x_15); +x_42 = l_Lean_mkTermIdFromIdent___closed__2; +x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_11); +return x_43; } else { -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_ParserState_restore(x_28, x_11, x_12); -x_41 = l_Lean_nullKind; -x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_11); -x_43 = l_Lean_mkTermIdFromIdent___closed__2; -x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_7); -return x_44; +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_44 = l_Lean_Parser_ParserState_restore(x_32, x_15, x_16); +x_45 = l_Lean_nullKind; +x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15); +x_47 = l_Lean_mkTermIdFromIdent___closed__2; +x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_11); +return x_48; } } } @@ -4707,183 +4782,208 @@ return x_44; } else { -lean_object* x_45; lean_object* x_46; +lean_object* x_49; lean_object* x_50; +lean_dec(x_13); +lean_dec(x_1); +x_49 = l_Lean_mkTermIdFromIdent___closed__2; +x_50 = l_Lean_Parser_ParserState_mkNode(x_12, x_49, x_11); +return x_50; +} +} +else +{ lean_dec(x_9); lean_dec(x_1); -x_45 = l_Lean_mkTermIdFromIdent___closed__2; -x_46 = l_Lean_Parser_ParserState_mkNode(x_8, x_45, x_7); -return x_46; +return x_8; } } else { -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_2, 0); -lean_inc(x_47); -x_48 = lean_array_get_size(x_47); -lean_dec(x_47); -x_49 = lean_ctor_get(x_2, 1); -lean_inc(x_49); -lean_inc(x_1); -x_50 = lean_apply_2(x_4, x_1, x_2); -x_51 = lean_ctor_get(x_50, 3); +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_51 = lean_ctor_get(x_2, 0); lean_inc(x_51); -if (lean_obj_tag(x_51) == 0) -{ -lean_dec(x_49); -lean_dec(x_48); -lean_dec(x_1); -return x_50; -} -else -{ -lean_object* x_52; lean_object* x_53; uint8_t x_54; -x_52 = lean_ctor_get(x_51, 0); -lean_inc(x_52); +x_52 = lean_array_get_size(x_51); lean_dec(x_51); -x_53 = lean_ctor_get(x_50, 1); +x_53 = lean_ctor_get(x_2, 1); lean_inc(x_53); -x_54 = lean_nat_dec_eq(x_53, x_49); -lean_dec(x_53); -if (x_54 == 0) +lean_inc(x_1); +x_54 = lean_apply_2(x_4, x_1, x_2); +x_55 = lean_ctor_get(x_54, 3); +lean_inc(x_55); +if (lean_obj_tag(x_55) == 0) { +lean_dec(x_53); lean_dec(x_52); -lean_dec(x_49); -lean_dec(x_48); lean_dec(x_1); -return x_50; +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_inc(x_49); -x_55 = l_Lean_Parser_ParserState_restore(x_50, x_48, x_49); -lean_dec(x_48); +lean_object* x_56; lean_object* x_57; uint8_t x_58; x_56 = lean_ctor_get(x_55, 0); lean_inc(x_56); -x_57 = lean_array_get_size(x_56); +lean_dec(x_55); +x_57 = lean_ctor_get(x_54, 1); +lean_inc(x_57); +x_58 = lean_nat_dec_eq(x_57, x_53); +lean_dec(x_57); +if (x_58 == 0) +{ lean_dec(x_56); -lean_inc(x_1); -x_58 = l_Lean_Parser_ident___elambda__1(x_1, x_55); -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; 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_1); -x_63 = l_Lean_Parser_Term_explicitUniv___elambda__1(x_1, 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_object* x_68; lean_object* x_69; -lean_dec(x_62); +lean_dec(x_53); +lean_dec(x_52); lean_dec(x_1); -x_65 = l_Lean_nullKind; -x_66 = l_Lean_Parser_ParserState_mkNode(x_63, x_65, x_61); -x_67 = l_Lean_mkTermIdFromIdent___closed__2; -x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_57); -x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_52, x_49); -lean_dec(x_49); -return x_69; +return x_54; } else { -lean_object* x_70; lean_object* x_71; uint8_t x_72; -x_70 = lean_ctor_get(x_64, 0); -lean_inc(x_70); +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +lean_inc(x_53); +x_59 = l_Lean_Parser_ParserState_restore(x_54, x_52, x_53); +lean_dec(x_52); +x_60 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_61 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_62 = l_Lean_Parser_checkRbpLtFn(x_60, x_61, 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; lean_object* x_67; +x_64 = lean_ctor_get(x_62, 0); +lean_inc(x_64); +x_65 = lean_array_get_size(x_64); lean_dec(x_64); -x_71 = lean_ctor_get(x_63, 1); -lean_inc(x_71); -x_72 = lean_nat_dec_eq(x_71, x_62); -lean_dec(x_71); -if (x_72 == 0) +lean_inc(x_1); +x_66 = l_Lean_Parser_ident___elambda__1(x_1, x_62); +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; 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_1); +x_71 = l_Lean_Parser_Term_explicitUniv___elambda__1(x_1, 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_object* x_75; lean_object* x_76; lean_object* x_77; lean_dec(x_70); -lean_dec(x_62); lean_dec(x_1); x_73 = l_Lean_nullKind; -x_74 = l_Lean_Parser_ParserState_mkNode(x_63, x_73, x_61); +x_74 = l_Lean_Parser_ParserState_mkNode(x_71, x_73, x_69); x_75 = l_Lean_mkTermIdFromIdent___closed__2; -x_76 = l_Lean_Parser_ParserState_mkNode(x_74, x_75, x_57); -x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_52, x_49); -lean_dec(x_49); +x_76 = l_Lean_Parser_ParserState_mkNode(x_74, x_75, x_65); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_76, x_56, x_53); +lean_dec(x_53); return x_77; } else { -lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; -lean_inc(x_62); -x_78 = l_Lean_Parser_ParserState_restore(x_63, x_61, x_62); -x_79 = l_Lean_Parser_Term_namedPattern___elambda__1(x_1, x_78); -x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_70, x_62); -x_81 = lean_ctor_get(x_80, 3); -lean_inc(x_81); -if (lean_obj_tag(x_81) == 0) +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_72, 0); +lean_inc(x_78); +lean_dec(x_72); +x_79 = lean_ctor_get(x_71, 1); +lean_inc(x_79); +x_80 = lean_nat_dec_eq(x_79, x_70); +lean_dec(x_79); +if (x_80 == 0) { -lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; -lean_dec(x_62); -x_82 = l_Lean_nullKind; -x_83 = l_Lean_Parser_ParserState_mkNode(x_80, x_82, x_61); -x_84 = l_Lean_mkTermIdFromIdent___closed__2; -x_85 = l_Lean_Parser_ParserState_mkNode(x_83, x_84, x_57); -x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_52, x_49); -lean_dec(x_49); -return x_86; -} -else -{ -lean_object* x_87; uint8_t x_88; -lean_dec(x_81); -x_87 = lean_ctor_get(x_80, 1); -lean_inc(x_87); -x_88 = lean_nat_dec_eq(x_87, x_62); -lean_dec(x_87); -if (x_88 == 0) -{ -lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; -lean_dec(x_62); -x_89 = l_Lean_nullKind; -x_90 = l_Lean_Parser_ParserState_mkNode(x_80, x_89, x_61); -x_91 = l_Lean_mkTermIdFromIdent___closed__2; -x_92 = l_Lean_Parser_ParserState_mkNode(x_90, x_91, x_57); -x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_52, x_49); -lean_dec(x_49); -return x_93; -} -else -{ -lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; -x_94 = l_Lean_Parser_ParserState_restore(x_80, x_61, x_62); -x_95 = l_Lean_nullKind; -x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_61); -x_97 = l_Lean_mkTermIdFromIdent___closed__2; -x_98 = l_Lean_Parser_ParserState_mkNode(x_96, x_97, x_57); -x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_52, x_49); -lean_dec(x_49); -return x_99; -} -} -} -} -} -else -{ -lean_object* x_100; lean_object* x_101; lean_object* x_102; -lean_dec(x_59); +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +lean_dec(x_78); +lean_dec(x_70); lean_dec(x_1); -x_100 = l_Lean_mkTermIdFromIdent___closed__2; -x_101 = l_Lean_Parser_ParserState_mkNode(x_58, x_100, x_57); -x_102 = l_Lean_Parser_mergeOrElseErrors(x_101, x_52, x_49); -lean_dec(x_49); -return x_102; +x_81 = l_Lean_nullKind; +x_82 = l_Lean_Parser_ParserState_mkNode(x_71, x_81, x_69); +x_83 = l_Lean_mkTermIdFromIdent___closed__2; +x_84 = l_Lean_Parser_ParserState_mkNode(x_82, x_83, x_65); +x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_56, x_53); +lean_dec(x_53); +return x_85; +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +lean_inc(x_70); +x_86 = l_Lean_Parser_ParserState_restore(x_71, x_69, x_70); +x_87 = l_Lean_Parser_Term_namedPattern___elambda__1(x_1, x_86); +x_88 = l_Lean_Parser_mergeOrElseErrors(x_87, x_78, x_70); +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; lean_object* x_92; lean_object* x_93; lean_object* x_94; +lean_dec(x_70); +x_90 = l_Lean_nullKind; +x_91 = l_Lean_Parser_ParserState_mkNode(x_88, x_90, x_69); +x_92 = l_Lean_mkTermIdFromIdent___closed__2; +x_93 = l_Lean_Parser_ParserState_mkNode(x_91, x_92, x_65); +x_94 = l_Lean_Parser_mergeOrElseErrors(x_93, x_56, x_53); +lean_dec(x_53); +return x_94; +} +else +{ +lean_object* x_95; uint8_t x_96; +lean_dec(x_89); +x_95 = lean_ctor_get(x_88, 1); +lean_inc(x_95); +x_96 = lean_nat_dec_eq(x_95, x_70); +lean_dec(x_95); +if (x_96 == 0) +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +lean_dec(x_70); +x_97 = l_Lean_nullKind; +x_98 = l_Lean_Parser_ParserState_mkNode(x_88, x_97, x_69); +x_99 = l_Lean_mkTermIdFromIdent___closed__2; +x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_65); +x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_56, x_53); +lean_dec(x_53); +return x_101; +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = l_Lean_Parser_ParserState_restore(x_88, x_69, x_70); +x_103 = l_Lean_nullKind; +x_104 = l_Lean_Parser_ParserState_mkNode(x_102, x_103, x_69); +x_105 = l_Lean_mkTermIdFromIdent___closed__2; +x_106 = l_Lean_Parser_ParserState_mkNode(x_104, x_105, x_65); +x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_56, x_53); +lean_dec(x_53); +return x_107; +} +} +} +} +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; +lean_dec(x_67); +lean_dec(x_1); +x_108 = l_Lean_mkTermIdFromIdent___closed__2; +x_109 = l_Lean_Parser_ParserState_mkNode(x_66, x_108, x_65); +x_110 = l_Lean_Parser_mergeOrElseErrors(x_109, x_56, x_53); +lean_dec(x_53); +return x_110; +} +} +else +{ +lean_object* x_111; +lean_dec(x_63); +lean_dec(x_1); +x_111 = l_Lean_Parser_mergeOrElseErrors(x_62, x_56, x_53); +lean_dec(x_53); +return x_111; } } } @@ -4938,16 +5038,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_id___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_id___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_id___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_id___elambda__1___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_id___closed__4; +x_3 = l_Lean_Parser_Term_id___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_id___closed__6() { +lean_object* _init_l_Lean_Parser_Term_id___closed__7() { _start: { lean_object* x_1; @@ -4955,12 +5065,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_id___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_id___closed__7() { +lean_object* _init_l_Lean_Parser_Term_id___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_id___closed__5; -x_2 = l_Lean_Parser_Term_id___closed__6; +x_1 = l_Lean_Parser_Term_id___closed__6; +x_2 = l_Lean_Parser_Term_id___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); @@ -4971,7 +5081,7 @@ lean_object* _init_l_Lean_Parser_Term_id() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_id___closed__7; +x_1 = l_Lean_Parser_Term_id___closed__8; return x_1; } } @@ -5020,71 +5130,104 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = l_Lean_Parser_numLit___elambda__1(x_1, x_2); -x_9 = l_Lean_Nat_HasQuote___closed__2; -x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7); -return x_10; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +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 = l_Lean_Parser_numLit___elambda__1(x_1, x_8); +x_13 = l_Lean_Nat_HasQuote___closed__2; +x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_11); +return x_14; } 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_2, 0); -lean_inc(x_11); -x_12 = lean_array_get_size(x_11); -lean_dec(x_11); -x_13 = lean_ctor_get(x_2, 1); -lean_inc(x_13); -lean_inc(x_1); -x_14 = lean_apply_2(x_4, x_1, x_2); -x_15 = lean_ctor_get(x_14, 3); +lean_dec(x_9); +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; +x_15 = lean_ctor_get(x_2, 0); lean_inc(x_15); -if (lean_obj_tag(x_15) == 0) -{ -lean_dec(x_13); -lean_dec(x_12); -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); +x_16 = lean_array_get_size(x_15); lean_dec(x_15); -x_17 = lean_ctor_get(x_14, 1); +x_17 = lean_ctor_get(x_2, 1); lean_inc(x_17); -x_18 = lean_nat_dec_eq(x_17, x_13); -lean_dec(x_17); -if (x_18 == 0) +lean_inc(x_1); +x_18 = lean_apply_2(x_4, x_1, x_2); +x_19 = lean_ctor_get(x_18, 3); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) { +lean_dec(x_17); lean_dec(x_16); -lean_dec(x_13); -lean_dec(x_12); lean_dec(x_1); -return x_14; +return x_18; } else { -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(x_13); -x_19 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13); -lean_dec(x_12); +lean_object* x_20; lean_object* x_21; uint8_t x_22; x_20 = lean_ctor_get(x_19, 0); lean_inc(x_20); -x_21 = lean_array_get_size(x_20); +lean_dec(x_19); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +x_22 = lean_nat_dec_eq(x_21, x_17); +lean_dec(x_21); +if (x_22 == 0) +{ lean_dec(x_20); -x_22 = l_Lean_Parser_numLit___elambda__1(x_1, x_19); -x_23 = l_Lean_Nat_HasQuote___closed__2; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_21); -x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_16, x_13); -lean_dec(x_13); -return x_25; +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_1); +return x_18; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_inc(x_17); +x_23 = l_Lean_Parser_ParserState_restore(x_18, x_16, x_17); +lean_dec(x_16); +x_24 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_25 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_26 = l_Lean_Parser_checkRbpLtFn(x_24, 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_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_26, 0); +lean_inc(x_28); +x_29 = lean_array_get_size(x_28); +lean_dec(x_28); +x_30 = l_Lean_Parser_numLit___elambda__1(x_1, x_26); +x_31 = l_Lean_Nat_HasQuote___closed__2; +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_29); +x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_20, x_17); +lean_dec(x_17); +return x_33; +} +else +{ +lean_object* x_34; +lean_dec(x_27); +lean_dec(x_1); +x_34 = l_Lean_Parser_mergeOrElseErrors(x_26, x_20, x_17); +lean_dec(x_17); +return x_34; +} } } } @@ -5105,16 +5248,26 @@ return x_4; lean_object* _init_l_Lean_Parser_Term_num___closed__2() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_num___closed__1; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_num___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_num___elambda__1___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_num___closed__1; +x_3 = l_Lean_Parser_Term_num___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_num___closed__3() { +lean_object* _init_l_Lean_Parser_Term_num___closed__4() { _start: { lean_object* x_1; @@ -5122,12 +5275,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_num___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_num___closed__4() { +lean_object* _init_l_Lean_Parser_Term_num___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_num___closed__2; -x_2 = l_Lean_Parser_Term_num___closed__3; +x_1 = l_Lean_Parser_Term_num___closed__3; +x_2 = l_Lean_Parser_Term_num___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); @@ -5138,7 +5291,7 @@ lean_object* _init_l_Lean_Parser_Term_num() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_num___closed__4; +x_1 = l_Lean_Parser_Term_num___closed__5; return x_1; } } @@ -5187,71 +5340,104 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = l_Lean_Parser_strLit___elambda__1(x_1, x_2); -x_9 = l_Lean_String_HasQuote___closed__2; -x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7); -return x_10; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +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 = l_Lean_Parser_strLit___elambda__1(x_1, x_8); +x_13 = l_Lean_String_HasQuote___closed__2; +x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_11); +return x_14; } 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_2, 0); -lean_inc(x_11); -x_12 = lean_array_get_size(x_11); -lean_dec(x_11); -x_13 = lean_ctor_get(x_2, 1); -lean_inc(x_13); -lean_inc(x_1); -x_14 = lean_apply_2(x_4, x_1, x_2); -x_15 = lean_ctor_get(x_14, 3); +lean_dec(x_9); +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; +x_15 = lean_ctor_get(x_2, 0); lean_inc(x_15); -if (lean_obj_tag(x_15) == 0) -{ -lean_dec(x_13); -lean_dec(x_12); -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); +x_16 = lean_array_get_size(x_15); lean_dec(x_15); -x_17 = lean_ctor_get(x_14, 1); +x_17 = lean_ctor_get(x_2, 1); lean_inc(x_17); -x_18 = lean_nat_dec_eq(x_17, x_13); -lean_dec(x_17); -if (x_18 == 0) +lean_inc(x_1); +x_18 = lean_apply_2(x_4, x_1, x_2); +x_19 = lean_ctor_get(x_18, 3); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) { +lean_dec(x_17); lean_dec(x_16); -lean_dec(x_13); -lean_dec(x_12); lean_dec(x_1); -return x_14; +return x_18; } else { -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(x_13); -x_19 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13); -lean_dec(x_12); +lean_object* x_20; lean_object* x_21; uint8_t x_22; x_20 = lean_ctor_get(x_19, 0); lean_inc(x_20); -x_21 = lean_array_get_size(x_20); +lean_dec(x_19); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +x_22 = lean_nat_dec_eq(x_21, x_17); +lean_dec(x_21); +if (x_22 == 0) +{ lean_dec(x_20); -x_22 = l_Lean_Parser_strLit___elambda__1(x_1, x_19); -x_23 = l_Lean_String_HasQuote___closed__2; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_21); -x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_16, x_13); -lean_dec(x_13); -return x_25; +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_1); +return x_18; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_inc(x_17); +x_23 = l_Lean_Parser_ParserState_restore(x_18, x_16, x_17); +lean_dec(x_16); +x_24 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_25 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_26 = l_Lean_Parser_checkRbpLtFn(x_24, 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_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_26, 0); +lean_inc(x_28); +x_29 = lean_array_get_size(x_28); +lean_dec(x_28); +x_30 = l_Lean_Parser_strLit___elambda__1(x_1, x_26); +x_31 = l_Lean_String_HasQuote___closed__2; +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_29); +x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_20, x_17); +lean_dec(x_17); +return x_33; +} +else +{ +lean_object* x_34; +lean_dec(x_27); +lean_dec(x_1); +x_34 = l_Lean_Parser_mergeOrElseErrors(x_26, x_20, x_17); +lean_dec(x_17); +return x_34; +} } } } @@ -5272,16 +5458,26 @@ return x_4; lean_object* _init_l_Lean_Parser_Term_str___closed__2() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_str___closed__1; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_str___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_str___elambda__1___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_str___closed__1; +x_3 = l_Lean_Parser_Term_str___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_str___closed__3() { +lean_object* _init_l_Lean_Parser_Term_str___closed__4() { _start: { lean_object* x_1; @@ -5289,12 +5485,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_str___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_str___closed__4() { +lean_object* _init_l_Lean_Parser_Term_str___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_str___closed__2; -x_2 = l_Lean_Parser_Term_str___closed__3; +x_1 = l_Lean_Parser_Term_str___closed__3; +x_2 = l_Lean_Parser_Term_str___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); @@ -5305,7 +5501,7 @@ lean_object* _init_l_Lean_Parser_Term_str() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_str___closed__4; +x_1 = l_Lean_Parser_Term_str___closed__5; return x_1; } } @@ -5372,71 +5568,104 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = l_Lean_Parser_charLit___elambda__1(x_1, x_2); -x_9 = l_Lean_Parser_Term_char___elambda__1___closed__2; -x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7); -return x_10; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +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 = l_Lean_Parser_charLit___elambda__1(x_1, x_8); +x_13 = l_Lean_Parser_Term_char___elambda__1___closed__2; +x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_11); +return x_14; } 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_2, 0); -lean_inc(x_11); -x_12 = lean_array_get_size(x_11); -lean_dec(x_11); -x_13 = lean_ctor_get(x_2, 1); -lean_inc(x_13); -lean_inc(x_1); -x_14 = lean_apply_2(x_4, x_1, x_2); -x_15 = lean_ctor_get(x_14, 3); +lean_dec(x_9); +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; +x_15 = lean_ctor_get(x_2, 0); lean_inc(x_15); -if (lean_obj_tag(x_15) == 0) -{ -lean_dec(x_13); -lean_dec(x_12); -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); +x_16 = lean_array_get_size(x_15); lean_dec(x_15); -x_17 = lean_ctor_get(x_14, 1); +x_17 = lean_ctor_get(x_2, 1); lean_inc(x_17); -x_18 = lean_nat_dec_eq(x_17, x_13); -lean_dec(x_17); -if (x_18 == 0) +lean_inc(x_1); +x_18 = lean_apply_2(x_4, x_1, x_2); +x_19 = lean_ctor_get(x_18, 3); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) { +lean_dec(x_17); lean_dec(x_16); -lean_dec(x_13); -lean_dec(x_12); lean_dec(x_1); -return x_14; +return x_18; } else { -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(x_13); -x_19 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13); -lean_dec(x_12); +lean_object* x_20; lean_object* x_21; uint8_t x_22; x_20 = lean_ctor_get(x_19, 0); lean_inc(x_20); -x_21 = lean_array_get_size(x_20); +lean_dec(x_19); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +x_22 = lean_nat_dec_eq(x_21, x_17); +lean_dec(x_21); +if (x_22 == 0) +{ lean_dec(x_20); -x_22 = l_Lean_Parser_charLit___elambda__1(x_1, x_19); -x_23 = l_Lean_Parser_Term_char___elambda__1___closed__2; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_21); -x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_16, x_13); -lean_dec(x_13); -return x_25; +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_1); +return x_18; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_inc(x_17); +x_23 = l_Lean_Parser_ParserState_restore(x_18, x_16, x_17); +lean_dec(x_16); +x_24 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_25 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_26 = l_Lean_Parser_checkRbpLtFn(x_24, 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_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_26, 0); +lean_inc(x_28); +x_29 = lean_array_get_size(x_28); +lean_dec(x_28); +x_30 = l_Lean_Parser_charLit___elambda__1(x_1, x_26); +x_31 = l_Lean_Parser_Term_char___elambda__1___closed__2; +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_29); +x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_20, x_17); +lean_dec(x_17); +return x_33; +} +else +{ +lean_object* x_34; +lean_dec(x_27); +lean_dec(x_1); +x_34 = l_Lean_Parser_mergeOrElseErrors(x_26, x_20, x_17); +lean_dec(x_17); +return x_34; +} } } } @@ -5457,16 +5686,26 @@ return x_4; lean_object* _init_l_Lean_Parser_Term_char___closed__2() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_char___closed__1; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_char___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_char___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_char___closed__1; +x_3 = l_Lean_Parser_Term_char___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_char___closed__3() { +lean_object* _init_l_Lean_Parser_Term_char___closed__4() { _start: { lean_object* x_1; @@ -5474,12 +5713,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_char___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_char___closed__4() { +lean_object* _init_l_Lean_Parser_Term_char___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_char___closed__2; -x_2 = l_Lean_Parser_Term_char___closed__3; +x_1 = l_Lean_Parser_Term_char___closed__3; +x_2 = l_Lean_Parser_Term_char___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); @@ -5490,7 +5729,7 @@ lean_object* _init_l_Lean_Parser_Term_char() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_char___closed__4; +x_1 = l_Lean_Parser_Term_char___closed__5; return x_1; } } @@ -5606,400 +5845,431 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_49; lean_object* x_50; lean_object* x_51; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_49 = lean_ctor_get(x_2, 1); -lean_inc(x_49); -lean_inc(x_1); -x_50 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_52 = lean_ctor_get(x_50, 0); -lean_inc(x_52); -x_53 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_52); -lean_dec(x_52); -if (lean_obj_tag(x_53) == 2) -{ -lean_object* x_54; lean_object* x_55; uint8_t x_56; -x_54 = lean_ctor_get(x_53, 1); -lean_inc(x_54); -lean_dec(x_53); -x_55 = l_Lean_Parser_Term_type___elambda__1___closed__6; -x_56 = lean_string_dec_eq(x_54, x_55); -lean_dec(x_54); -if (x_56 == 0) -{ -lean_object* x_57; lean_object* x_58; -x_57 = l_Lean_Parser_Term_type___elambda__1___closed__9; -x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_57, x_49); -x_8 = x_58; -goto block_48; -} -else -{ -lean_dec(x_49); -x_8 = x_50; -goto block_48; -} -} -else -{ -lean_object* x_59; lean_object* x_60; -lean_dec(x_53); -x_59 = l_Lean_Parser_Term_type___elambda__1___closed__9; -x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_59, x_49); -x_8 = x_60; -goto block_48; -} -} -else -{ -lean_object* x_61; lean_object* x_62; -lean_dec(x_51); -x_61 = l_Lean_Parser_Term_type___elambda__1___closed__9; -x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_61, x_49); -x_8 = x_62; -goto block_48; -} -block_48: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_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_10; lean_object* x_11; lean_object* x_12; lean_object* x_52; lean_object* x_53; lean_object* x_54; 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_13 = l_Lean_Parser_appPrec; -x_14 = l_Lean_Parser_leadingNodePrec___closed__1; -x_15 = l_Lean_Parser_checkRbpLtFn(x_13, x_14, x_1, x_8); -x_16 = lean_ctor_get(x_15, 3); -lean_inc(x_16); -if (lean_obj_tag(x_16) == 0) +x_52 = lean_ctor_get(x_8, 1); +lean_inc(x_52); +lean_inc(x_1); +x_53 = l_Lean_Parser_tokenFn(x_1, x_8); +x_54 = lean_ctor_get(x_53, 3); +lean_inc(x_54); +if (lean_obj_tag(x_54) == 0) { -lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_17 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_18 = l_Lean_Parser_categoryParser___elambda__1(x_17, x_13, x_1, x_15); +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_checkStackTopFn___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_Term_type___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_Term_type___elambda__1___closed__9; +x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_60, x_52); +x_12 = x_61; +goto block_51; +} +else +{ +lean_dec(x_52); +x_12 = x_53; +goto block_51; +} +} +else +{ +lean_object* x_62; lean_object* x_63; +lean_dec(x_56); +x_62 = l_Lean_Parser_Term_type___elambda__1___closed__9; +x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_62, x_52); +x_12 = x_63; +goto block_51; +} +} +else +{ +lean_object* x_64; lean_object* x_65; +lean_dec(x_54); +x_64 = l_Lean_Parser_Term_type___elambda__1___closed__9; +x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_64, x_52); +x_12 = x_65; +goto block_51; +} +block_51: +{ +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_18; lean_object* x_19; +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 = l_Lean_Parser_appPrec; +x_18 = l_Lean_Parser_checkRbpLtFn(x_17, x_7, x_1, x_12); 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_dec(x_12); -x_20 = l_Lean_nullKind; -x_21 = l_Lean_Parser_ParserState_mkNode(x_18, x_20, x_11); -x_22 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_7); -return x_23; -} -else +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_21 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_17, 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_24; uint8_t x_25; -lean_dec(x_19); -x_24 = lean_ctor_get(x_18, 1); -lean_inc(x_24); -x_25 = lean_nat_dec_eq(x_24, x_12); -lean_dec(x_24); -if (x_25 == 0) -{ -lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -lean_dec(x_12); -x_26 = l_Lean_nullKind; -x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_11); -x_28 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, 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; -x_30 = l_Lean_Parser_ParserState_restore(x_18, x_11, x_12); -x_31 = l_Lean_nullKind; -x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_11); -x_33 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_7); -return x_34; -} -} -} -else -{ -lean_object* x_35; uint8_t x_36; +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_dec(x_16); +x_23 = l_Lean_nullKind; +x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_15); +x_25 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_11); +return x_26; +} +else +{ +lean_object* x_27; uint8_t x_28; +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_16); +lean_dec(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +lean_dec(x_16); +x_29 = l_Lean_nullKind; +x_30 = l_Lean_Parser_ParserState_mkNode(x_21, x_29, x_15); +x_31 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_11); +return x_32; +} +else +{ +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_ParserState_restore(x_21, x_15, x_16); +x_34 = l_Lean_nullKind; +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_15); +x_36 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_11); +return x_37; +} +} +} +else +{ +lean_object* x_38; uint8_t x_39; +lean_dec(x_19); lean_dec(x_1); -x_35 = lean_ctor_get(x_15, 1); -lean_inc(x_35); -x_36 = lean_nat_dec_eq(x_35, x_12); -lean_dec(x_35); -if (x_36 == 0) +x_38 = lean_ctor_get(x_18, 1); +lean_inc(x_38); +x_39 = lean_nat_dec_eq(x_38, x_16); +lean_dec(x_38); +if (x_39 == 0) { -lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; -lean_dec(x_12); -x_37 = l_Lean_nullKind; -x_38 = l_Lean_Parser_ParserState_mkNode(x_15, x_37, x_11); -x_39 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, 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; -x_41 = l_Lean_Parser_ParserState_restore(x_15, x_11, x_12); -x_42 = l_Lean_nullKind; +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_dec(x_16); +x_40 = l_Lean_nullKind; +x_41 = l_Lean_Parser_ParserState_mkNode(x_18, x_40, x_15); +x_42 = l_Lean_Parser_Term_type___elambda__1___closed__2; x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_11); -x_44 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_7); -return x_45; +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_44 = l_Lean_Parser_ParserState_restore(x_18, x_15, x_16); +x_45 = l_Lean_nullKind; +x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15); +x_47 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_11); +return x_48; +} +} +} +else +{ +lean_object* x_49; lean_object* x_50; +lean_dec(x_13); +lean_dec(x_1); +x_49 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_50 = l_Lean_Parser_ParserState_mkNode(x_12, x_49, x_11); +return x_50; } } } else { -lean_object* x_46; lean_object* x_47; lean_dec(x_9); lean_dec(x_1); -x_46 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_47 = l_Lean_Parser_ParserState_mkNode(x_8, x_46, x_7); -return x_47; -} +return x_8; } } else { -lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; -x_63 = lean_ctor_get(x_2, 0); -lean_inc(x_63); -x_64 = lean_array_get_size(x_63); -lean_dec(x_63); -x_65 = lean_ctor_get(x_2, 1); -lean_inc(x_65); -lean_inc(x_1); -x_66 = lean_apply_2(x_4, x_1, x_2); -x_67 = lean_ctor_get(x_66, 3); -lean_inc(x_67); -if (lean_obj_tag(x_67) == 0) -{ -lean_dec(x_65); -lean_dec(x_64); -lean_dec(x_1); -return x_66; -} -else -{ -lean_object* x_68; lean_object* x_69; uint8_t x_70; -x_68 = lean_ctor_get(x_67, 0); +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_2, 0); +lean_inc(x_66); +x_67 = lean_array_get_size(x_66); +lean_dec(x_66); +x_68 = lean_ctor_get(x_2, 1); lean_inc(x_68); -lean_dec(x_67); -x_69 = lean_ctor_get(x_66, 1); -lean_inc(x_69); -x_70 = lean_nat_dec_eq(x_69, x_65); -lean_dec(x_69); -if (x_70 == 0) +lean_inc(x_1); +x_69 = lean_apply_2(x_4, x_1, x_2); +x_70 = lean_ctor_get(x_69, 3); +lean_inc(x_70); +if (lean_obj_tag(x_70) == 0) { lean_dec(x_68); -lean_dec(x_65); -lean_dec(x_64); +lean_dec(x_67); lean_dec(x_1); -return x_66; +return x_69; } else { -lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_121; lean_object* x_122; -lean_inc(x_65); -x_71 = l_Lean_Parser_ParserState_restore(x_66, x_64, x_65); -lean_dec(x_64); -x_72 = lean_ctor_get(x_71, 0); +lean_object* x_71; lean_object* x_72; uint8_t x_73; +x_71 = lean_ctor_get(x_70, 0); +lean_inc(x_71); +lean_dec(x_70); +x_72 = lean_ctor_get(x_69, 1); lean_inc(x_72); -x_73 = lean_array_get_size(x_72); +x_73 = lean_nat_dec_eq(x_72, x_68); lean_dec(x_72); +if (x_73 == 0) +{ +lean_dec(x_71); +lean_dec(x_68); +lean_dec(x_67); +lean_dec(x_1); +return x_69; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +lean_inc(x_68); +x_74 = l_Lean_Parser_ParserState_restore(x_69, x_67, x_68); +lean_dec(x_67); +x_75 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_76 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_77 = l_Lean_Parser_checkRbpLtFn(x_75, x_76, x_1, x_74); +x_78 = lean_ctor_get(x_77, 3); +lean_inc(x_78); +if (lean_obj_tag(x_78) == 0) +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_127; lean_object* x_128; lean_object* x_129; +x_79 = lean_ctor_get(x_77, 0); +lean_inc(x_79); +x_80 = lean_array_get_size(x_79); +lean_dec(x_79); +x_127 = lean_ctor_get(x_77, 1); +lean_inc(x_127); lean_inc(x_1); -x_121 = l_Lean_Parser_tokenFn(x_1, x_71); -x_122 = lean_ctor_get(x_121, 3); -lean_inc(x_122); -if (lean_obj_tag(x_122) == 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_checkStackTopFn___spec__1(x_123); -lean_dec(x_123); -if (lean_obj_tag(x_124) == 2) -{ -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_type___elambda__1___closed__6; -x_127 = lean_string_dec_eq(x_125, x_126); -lean_dec(x_125); -if (x_127 == 0) -{ -lean_object* x_128; lean_object* x_129; -x_128 = l_Lean_Parser_Term_type___elambda__1___closed__9; -lean_inc(x_65); -x_129 = l_Lean_Parser_ParserState_mkErrorsAt(x_121, x_128, x_65); -x_74 = x_129; -goto block_120; -} -else -{ -x_74 = x_121; -goto block_120; -} -} -else +x_128 = l_Lean_Parser_tokenFn(x_1, x_77); +x_129 = lean_ctor_get(x_128, 3); +lean_inc(x_129); +if (lean_obj_tag(x_129) == 0) { lean_object* x_130; lean_object* x_131; -lean_dec(x_124); -x_130 = l_Lean_Parser_Term_type___elambda__1___closed__9; -lean_inc(x_65); -x_131 = l_Lean_Parser_ParserState_mkErrorsAt(x_121, x_130, x_65); -x_74 = x_131; -goto block_120; +x_130 = lean_ctor_get(x_128, 0); +lean_inc(x_130); +x_131 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_130); +lean_dec(x_130); +if (lean_obj_tag(x_131) == 2) +{ +lean_object* x_132; lean_object* x_133; uint8_t x_134; +x_132 = lean_ctor_get(x_131, 1); +lean_inc(x_132); +lean_dec(x_131); +x_133 = l_Lean_Parser_Term_type___elambda__1___closed__6; +x_134 = lean_string_dec_eq(x_132, x_133); +lean_dec(x_132); +if (x_134 == 0) +{ +lean_object* x_135; lean_object* x_136; +x_135 = l_Lean_Parser_Term_type___elambda__1___closed__9; +x_136 = l_Lean_Parser_ParserState_mkErrorsAt(x_128, x_135, x_127); +x_81 = x_136; +goto block_126; +} +else +{ +lean_dec(x_127); +x_81 = x_128; +goto block_126; } } else { -lean_object* x_132; lean_object* x_133; -lean_dec(x_122); -x_132 = l_Lean_Parser_Term_type___elambda__1___closed__9; -lean_inc(x_65); -x_133 = l_Lean_Parser_ParserState_mkErrorsAt(x_121, x_132, x_65); -x_74 = x_133; -goto block_120; +lean_object* x_137; lean_object* x_138; +lean_dec(x_131); +x_137 = l_Lean_Parser_Term_type___elambda__1___closed__9; +x_138 = l_Lean_Parser_ParserState_mkErrorsAt(x_128, x_137, x_127); +x_81 = x_138; +goto block_126; } -block_120: +} +else { -lean_object* x_75; -x_75 = lean_ctor_get(x_74, 3); -lean_inc(x_75); -if (lean_obj_tag(x_75) == 0) +lean_object* x_139; lean_object* x_140; +lean_dec(x_129); +x_139 = l_Lean_Parser_Term_type___elambda__1___closed__9; +x_140 = l_Lean_Parser_ParserState_mkErrorsAt(x_128, x_139, x_127); +x_81 = x_140; +goto block_126; +} +block_126: { -lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_76 = lean_ctor_get(x_74, 0); -lean_inc(x_76); -x_77 = lean_array_get_size(x_76); -lean_dec(x_76); -x_78 = lean_ctor_get(x_74, 1); -lean_inc(x_78); -x_79 = l_Lean_Parser_appPrec; -x_80 = l_Lean_Parser_leadingNodePrec___closed__1; -x_81 = l_Lean_Parser_checkRbpLtFn(x_79, x_80, x_1, x_74); +lean_object* x_82; x_82 = lean_ctor_get(x_81, 3); lean_inc(x_82); if (lean_obj_tag(x_82) == 0) { -lean_object* x_83; lean_object* x_84; lean_object* x_85; -x_83 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_84 = l_Lean_Parser_categoryParser___elambda__1(x_83, x_79, x_1, x_81); -x_85 = lean_ctor_get(x_84, 3); +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_83 = lean_ctor_get(x_81, 0); +lean_inc(x_83); +x_84 = lean_array_get_size(x_83); +lean_dec(x_83); +x_85 = lean_ctor_get(x_81, 1); lean_inc(x_85); -if (lean_obj_tag(x_85) == 0) +x_86 = l_Lean_Parser_appPrec; +x_87 = l_Lean_Parser_checkRbpLtFn(x_86, x_76, x_1, x_81); +x_88 = lean_ctor_get(x_87, 3); +lean_inc(x_88); +if (lean_obj_tag(x_88) == 0) { -lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; -lean_dec(x_78); -x_86 = l_Lean_nullKind; -x_87 = l_Lean_Parser_ParserState_mkNode(x_84, x_86, x_77); -x_88 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_73); -x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_68, x_65); -lean_dec(x_65); -return x_90; -} -else -{ -lean_object* x_91; uint8_t x_92; -lean_dec(x_85); -x_91 = lean_ctor_get(x_84, 1); +lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_89 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_90 = l_Lean_Parser_categoryParser___elambda__1(x_89, x_86, x_1, x_87); +x_91 = lean_ctor_get(x_90, 3); lean_inc(x_91); -x_92 = lean_nat_dec_eq(x_91, x_78); -lean_dec(x_91); -if (x_92 == 0) +if (lean_obj_tag(x_91) == 0) { -lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; -lean_dec(x_78); -x_93 = l_Lean_nullKind; -x_94 = l_Lean_Parser_ParserState_mkNode(x_84, x_93, x_77); -x_95 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_73); -x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_68, x_65); -lean_dec(x_65); -return x_97; +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_85); +x_92 = l_Lean_nullKind; +x_93 = l_Lean_Parser_ParserState_mkNode(x_90, x_92, x_84); +x_94 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_95 = l_Lean_Parser_ParserState_mkNode(x_93, x_94, x_80); +x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_71, x_68); +lean_dec(x_68); +return x_96; } else { -lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; -x_98 = l_Lean_Parser_ParserState_restore(x_84, x_77, x_78); +lean_object* x_97; uint8_t x_98; +lean_dec(x_91); +x_97 = lean_ctor_get(x_90, 1); +lean_inc(x_97); +x_98 = lean_nat_dec_eq(x_97, x_85); +lean_dec(x_97); +if (x_98 == 0) +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +lean_dec(x_85); x_99 = l_Lean_nullKind; -x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_77); +x_100 = l_Lean_Parser_ParserState_mkNode(x_90, x_99, x_84); x_101 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_73); -x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_68, x_65); -lean_dec(x_65); +x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_80); +x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_71, x_68); +lean_dec(x_68); return x_103; } +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_104 = l_Lean_Parser_ParserState_restore(x_90, x_84, x_85); +x_105 = l_Lean_nullKind; +x_106 = l_Lean_Parser_ParserState_mkNode(x_104, x_105, x_84); +x_107 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_108 = l_Lean_Parser_ParserState_mkNode(x_106, x_107, x_80); +x_109 = l_Lean_Parser_mergeOrElseErrors(x_108, x_71, x_68); +lean_dec(x_68); +return x_109; +} } } else { -lean_object* x_104; uint8_t x_105; -lean_dec(x_82); +lean_object* x_110; uint8_t x_111; +lean_dec(x_88); lean_dec(x_1); -x_104 = lean_ctor_get(x_81, 1); -lean_inc(x_104); -x_105 = lean_nat_dec_eq(x_104, x_78); -lean_dec(x_104); -if (x_105 == 0) +x_110 = lean_ctor_get(x_87, 1); +lean_inc(x_110); +x_111 = lean_nat_dec_eq(x_110, x_85); +lean_dec(x_110); +if (x_111 == 0) { -lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; -lean_dec(x_78); -x_106 = l_Lean_nullKind; -x_107 = l_Lean_Parser_ParserState_mkNode(x_81, x_106, x_77); -x_108 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_109 = l_Lean_Parser_ParserState_mkNode(x_107, x_108, x_73); -x_110 = l_Lean_Parser_mergeOrElseErrors(x_109, x_68, x_65); -lean_dec(x_65); -return x_110; -} -else -{ -lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; -x_111 = l_Lean_Parser_ParserState_restore(x_81, x_77, x_78); +lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; +lean_dec(x_85); x_112 = l_Lean_nullKind; -x_113 = l_Lean_Parser_ParserState_mkNode(x_111, x_112, x_77); +x_113 = l_Lean_Parser_ParserState_mkNode(x_87, x_112, x_84); x_114 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_115 = l_Lean_Parser_ParserState_mkNode(x_113, x_114, x_73); -x_116 = l_Lean_Parser_mergeOrElseErrors(x_115, x_68, x_65); -lean_dec(x_65); +x_115 = l_Lean_Parser_ParserState_mkNode(x_113, x_114, x_80); +x_116 = l_Lean_Parser_mergeOrElseErrors(x_115, x_71, x_68); +lean_dec(x_68); return x_116; } +else +{ +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_117 = l_Lean_Parser_ParserState_restore(x_87, x_84, x_85); +x_118 = l_Lean_nullKind; +x_119 = l_Lean_Parser_ParserState_mkNode(x_117, x_118, x_84); +x_120 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_121 = l_Lean_Parser_ParserState_mkNode(x_119, x_120, x_80); +x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_71, x_68); +lean_dec(x_68); +return x_122; +} } } else { -lean_object* x_117; lean_object* x_118; lean_object* x_119; -lean_dec(x_75); +lean_object* x_123; lean_object* x_124; lean_object* x_125; +lean_dec(x_82); lean_dec(x_1); -x_117 = l_Lean_Parser_Term_type___elambda__1___closed__2; -x_118 = l_Lean_Parser_ParserState_mkNode(x_74, x_117, x_73); -x_119 = l_Lean_Parser_mergeOrElseErrors(x_118, x_68, x_65); -lean_dec(x_65); -return x_119; +x_123 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_124 = l_Lean_Parser_ParserState_mkNode(x_81, x_123, x_80); +x_125 = l_Lean_Parser_mergeOrElseErrors(x_124, x_71, x_68); +lean_dec(x_68); +return x_125; } } } +else +{ +lean_object* x_141; +lean_dec(x_78); +lean_dec(x_1); +x_141 = l_Lean_Parser_mergeOrElseErrors(x_77, x_71, x_68); +lean_dec(x_68); +return x_141; +} +} } } } @@ -6007,11 +6277,10 @@ return x_119; lean_object* _init_l_Lean_Parser_Term_type___closed__1() { _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_type___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_type___closed__2() { @@ -6058,16 +6327,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_type___closed__6() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_type___closed__5; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_type___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_type___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_type___closed__5; +x_3 = l_Lean_Parser_Term_type___closed__6; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_type___closed__7() { +lean_object* _init_l_Lean_Parser_Term_type___closed__8() { _start: { lean_object* x_1; @@ -6075,12 +6354,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_type___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_type___closed__8() { +lean_object* _init_l_Lean_Parser_Term_type___closed__9() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_type___closed__6; -x_2 = l_Lean_Parser_Term_type___closed__7; +x_1 = l_Lean_Parser_Term_type___closed__7; +x_2 = l_Lean_Parser_Term_type___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); @@ -6091,7 +6370,7 @@ lean_object* _init_l_Lean_Parser_Term_type() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_type___closed__8; +x_1 = l_Lean_Parser_Term_type___closed__9; return x_1; } } @@ -6207,400 +6486,431 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_49; lean_object* x_50; lean_object* x_51; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_49 = lean_ctor_get(x_2, 1); -lean_inc(x_49); -lean_inc(x_1); -x_50 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_52 = lean_ctor_get(x_50, 0); -lean_inc(x_52); -x_53 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_52); -lean_dec(x_52); -if (lean_obj_tag(x_53) == 2) -{ -lean_object* x_54; lean_object* x_55; uint8_t x_56; -x_54 = lean_ctor_get(x_53, 1); -lean_inc(x_54); -lean_dec(x_53); -x_55 = l_Lean_Parser_Term_sort___elambda__1___closed__6; -x_56 = lean_string_dec_eq(x_54, x_55); -lean_dec(x_54); -if (x_56 == 0) -{ -lean_object* x_57; lean_object* x_58; -x_57 = l_Lean_Parser_Term_sort___elambda__1___closed__9; -x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_57, x_49); -x_8 = x_58; -goto block_48; -} -else -{ -lean_dec(x_49); -x_8 = x_50; -goto block_48; -} -} -else -{ -lean_object* x_59; lean_object* x_60; -lean_dec(x_53); -x_59 = l_Lean_Parser_Term_sort___elambda__1___closed__9; -x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_59, x_49); -x_8 = x_60; -goto block_48; -} -} -else -{ -lean_object* x_61; lean_object* x_62; -lean_dec(x_51); -x_61 = l_Lean_Parser_Term_sort___elambda__1___closed__9; -x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_61, x_49); -x_8 = x_62; -goto block_48; -} -block_48: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_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_10; lean_object* x_11; lean_object* x_12; lean_object* x_52; lean_object* x_53; lean_object* x_54; 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_13 = l_Lean_Parser_appPrec; -x_14 = l_Lean_Parser_leadingNodePrec___closed__1; -x_15 = l_Lean_Parser_checkRbpLtFn(x_13, x_14, x_1, x_8); -x_16 = lean_ctor_get(x_15, 3); -lean_inc(x_16); -if (lean_obj_tag(x_16) == 0) +x_52 = lean_ctor_get(x_8, 1); +lean_inc(x_52); +lean_inc(x_1); +x_53 = l_Lean_Parser_tokenFn(x_1, x_8); +x_54 = lean_ctor_get(x_53, 3); +lean_inc(x_54); +if (lean_obj_tag(x_54) == 0) { -lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_17 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_18 = l_Lean_Parser_categoryParser___elambda__1(x_17, x_13, x_1, x_15); +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_checkStackTopFn___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_Term_sort___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_Term_sort___elambda__1___closed__9; +x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_60, x_52); +x_12 = x_61; +goto block_51; +} +else +{ +lean_dec(x_52); +x_12 = x_53; +goto block_51; +} +} +else +{ +lean_object* x_62; lean_object* x_63; +lean_dec(x_56); +x_62 = l_Lean_Parser_Term_sort___elambda__1___closed__9; +x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_62, x_52); +x_12 = x_63; +goto block_51; +} +} +else +{ +lean_object* x_64; lean_object* x_65; +lean_dec(x_54); +x_64 = l_Lean_Parser_Term_sort___elambda__1___closed__9; +x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_53, x_64, x_52); +x_12 = x_65; +goto block_51; +} +block_51: +{ +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_18; lean_object* x_19; +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 = l_Lean_Parser_appPrec; +x_18 = l_Lean_Parser_checkRbpLtFn(x_17, x_7, x_1, x_12); 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_dec(x_12); -x_20 = l_Lean_nullKind; -x_21 = l_Lean_Parser_ParserState_mkNode(x_18, x_20, x_11); -x_22 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_7); -return x_23; -} -else +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_21 = l_Lean_Parser_categoryParser___elambda__1(x_20, x_17, 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_24; uint8_t x_25; -lean_dec(x_19); -x_24 = lean_ctor_get(x_18, 1); -lean_inc(x_24); -x_25 = lean_nat_dec_eq(x_24, x_12); -lean_dec(x_24); -if (x_25 == 0) -{ -lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -lean_dec(x_12); -x_26 = l_Lean_nullKind; -x_27 = l_Lean_Parser_ParserState_mkNode(x_18, x_26, x_11); -x_28 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, 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; -x_30 = l_Lean_Parser_ParserState_restore(x_18, x_11, x_12); -x_31 = l_Lean_nullKind; -x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_11); -x_33 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_7); -return x_34; -} -} -} -else -{ -lean_object* x_35; uint8_t x_36; +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_dec(x_16); +x_23 = l_Lean_nullKind; +x_24 = l_Lean_Parser_ParserState_mkNode(x_21, x_23, x_15); +x_25 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_11); +return x_26; +} +else +{ +lean_object* x_27; uint8_t x_28; +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_16); +lean_dec(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +lean_dec(x_16); +x_29 = l_Lean_nullKind; +x_30 = l_Lean_Parser_ParserState_mkNode(x_21, x_29, x_15); +x_31 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_11); +return x_32; +} +else +{ +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_ParserState_restore(x_21, x_15, x_16); +x_34 = l_Lean_nullKind; +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_15); +x_36 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_11); +return x_37; +} +} +} +else +{ +lean_object* x_38; uint8_t x_39; +lean_dec(x_19); lean_dec(x_1); -x_35 = lean_ctor_get(x_15, 1); -lean_inc(x_35); -x_36 = lean_nat_dec_eq(x_35, x_12); -lean_dec(x_35); -if (x_36 == 0) +x_38 = lean_ctor_get(x_18, 1); +lean_inc(x_38); +x_39 = lean_nat_dec_eq(x_38, x_16); +lean_dec(x_38); +if (x_39 == 0) { -lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; -lean_dec(x_12); -x_37 = l_Lean_nullKind; -x_38 = l_Lean_Parser_ParserState_mkNode(x_15, x_37, x_11); -x_39 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, 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; -x_41 = l_Lean_Parser_ParserState_restore(x_15, x_11, x_12); -x_42 = l_Lean_nullKind; +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_dec(x_16); +x_40 = l_Lean_nullKind; +x_41 = l_Lean_Parser_ParserState_mkNode(x_18, x_40, x_15); +x_42 = l_Lean_Parser_Term_sort___elambda__1___closed__2; x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_11); -x_44 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_7); -return x_45; +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_44 = l_Lean_Parser_ParserState_restore(x_18, x_15, x_16); +x_45 = l_Lean_nullKind; +x_46 = l_Lean_Parser_ParserState_mkNode(x_44, x_45, x_15); +x_47 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_48 = l_Lean_Parser_ParserState_mkNode(x_46, x_47, x_11); +return x_48; +} +} +} +else +{ +lean_object* x_49; lean_object* x_50; +lean_dec(x_13); +lean_dec(x_1); +x_49 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_50 = l_Lean_Parser_ParserState_mkNode(x_12, x_49, x_11); +return x_50; } } } else { -lean_object* x_46; lean_object* x_47; lean_dec(x_9); lean_dec(x_1); -x_46 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_47 = l_Lean_Parser_ParserState_mkNode(x_8, x_46, x_7); -return x_47; -} +return x_8; } } else { -lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; -x_63 = lean_ctor_get(x_2, 0); -lean_inc(x_63); -x_64 = lean_array_get_size(x_63); -lean_dec(x_63); -x_65 = lean_ctor_get(x_2, 1); -lean_inc(x_65); -lean_inc(x_1); -x_66 = lean_apply_2(x_4, x_1, x_2); -x_67 = lean_ctor_get(x_66, 3); -lean_inc(x_67); -if (lean_obj_tag(x_67) == 0) -{ -lean_dec(x_65); -lean_dec(x_64); -lean_dec(x_1); -return x_66; -} -else -{ -lean_object* x_68; lean_object* x_69; uint8_t x_70; -x_68 = lean_ctor_get(x_67, 0); +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_2, 0); +lean_inc(x_66); +x_67 = lean_array_get_size(x_66); +lean_dec(x_66); +x_68 = lean_ctor_get(x_2, 1); lean_inc(x_68); -lean_dec(x_67); -x_69 = lean_ctor_get(x_66, 1); -lean_inc(x_69); -x_70 = lean_nat_dec_eq(x_69, x_65); -lean_dec(x_69); -if (x_70 == 0) +lean_inc(x_1); +x_69 = lean_apply_2(x_4, x_1, x_2); +x_70 = lean_ctor_get(x_69, 3); +lean_inc(x_70); +if (lean_obj_tag(x_70) == 0) { lean_dec(x_68); -lean_dec(x_65); -lean_dec(x_64); +lean_dec(x_67); lean_dec(x_1); -return x_66; +return x_69; } else { -lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_121; lean_object* x_122; -lean_inc(x_65); -x_71 = l_Lean_Parser_ParserState_restore(x_66, x_64, x_65); -lean_dec(x_64); -x_72 = lean_ctor_get(x_71, 0); +lean_object* x_71; lean_object* x_72; uint8_t x_73; +x_71 = lean_ctor_get(x_70, 0); +lean_inc(x_71); +lean_dec(x_70); +x_72 = lean_ctor_get(x_69, 1); lean_inc(x_72); -x_73 = lean_array_get_size(x_72); +x_73 = lean_nat_dec_eq(x_72, x_68); lean_dec(x_72); +if (x_73 == 0) +{ +lean_dec(x_71); +lean_dec(x_68); +lean_dec(x_67); +lean_dec(x_1); +return x_69; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +lean_inc(x_68); +x_74 = l_Lean_Parser_ParserState_restore(x_69, x_67, x_68); +lean_dec(x_67); +x_75 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_76 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_77 = l_Lean_Parser_checkRbpLtFn(x_75, x_76, x_1, x_74); +x_78 = lean_ctor_get(x_77, 3); +lean_inc(x_78); +if (lean_obj_tag(x_78) == 0) +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_127; lean_object* x_128; lean_object* x_129; +x_79 = lean_ctor_get(x_77, 0); +lean_inc(x_79); +x_80 = lean_array_get_size(x_79); +lean_dec(x_79); +x_127 = lean_ctor_get(x_77, 1); +lean_inc(x_127); lean_inc(x_1); -x_121 = l_Lean_Parser_tokenFn(x_1, x_71); -x_122 = lean_ctor_get(x_121, 3); -lean_inc(x_122); -if (lean_obj_tag(x_122) == 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_checkStackTopFn___spec__1(x_123); -lean_dec(x_123); -if (lean_obj_tag(x_124) == 2) -{ -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_sort___elambda__1___closed__6; -x_127 = lean_string_dec_eq(x_125, x_126); -lean_dec(x_125); -if (x_127 == 0) -{ -lean_object* x_128; lean_object* x_129; -x_128 = l_Lean_Parser_Term_sort___elambda__1___closed__9; -lean_inc(x_65); -x_129 = l_Lean_Parser_ParserState_mkErrorsAt(x_121, x_128, x_65); -x_74 = x_129; -goto block_120; -} -else -{ -x_74 = x_121; -goto block_120; -} -} -else +x_128 = l_Lean_Parser_tokenFn(x_1, x_77); +x_129 = lean_ctor_get(x_128, 3); +lean_inc(x_129); +if (lean_obj_tag(x_129) == 0) { lean_object* x_130; lean_object* x_131; -lean_dec(x_124); -x_130 = l_Lean_Parser_Term_sort___elambda__1___closed__9; -lean_inc(x_65); -x_131 = l_Lean_Parser_ParserState_mkErrorsAt(x_121, x_130, x_65); -x_74 = x_131; -goto block_120; +x_130 = lean_ctor_get(x_128, 0); +lean_inc(x_130); +x_131 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_130); +lean_dec(x_130); +if (lean_obj_tag(x_131) == 2) +{ +lean_object* x_132; lean_object* x_133; uint8_t x_134; +x_132 = lean_ctor_get(x_131, 1); +lean_inc(x_132); +lean_dec(x_131); +x_133 = l_Lean_Parser_Term_sort___elambda__1___closed__6; +x_134 = lean_string_dec_eq(x_132, x_133); +lean_dec(x_132); +if (x_134 == 0) +{ +lean_object* x_135; lean_object* x_136; +x_135 = l_Lean_Parser_Term_sort___elambda__1___closed__9; +x_136 = l_Lean_Parser_ParserState_mkErrorsAt(x_128, x_135, x_127); +x_81 = x_136; +goto block_126; +} +else +{ +lean_dec(x_127); +x_81 = x_128; +goto block_126; } } else { -lean_object* x_132; lean_object* x_133; -lean_dec(x_122); -x_132 = l_Lean_Parser_Term_sort___elambda__1___closed__9; -lean_inc(x_65); -x_133 = l_Lean_Parser_ParserState_mkErrorsAt(x_121, x_132, x_65); -x_74 = x_133; -goto block_120; +lean_object* x_137; lean_object* x_138; +lean_dec(x_131); +x_137 = l_Lean_Parser_Term_sort___elambda__1___closed__9; +x_138 = l_Lean_Parser_ParserState_mkErrorsAt(x_128, x_137, x_127); +x_81 = x_138; +goto block_126; } -block_120: +} +else { -lean_object* x_75; -x_75 = lean_ctor_get(x_74, 3); -lean_inc(x_75); -if (lean_obj_tag(x_75) == 0) +lean_object* x_139; lean_object* x_140; +lean_dec(x_129); +x_139 = l_Lean_Parser_Term_sort___elambda__1___closed__9; +x_140 = l_Lean_Parser_ParserState_mkErrorsAt(x_128, x_139, x_127); +x_81 = x_140; +goto block_126; +} +block_126: { -lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_76 = lean_ctor_get(x_74, 0); -lean_inc(x_76); -x_77 = lean_array_get_size(x_76); -lean_dec(x_76); -x_78 = lean_ctor_get(x_74, 1); -lean_inc(x_78); -x_79 = l_Lean_Parser_appPrec; -x_80 = l_Lean_Parser_leadingNodePrec___closed__1; -x_81 = l_Lean_Parser_checkRbpLtFn(x_79, x_80, x_1, x_74); +lean_object* x_82; x_82 = lean_ctor_get(x_81, 3); lean_inc(x_82); if (lean_obj_tag(x_82) == 0) { -lean_object* x_83; lean_object* x_84; lean_object* x_85; -x_83 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_84 = l_Lean_Parser_categoryParser___elambda__1(x_83, x_79, x_1, x_81); -x_85 = lean_ctor_get(x_84, 3); +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_83 = lean_ctor_get(x_81, 0); +lean_inc(x_83); +x_84 = lean_array_get_size(x_83); +lean_dec(x_83); +x_85 = lean_ctor_get(x_81, 1); lean_inc(x_85); -if (lean_obj_tag(x_85) == 0) +x_86 = l_Lean_Parser_appPrec; +x_87 = l_Lean_Parser_checkRbpLtFn(x_86, x_76, x_1, x_81); +x_88 = lean_ctor_get(x_87, 3); +lean_inc(x_88); +if (lean_obj_tag(x_88) == 0) { -lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; -lean_dec(x_78); -x_86 = l_Lean_nullKind; -x_87 = l_Lean_Parser_ParserState_mkNode(x_84, x_86, x_77); -x_88 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_73); -x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_68, x_65); -lean_dec(x_65); -return x_90; -} -else -{ -lean_object* x_91; uint8_t x_92; -lean_dec(x_85); -x_91 = lean_ctor_get(x_84, 1); +lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_89 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_90 = l_Lean_Parser_categoryParser___elambda__1(x_89, x_86, x_1, x_87); +x_91 = lean_ctor_get(x_90, 3); lean_inc(x_91); -x_92 = lean_nat_dec_eq(x_91, x_78); -lean_dec(x_91); -if (x_92 == 0) +if (lean_obj_tag(x_91) == 0) { -lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; -lean_dec(x_78); -x_93 = l_Lean_nullKind; -x_94 = l_Lean_Parser_ParserState_mkNode(x_84, x_93, x_77); -x_95 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_73); -x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_68, x_65); -lean_dec(x_65); -return x_97; +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_85); +x_92 = l_Lean_nullKind; +x_93 = l_Lean_Parser_ParserState_mkNode(x_90, x_92, x_84); +x_94 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_95 = l_Lean_Parser_ParserState_mkNode(x_93, x_94, x_80); +x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_71, x_68); +lean_dec(x_68); +return x_96; } else { -lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; -x_98 = l_Lean_Parser_ParserState_restore(x_84, x_77, x_78); +lean_object* x_97; uint8_t x_98; +lean_dec(x_91); +x_97 = lean_ctor_get(x_90, 1); +lean_inc(x_97); +x_98 = lean_nat_dec_eq(x_97, x_85); +lean_dec(x_97); +if (x_98 == 0) +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +lean_dec(x_85); x_99 = l_Lean_nullKind; -x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_77); +x_100 = l_Lean_Parser_ParserState_mkNode(x_90, x_99, x_84); x_101 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_73); -x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_68, x_65); -lean_dec(x_65); +x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_80); +x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_71, x_68); +lean_dec(x_68); return x_103; } +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_104 = l_Lean_Parser_ParserState_restore(x_90, x_84, x_85); +x_105 = l_Lean_nullKind; +x_106 = l_Lean_Parser_ParserState_mkNode(x_104, x_105, x_84); +x_107 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_108 = l_Lean_Parser_ParserState_mkNode(x_106, x_107, x_80); +x_109 = l_Lean_Parser_mergeOrElseErrors(x_108, x_71, x_68); +lean_dec(x_68); +return x_109; +} } } else { -lean_object* x_104; uint8_t x_105; -lean_dec(x_82); +lean_object* x_110; uint8_t x_111; +lean_dec(x_88); lean_dec(x_1); -x_104 = lean_ctor_get(x_81, 1); -lean_inc(x_104); -x_105 = lean_nat_dec_eq(x_104, x_78); -lean_dec(x_104); -if (x_105 == 0) +x_110 = lean_ctor_get(x_87, 1); +lean_inc(x_110); +x_111 = lean_nat_dec_eq(x_110, x_85); +lean_dec(x_110); +if (x_111 == 0) { -lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; -lean_dec(x_78); -x_106 = l_Lean_nullKind; -x_107 = l_Lean_Parser_ParserState_mkNode(x_81, x_106, x_77); -x_108 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_109 = l_Lean_Parser_ParserState_mkNode(x_107, x_108, x_73); -x_110 = l_Lean_Parser_mergeOrElseErrors(x_109, x_68, x_65); -lean_dec(x_65); -return x_110; -} -else -{ -lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; -x_111 = l_Lean_Parser_ParserState_restore(x_81, x_77, x_78); +lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; +lean_dec(x_85); x_112 = l_Lean_nullKind; -x_113 = l_Lean_Parser_ParserState_mkNode(x_111, x_112, x_77); +x_113 = l_Lean_Parser_ParserState_mkNode(x_87, x_112, x_84); x_114 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_115 = l_Lean_Parser_ParserState_mkNode(x_113, x_114, x_73); -x_116 = l_Lean_Parser_mergeOrElseErrors(x_115, x_68, x_65); -lean_dec(x_65); +x_115 = l_Lean_Parser_ParserState_mkNode(x_113, x_114, x_80); +x_116 = l_Lean_Parser_mergeOrElseErrors(x_115, x_71, x_68); +lean_dec(x_68); return x_116; } +else +{ +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_117 = l_Lean_Parser_ParserState_restore(x_87, x_84, x_85); +x_118 = l_Lean_nullKind; +x_119 = l_Lean_Parser_ParserState_mkNode(x_117, x_118, x_84); +x_120 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_121 = l_Lean_Parser_ParserState_mkNode(x_119, x_120, x_80); +x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_71, x_68); +lean_dec(x_68); +return x_122; +} } } else { -lean_object* x_117; lean_object* x_118; lean_object* x_119; -lean_dec(x_75); +lean_object* x_123; lean_object* x_124; lean_object* x_125; +lean_dec(x_82); lean_dec(x_1); -x_117 = l_Lean_Parser_Term_sort___elambda__1___closed__2; -x_118 = l_Lean_Parser_ParserState_mkNode(x_74, x_117, x_73); -x_119 = l_Lean_Parser_mergeOrElseErrors(x_118, x_68, x_65); -lean_dec(x_65); -return x_119; +x_123 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_124 = l_Lean_Parser_ParserState_mkNode(x_81, x_123, x_80); +x_125 = l_Lean_Parser_mergeOrElseErrors(x_124, x_71, x_68); +lean_dec(x_68); +return x_125; } } } +else +{ +lean_object* x_141; +lean_dec(x_78); +lean_dec(x_1); +x_141 = l_Lean_Parser_mergeOrElseErrors(x_77, x_71, x_68); +lean_dec(x_68); +return x_141; +} +} } } } @@ -6608,11 +6918,10 @@ return x_119; lean_object* _init_l_Lean_Parser_Term_sort___closed__1() { _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_sort___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_sort___closed__2() { @@ -6638,16 +6947,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_sort___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_sort___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_sort___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_sort___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_sort___closed__3; +x_3 = l_Lean_Parser_Term_sort___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_sort___closed__5() { +lean_object* _init_l_Lean_Parser_Term_sort___closed__6() { _start: { lean_object* x_1; @@ -6655,12 +6974,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sort___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_sort___closed__6() { +lean_object* _init_l_Lean_Parser_Term_sort___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_sort___closed__4; -x_2 = l_Lean_Parser_Term_sort___closed__5; +x_1 = l_Lean_Parser_Term_sort___closed__5; +x_2 = l_Lean_Parser_Term_sort___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); @@ -6671,7 +6990,7 @@ lean_object* _init_l_Lean_Parser_Term_sort() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_sort___closed__6; +x_1 = l_Lean_Parser_Term_sort___closed__7; return x_1; } } @@ -6787,188 +7106,221 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = lean_ctor_get(x_2, 1); -lean_inc(x_8); -x_9 = l_Lean_Parser_tokenFn(x_1, x_2); -x_10 = lean_ctor_get(x_9, 3); +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = lean_ctor_get(x_8, 0); lean_inc(x_10); -if (lean_obj_tag(x_10) == 0) +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_13 = l_Lean_Parser_tokenFn(x_1, x_8); +x_14 = lean_ctor_get(x_13, 3); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 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_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_checkStackTopFn___spec__1(x_15); +lean_dec(x_15); +if (lean_obj_tag(x_16) == 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_Lean_Parser_Term_prop___elambda__1___closed__6; -x_15 = lean_string_dec_eq(x_13, x_14); -lean_dec(x_13); -if (x_15 == 0) +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_Lean_Parser_Term_prop___elambda__1___closed__6; +x_19 = lean_string_dec_eq(x_17, x_18); +lean_dec(x_17); +if (x_19 == 0) { -lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_16 = l_Lean_Parser_Term_prop___elambda__1___closed__9; -x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_16, x_8); -x_18 = l_Lean_Parser_Term_prop___elambda__1___closed__2; -x_19 = l_Lean_Parser_ParserState_mkNode(x_17, x_18, x_7); -return x_19; +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_20 = l_Lean_Parser_Term_prop___elambda__1___closed__9; +x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); +x_22 = l_Lean_Parser_Term_prop___elambda__1___closed__2; +x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_11); +return x_23; } else { -lean_object* x_20; lean_object* x_21; -lean_dec(x_8); -x_20 = l_Lean_Parser_Term_prop___elambda__1___closed__2; -x_21 = l_Lean_Parser_ParserState_mkNode(x_9, x_20, x_7); -return x_21; -} -} -else -{ -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_object* x_24; lean_object* x_25; lean_dec(x_12); -x_22 = l_Lean_Parser_Term_prop___elambda__1___closed__9; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_22, x_8); x_24 = l_Lean_Parser_Term_prop___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); +x_25 = l_Lean_Parser_ParserState_mkNode(x_13, x_24, x_11); return x_25; } } else { lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -lean_dec(x_10); +lean_dec(x_16); x_26 = l_Lean_Parser_Term_prop___elambda__1___closed__9; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_26, x_8); +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_Parser_Term_prop___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); return x_29; } } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_30 = lean_ctor_get(x_2, 0); -lean_inc(x_30); -x_31 = lean_array_get_size(x_30); -lean_dec(x_30); -x_32 = lean_ctor_get(x_2, 1); -lean_inc(x_32); -lean_inc(x_1); -x_33 = lean_apply_2(x_4, x_1, x_2); -x_34 = lean_ctor_get(x_33, 3); +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_prop___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_32 = l_Lean_Parser_Term_prop___elambda__1___closed__2; +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); +return x_33; +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_2, 0); lean_inc(x_34); -if (lean_obj_tag(x_34) == 0) -{ -lean_dec(x_32); -lean_dec(x_31); -lean_dec(x_1); -return x_33; -} -else -{ -lean_object* x_35; lean_object* x_36; uint8_t x_37; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); +x_35 = lean_array_get_size(x_34); lean_dec(x_34); -x_36 = lean_ctor_get(x_33, 1); +x_36 = lean_ctor_get(x_2, 1); lean_inc(x_36); -x_37 = lean_nat_dec_eq(x_36, x_32); -lean_dec(x_36); -if (x_37 == 0) +lean_inc(x_1); +x_37 = lean_apply_2(x_4, x_1, x_2); +x_38 = lean_ctor_get(x_37, 3); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) { +lean_dec(x_36); lean_dec(x_35); -lean_dec(x_32); -lean_dec(x_31); lean_dec(x_1); -return x_33; +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_inc(x_32); -x_38 = l_Lean_Parser_ParserState_restore(x_33, x_31, x_32); -lean_dec(x_31); +lean_object* x_39; lean_object* x_40; uint8_t x_41; x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -x_40 = lean_array_get_size(x_39); +lean_dec(x_38); +x_40 = lean_ctor_get(x_37, 1); +lean_inc(x_40); +x_41 = lean_nat_dec_eq(x_40, x_36); +lean_dec(x_40); +if (x_41 == 0) +{ lean_dec(x_39); -x_41 = l_Lean_Parser_tokenFn(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_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_Lean_Parser_Term_prop___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_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_48 = l_Lean_Parser_Term_prop___elambda__1___closed__9; -lean_inc(x_32); -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_32); -x_50 = l_Lean_Parser_Term_prop___elambda__1___closed__2; -x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_40); -x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_35, x_32); -lean_dec(x_32); -return x_52; +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_1); +return x_37; } else { -lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_53 = l_Lean_Parser_Term_prop___elambda__1___closed__2; -x_54 = l_Lean_Parser_ParserState_mkNode(x_41, x_53, x_40); -x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_35, x_32); -lean_dec(x_32); -return x_55; +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_inc(x_36); +x_42 = l_Lean_Parser_ParserState_restore(x_37, x_35, x_36); +lean_dec(x_35); +x_43 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_44 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_45 = l_Lean_Parser_checkRbpLtFn(x_43, 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) +{ +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); +x_48 = lean_array_get_size(x_47); +lean_dec(x_47); +x_49 = lean_ctor_get(x_45, 1); +lean_inc(x_49); +x_50 = l_Lean_Parser_tokenFn(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_52; lean_object* x_53; +x_52 = lean_ctor_get(x_50, 0); +lean_inc(x_52); +x_53 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_52); +lean_dec(x_52); +if (lean_obj_tag(x_53) == 2) +{ +lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_54); +lean_dec(x_53); +x_55 = l_Lean_Parser_Term_prop___elambda__1___closed__6; +x_56 = lean_string_dec_eq(x_54, x_55); +lean_dec(x_54); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = l_Lean_Parser_Term_prop___elambda__1___closed__9; +x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_57, x_49); +x_59 = l_Lean_Parser_Term_prop___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_48); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_39, x_36); +lean_dec(x_36); +return x_61; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_49); +x_62 = l_Lean_Parser_Term_prop___elambda__1___closed__2; +x_63 = l_Lean_Parser_ParserState_mkNode(x_50, x_62, x_48); +x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_39, x_36); +lean_dec(x_36); +return x_64; } } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -lean_dec(x_44); -x_56 = l_Lean_Parser_Term_prop___elambda__1___closed__9; -lean_inc(x_32); -x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_56, x_32); -x_58 = l_Lean_Parser_Term_prop___elambda__1___closed__2; -x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_40); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_35, x_32); -lean_dec(x_32); -return x_60; +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_53); +x_65 = l_Lean_Parser_Term_prop___elambda__1___closed__9; +x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_65, x_49); +x_67 = l_Lean_Parser_Term_prop___elambda__1___closed__2; +x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_48); +x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_39, x_36); +lean_dec(x_36); +return x_69; } } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -lean_dec(x_42); -x_61 = l_Lean_Parser_Term_prop___elambda__1___closed__9; -lean_inc(x_32); -x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_61, x_32); -x_63 = l_Lean_Parser_Term_prop___elambda__1___closed__2; -x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_40); -x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_35, x_32); -lean_dec(x_32); -return x_65; +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_51); +x_70 = l_Lean_Parser_Term_prop___elambda__1___closed__9; +x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_70, x_49); +x_72 = l_Lean_Parser_Term_prop___elambda__1___closed__2; +x_73 = l_Lean_Parser_ParserState_mkNode(x_71, x_72, x_48); +x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_39, x_36); +lean_dec(x_36); +return x_74; +} +} +else +{ +lean_object* x_75; +lean_dec(x_46); +lean_dec(x_1); +x_75 = l_Lean_Parser_mergeOrElseErrors(x_45, x_39, x_36); +lean_dec(x_36); +return x_75; } } } @@ -6978,11 +7330,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Term_prop___closed__1() { _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_prop___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_prop___closed__2() { @@ -6998,16 +7349,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_prop___closed__3() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_prop___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_prop___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_prop___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_prop___closed__2; +x_3 = l_Lean_Parser_Term_prop___closed__3; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_prop___closed__4() { +lean_object* _init_l_Lean_Parser_Term_prop___closed__5() { _start: { lean_object* x_1; @@ -7015,12 +7376,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_prop___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_prop___closed__5() { +lean_object* _init_l_Lean_Parser_Term_prop___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_prop___closed__3; -x_2 = l_Lean_Parser_Term_prop___closed__4; +x_1 = l_Lean_Parser_Term_prop___closed__4; +x_2 = l_Lean_Parser_Term_prop___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); @@ -7031,7 +7392,7 @@ lean_object* _init_l_Lean_Parser_Term_prop() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_prop___closed__5; +x_1 = l_Lean_Parser_Term_prop___closed__6; return x_1; } } @@ -7080,188 +7441,221 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = lean_ctor_get(x_2, 1); -lean_inc(x_8); -x_9 = l_Lean_Parser_tokenFn(x_1, x_2); -x_10 = lean_ctor_get(x_9, 3); +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = lean_ctor_get(x_8, 0); lean_inc(x_10); -if (lean_obj_tag(x_10) == 0) +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_13 = l_Lean_Parser_tokenFn(x_1, x_8); +x_14 = lean_ctor_get(x_13, 3); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 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_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_checkStackTopFn___spec__1(x_15); +lean_dec(x_15); +if (lean_obj_tag(x_16) == 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_Lean_Parser_Level_hole___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_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_Lean_Parser_Level_hole___elambda__1___closed__4; +x_19 = lean_string_dec_eq(x_17, x_18); +lean_dec(x_17); +if (x_19 == 0) { -lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_16 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_16, x_8); -x_18 = l_Lean_mkHole___closed__2; -x_19 = l_Lean_Parser_ParserState_mkNode(x_17, x_18, x_7); -return x_19; +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_20 = l_Lean_Parser_Level_hole___elambda__1___closed__7; +x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); +x_22 = l_Lean_mkHole___closed__2; +x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_11); +return x_23; } else { -lean_object* x_20; lean_object* x_21; -lean_dec(x_8); -x_20 = l_Lean_mkHole___closed__2; -x_21 = l_Lean_Parser_ParserState_mkNode(x_9, x_20, x_7); -return x_21; -} -} -else -{ -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_object* x_24; lean_object* x_25; lean_dec(x_12); -x_22 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_22, x_8); x_24 = l_Lean_mkHole___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); +x_25 = l_Lean_Parser_ParserState_mkNode(x_13, x_24, x_11); return x_25; } } else { lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -lean_dec(x_10); +lean_dec(x_16); x_26 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_26, x_8); +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_mkHole___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); return x_29; } } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_30 = lean_ctor_get(x_2, 0); -lean_inc(x_30); -x_31 = lean_array_get_size(x_30); -lean_dec(x_30); -x_32 = lean_ctor_get(x_2, 1); -lean_inc(x_32); -lean_inc(x_1); -x_33 = lean_apply_2(x_4, x_1, x_2); -x_34 = lean_ctor_get(x_33, 3); +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_Level_hole___elambda__1___closed__7; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_32 = l_Lean_mkHole___closed__2; +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); +return x_33; +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_2, 0); lean_inc(x_34); -if (lean_obj_tag(x_34) == 0) -{ -lean_dec(x_32); -lean_dec(x_31); -lean_dec(x_1); -return x_33; -} -else -{ -lean_object* x_35; lean_object* x_36; uint8_t x_37; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); +x_35 = lean_array_get_size(x_34); lean_dec(x_34); -x_36 = lean_ctor_get(x_33, 1); +x_36 = lean_ctor_get(x_2, 1); lean_inc(x_36); -x_37 = lean_nat_dec_eq(x_36, x_32); -lean_dec(x_36); -if (x_37 == 0) +lean_inc(x_1); +x_37 = lean_apply_2(x_4, x_1, x_2); +x_38 = lean_ctor_get(x_37, 3); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) { +lean_dec(x_36); lean_dec(x_35); -lean_dec(x_32); -lean_dec(x_31); lean_dec(x_1); -return x_33; +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_inc(x_32); -x_38 = l_Lean_Parser_ParserState_restore(x_33, x_31, x_32); -lean_dec(x_31); +lean_object* x_39; lean_object* x_40; uint8_t x_41; x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -x_40 = lean_array_get_size(x_39); +lean_dec(x_38); +x_40 = lean_ctor_get(x_37, 1); +lean_inc(x_40); +x_41 = lean_nat_dec_eq(x_40, x_36); +lean_dec(x_40); +if (x_41 == 0) +{ lean_dec(x_39); -x_41 = l_Lean_Parser_tokenFn(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_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_Lean_Parser_Level_hole___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_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_48 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -lean_inc(x_32); -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_32); -x_50 = l_Lean_mkHole___closed__2; -x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_40); -x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_35, x_32); -lean_dec(x_32); -return x_52; +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_1); +return x_37; } else { -lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_53 = l_Lean_mkHole___closed__2; -x_54 = l_Lean_Parser_ParserState_mkNode(x_41, x_53, x_40); -x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_35, x_32); -lean_dec(x_32); -return x_55; +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_inc(x_36); +x_42 = l_Lean_Parser_ParserState_restore(x_37, x_35, x_36); +lean_dec(x_35); +x_43 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_44 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_45 = l_Lean_Parser_checkRbpLtFn(x_43, 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) +{ +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); +x_48 = lean_array_get_size(x_47); +lean_dec(x_47); +x_49 = lean_ctor_get(x_45, 1); +lean_inc(x_49); +x_50 = l_Lean_Parser_tokenFn(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_52; lean_object* x_53; +x_52 = lean_ctor_get(x_50, 0); +lean_inc(x_52); +x_53 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_52); +lean_dec(x_52); +if (lean_obj_tag(x_53) == 2) +{ +lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_54); +lean_dec(x_53); +x_55 = l_Lean_Parser_Level_hole___elambda__1___closed__4; +x_56 = lean_string_dec_eq(x_54, x_55); +lean_dec(x_54); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = l_Lean_Parser_Level_hole___elambda__1___closed__7; +x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_57, x_49); +x_59 = l_Lean_mkHole___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_48); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_39, x_36); +lean_dec(x_36); +return x_61; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_49); +x_62 = l_Lean_mkHole___closed__2; +x_63 = l_Lean_Parser_ParserState_mkNode(x_50, x_62, x_48); +x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_39, x_36); +lean_dec(x_36); +return x_64; } } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -lean_dec(x_44); -x_56 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -lean_inc(x_32); -x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_56, x_32); -x_58 = l_Lean_mkHole___closed__2; -x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_40); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_35, x_32); -lean_dec(x_32); -return x_60; +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_53); +x_65 = l_Lean_Parser_Level_hole___elambda__1___closed__7; +x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_65, x_49); +x_67 = l_Lean_mkHole___closed__2; +x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_48); +x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_39, x_36); +lean_dec(x_36); +return x_69; } } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -lean_dec(x_42); -x_61 = l_Lean_Parser_Level_hole___elambda__1___closed__7; -lean_inc(x_32); -x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_61, x_32); -x_63 = l_Lean_mkHole___closed__2; -x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_40); -x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_35, x_32); -lean_dec(x_32); -return x_65; +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_51); +x_70 = l_Lean_Parser_Level_hole___elambda__1___closed__7; +x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_70, x_49); +x_72 = l_Lean_mkHole___closed__2; +x_73 = l_Lean_Parser_ParserState_mkNode(x_71, x_72, x_48); +x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_39, x_36); +lean_dec(x_36); +return x_74; +} +} +else +{ +lean_object* x_75; +lean_dec(x_46); +lean_dec(x_1); +x_75 = l_Lean_Parser_mergeOrElseErrors(x_45, x_39, x_36); +lean_dec(x_36); +return x_75; } } } @@ -7281,16 +7675,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_hole___closed__2() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_hole___closed__1; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_hole___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_hole___elambda__1___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_hole___closed__1; +x_3 = l_Lean_Parser_Term_hole___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_hole___closed__3() { +lean_object* _init_l_Lean_Parser_Term_hole___closed__4() { _start: { lean_object* x_1; @@ -7298,12 +7702,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_hole___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_hole___closed__4() { +lean_object* _init_l_Lean_Parser_Term_hole___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_hole___closed__2; -x_2 = l_Lean_Parser_Term_hole___closed__3; +x_1 = l_Lean_Parser_Term_hole___closed__3; +x_2 = l_Lean_Parser_Term_hole___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); @@ -7314,7 +7718,7 @@ lean_object* _init_l_Lean_Parser_Term_hole() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_hole___closed__4; +x_1 = l_Lean_Parser_Term_hole___closed__5; return x_1; } } @@ -7422,223 +7826,256 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_16; lean_object* x_17; lean_object* x_18; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_16 = lean_ctor_get(x_2, 1); -lean_inc(x_16); -lean_inc(x_1); -x_17 = l_Lean_Parser_tokenFn(x_1, x_2); -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_checkStackTopFn___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_namedHole___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; -x_24 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; -x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); -x_8 = x_25; -goto block_15; -} -else -{ -lean_dec(x_16); -x_8 = x_17; -goto block_15; -} -} -else -{ -lean_object* x_26; lean_object* x_27; -lean_dec(x_20); -x_26 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; -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_dec(x_18); -x_28 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_28, x_16); -x_8 = x_29; -goto block_15; -} -block_15: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; -x_10 = l_Lean_Parser_ident___elambda__1(x_1, x_8); -x_11 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; -x_12 = l_Lean_Parser_ParserState_mkNode(x_10, x_11, x_7); -return x_12; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_20; lean_object* x_21; lean_object* x_22; +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_20 = lean_ctor_get(x_8, 1); +lean_inc(x_20); +lean_inc(x_1); +x_21 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_23 = lean_ctor_get(x_21, 0); +lean_inc(x_23); +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); +lean_dec(x_24); +x_26 = l_Lean_Parser_Term_namedHole___elambda__1___closed__5; +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; +x_28 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; +x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20); +x_12 = x_29; +goto block_19; +} +else +{ +lean_dec(x_20); +x_12 = x_21; +goto block_19; +} +} +else +{ +lean_object* x_30; lean_object* x_31; +lean_dec(x_24); +x_30 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_30, x_20); +x_12 = x_31; +goto block_19; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_22); +x_32 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_32, x_20); +x_12 = x_33; +goto block_19; +} +block_19: +{ +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; +x_14 = l_Lean_Parser_ident___elambda__1(x_1, x_12); +x_15 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; +x_16 = l_Lean_Parser_ParserState_mkNode(x_14, x_15, x_11); +return x_16; +} +else +{ +lean_object* x_17; lean_object* x_18; +lean_dec(x_13); +lean_dec(x_1); +x_17 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_12, x_17, x_11); +return x_18; +} +} } else { -lean_object* x_13; lean_object* x_14; lean_dec(x_9); lean_dec(x_1); -x_13 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_8, x_13, x_7); -return x_14; -} +return x_8; } } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_30 = lean_ctor_get(x_2, 0); -lean_inc(x_30); -x_31 = lean_array_get_size(x_30); -lean_dec(x_30); -x_32 = lean_ctor_get(x_2, 1); -lean_inc(x_32); -lean_inc(x_1); -x_33 = lean_apply_2(x_4, x_1, x_2); -x_34 = lean_ctor_get(x_33, 3); +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_2, 0); lean_inc(x_34); -if (lean_obj_tag(x_34) == 0) -{ -lean_dec(x_32); -lean_dec(x_31); -lean_dec(x_1); -return x_33; -} -else -{ -lean_object* x_35; lean_object* x_36; uint8_t x_37; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); +x_35 = lean_array_get_size(x_34); lean_dec(x_34); -x_36 = lean_ctor_get(x_33, 1); +x_36 = lean_ctor_get(x_2, 1); lean_inc(x_36); -x_37 = lean_nat_dec_eq(x_36, x_32); -lean_dec(x_36); -if (x_37 == 0) +lean_inc(x_1); +x_37 = lean_apply_2(x_4, x_1, x_2); +x_38 = lean_ctor_get(x_37, 3); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) { +lean_dec(x_36); lean_dec(x_35); -lean_dec(x_32); -lean_dec(x_31); lean_dec(x_1); -return x_33; +return x_37; } else { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_51; lean_object* x_52; -lean_inc(x_32); -x_38 = l_Lean_Parser_ParserState_restore(x_33, x_31, x_32); -lean_dec(x_31); +lean_object* x_39; lean_object* x_40; uint8_t x_41; x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -x_40 = lean_array_get_size(x_39); +lean_dec(x_38); +x_40 = lean_ctor_get(x_37, 1); +lean_inc(x_40); +x_41 = lean_nat_dec_eq(x_40, x_36); +lean_dec(x_40); +if (x_41 == 0) +{ lean_dec(x_39); +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_1); +return x_37; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_inc(x_36); +x_42 = l_Lean_Parser_ParserState_restore(x_37, x_35, x_36); +lean_dec(x_35); +x_43 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_44 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_45 = l_Lean_Parser_checkRbpLtFn(x_43, 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) +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_47 = lean_ctor_get(x_45, 0); +lean_inc(x_47); +x_48 = lean_array_get_size(x_47); +lean_dec(x_47); +x_59 = lean_ctor_get(x_45, 1); +lean_inc(x_59); lean_inc(x_1); -x_51 = l_Lean_Parser_tokenFn(x_1, x_38); -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_namedHole___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_namedHole___elambda__1___closed__8; -lean_inc(x_32); -x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_58, x_32); -x_41 = x_59; -goto block_50; -} -else -{ -x_41 = x_51; -goto block_50; -} -} -else -{ -lean_object* x_60; lean_object* x_61; -lean_dec(x_54); -x_60 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; -lean_inc(x_32); -x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_60, x_32); -x_41 = x_61; -goto block_50; -} -} -else +x_60 = l_Lean_Parser_tokenFn(x_1, x_45); +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_dec(x_52); -x_62 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; -lean_inc(x_32); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_62, x_32); -x_41 = x_63; -goto block_50; -} -block_50: +x_62 = lean_ctor_get(x_60, 0); +lean_inc(x_62); +x_63 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_62); +lean_dec(x_62); +if (lean_obj_tag(x_63) == 2) { -lean_object* x_42; -x_42 = lean_ctor_get(x_41, 3); -lean_inc(x_42); -if (lean_obj_tag(x_42) == 0) +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_namedHole___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_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; -x_43 = l_Lean_Parser_ident___elambda__1(x_1, x_41); -x_44 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; -x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_40); -x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_35, x_32); -lean_dec(x_32); -return x_46; +lean_object* x_67; lean_object* x_68; +x_67 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; +x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_67, x_59); +x_49 = x_68; +goto block_58; } else { -lean_object* x_47; lean_object* x_48; lean_object* x_49; -lean_dec(x_42); -lean_dec(x_1); -x_47 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; -x_48 = l_Lean_Parser_ParserState_mkNode(x_41, x_47, x_40); -x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_35, x_32); -lean_dec(x_32); -return x_49; +lean_dec(x_59); +x_49 = x_60; +goto block_58; } } +else +{ +lean_object* x_69; lean_object* x_70; +lean_dec(x_63); +x_69 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; +x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_69, x_59); +x_49 = x_70; +goto block_58; +} +} +else +{ +lean_object* x_71; lean_object* x_72; +lean_dec(x_61); +x_71 = l_Lean_Parser_Term_namedHole___elambda__1___closed__8; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_71, x_59); +x_49 = x_72; +goto block_58; +} +block_58: +{ +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_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_51 = l_Lean_Parser_ident___elambda__1(x_1, x_49); +x_52 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; +x_53 = l_Lean_Parser_ParserState_mkNode(x_51, x_52, x_48); +x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_39, x_36); +lean_dec(x_36); +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_Term_namedHole___elambda__1___closed__2; +x_56 = l_Lean_Parser_ParserState_mkNode(x_49, x_55, x_48); +x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_39, x_36); +lean_dec(x_36); +return x_57; +} +} +} +else +{ +lean_object* x_73; +lean_dec(x_46); +lean_dec(x_1); +x_73 = l_Lean_Parser_mergeOrElseErrors(x_45, x_39, x_36); +lean_dec(x_36); +return x_73; +} } } } @@ -7647,11 +8084,10 @@ return x_49; lean_object* _init_l_Lean_Parser_Term_namedHole___closed__1() { _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_namedHole___elambda__1___closed__5; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_namedHole___closed__2() { @@ -7679,16 +8115,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_namedHole___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_namedHole___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_namedHole___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_namedHole___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_namedHole___closed__3; +x_3 = l_Lean_Parser_Term_namedHole___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_namedHole___closed__5() { +lean_object* _init_l_Lean_Parser_Term_namedHole___closed__6() { _start: { lean_object* x_1; @@ -7696,12 +8142,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_namedHole___elambda__1), 2, return x_1; } } -lean_object* _init_l_Lean_Parser_Term_namedHole___closed__6() { +lean_object* _init_l_Lean_Parser_Term_namedHole___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_namedHole___closed__4; -x_2 = l_Lean_Parser_Term_namedHole___closed__5; +x_1 = l_Lean_Parser_Term_namedHole___closed__5; +x_2 = l_Lean_Parser_Term_namedHole___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); @@ -7712,7 +8158,7 @@ lean_object* _init_l_Lean_Parser_Term_namedHole() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_namedHole___closed__6; +x_1 = l_Lean_Parser_Term_namedHole___closed__7; return x_1; } } @@ -7820,188 +8266,221 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = lean_ctor_get(x_2, 1); -lean_inc(x_8); -x_9 = l_Lean_Parser_tokenFn(x_1, x_2); -x_10 = lean_ctor_get(x_9, 3); +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = lean_ctor_get(x_8, 0); lean_inc(x_10); -if (lean_obj_tag(x_10) == 0) +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_13 = l_Lean_Parser_tokenFn(x_1, x_8); +x_14 = lean_ctor_get(x_13, 3); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 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_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_checkStackTopFn___spec__1(x_15); +lean_dec(x_15); +if (lean_obj_tag(x_16) == 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_Lean_Parser_Term_sorry___elambda__1___closed__5; -x_15 = lean_string_dec_eq(x_13, x_14); -lean_dec(x_13); -if (x_15 == 0) +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_Lean_Parser_Term_sorry___elambda__1___closed__5; +x_19 = lean_string_dec_eq(x_17, x_18); +lean_dec(x_17); +if (x_19 == 0) { -lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_16 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; -x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_16, x_8); -x_18 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; -x_19 = l_Lean_Parser_ParserState_mkNode(x_17, x_18, x_7); -return x_19; +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_20 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; +x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); +x_22 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; +x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_11); +return x_23; } else { -lean_object* x_20; lean_object* x_21; -lean_dec(x_8); -x_20 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; -x_21 = l_Lean_Parser_ParserState_mkNode(x_9, x_20, x_7); -return x_21; -} -} -else -{ -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_object* x_24; lean_object* x_25; lean_dec(x_12); -x_22 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_22, x_8); x_24 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); +x_25 = l_Lean_Parser_ParserState_mkNode(x_13, x_24, x_11); return x_25; } } else { lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -lean_dec(x_10); +lean_dec(x_16); x_26 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_26, x_8); +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); return x_29; } } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_30 = lean_ctor_get(x_2, 0); -lean_inc(x_30); -x_31 = lean_array_get_size(x_30); -lean_dec(x_30); -x_32 = lean_ctor_get(x_2, 1); -lean_inc(x_32); -lean_inc(x_1); -x_33 = lean_apply_2(x_4, x_1, x_2); -x_34 = lean_ctor_get(x_33, 3); +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_sorry___elambda__1___closed__8; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_32 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); +return x_33; +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_2, 0); lean_inc(x_34); -if (lean_obj_tag(x_34) == 0) -{ -lean_dec(x_32); -lean_dec(x_31); -lean_dec(x_1); -return x_33; -} -else -{ -lean_object* x_35; lean_object* x_36; uint8_t x_37; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); +x_35 = lean_array_get_size(x_34); lean_dec(x_34); -x_36 = lean_ctor_get(x_33, 1); +x_36 = lean_ctor_get(x_2, 1); lean_inc(x_36); -x_37 = lean_nat_dec_eq(x_36, x_32); -lean_dec(x_36); -if (x_37 == 0) +lean_inc(x_1); +x_37 = lean_apply_2(x_4, x_1, x_2); +x_38 = lean_ctor_get(x_37, 3); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) { +lean_dec(x_36); lean_dec(x_35); -lean_dec(x_32); -lean_dec(x_31); lean_dec(x_1); -return x_33; +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_inc(x_32); -x_38 = l_Lean_Parser_ParserState_restore(x_33, x_31, x_32); -lean_dec(x_31); +lean_object* x_39; lean_object* x_40; uint8_t x_41; x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -x_40 = lean_array_get_size(x_39); +lean_dec(x_38); +x_40 = lean_ctor_get(x_37, 1); +lean_inc(x_40); +x_41 = lean_nat_dec_eq(x_40, x_36); +lean_dec(x_40); +if (x_41 == 0) +{ lean_dec(x_39); -x_41 = l_Lean_Parser_tokenFn(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_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_Lean_Parser_Term_sorry___elambda__1___closed__5; -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; lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_48 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; -lean_inc(x_32); -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_32); -x_50 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; -x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_40); -x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_35, x_32); -lean_dec(x_32); -return x_52; +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_1); +return x_37; } else { -lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_53 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; -x_54 = l_Lean_Parser_ParserState_mkNode(x_41, x_53, x_40); -x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_35, x_32); -lean_dec(x_32); -return x_55; +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_inc(x_36); +x_42 = l_Lean_Parser_ParserState_restore(x_37, x_35, x_36); +lean_dec(x_35); +x_43 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_44 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_45 = l_Lean_Parser_checkRbpLtFn(x_43, 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) +{ +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); +x_48 = lean_array_get_size(x_47); +lean_dec(x_47); +x_49 = lean_ctor_get(x_45, 1); +lean_inc(x_49); +x_50 = l_Lean_Parser_tokenFn(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_52; lean_object* x_53; +x_52 = lean_ctor_get(x_50, 0); +lean_inc(x_52); +x_53 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_52); +lean_dec(x_52); +if (lean_obj_tag(x_53) == 2) +{ +lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_54); +lean_dec(x_53); +x_55 = l_Lean_Parser_Term_sorry___elambda__1___closed__5; +x_56 = lean_string_dec_eq(x_54, x_55); +lean_dec(x_54); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; +x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_57, x_49); +x_59 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_48); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_39, x_36); +lean_dec(x_36); +return x_61; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_49); +x_62 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; +x_63 = l_Lean_Parser_ParserState_mkNode(x_50, x_62, x_48); +x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_39, x_36); +lean_dec(x_36); +return x_64; } } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -lean_dec(x_44); -x_56 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; -lean_inc(x_32); -x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_56, x_32); -x_58 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; -x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_40); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_35, x_32); -lean_dec(x_32); -return x_60; +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_53); +x_65 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; +x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_65, x_49); +x_67 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; +x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_48); +x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_39, x_36); +lean_dec(x_36); +return x_69; } } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -lean_dec(x_42); -x_61 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; -lean_inc(x_32); -x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_61, x_32); -x_63 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; -x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_40); -x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_35, x_32); -lean_dec(x_32); -return x_65; +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_51); +x_70 = l_Lean_Parser_Term_sorry___elambda__1___closed__8; +x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_70, x_49); +x_72 = l_Lean_Parser_Term_sorry___elambda__1___closed__2; +x_73 = l_Lean_Parser_ParserState_mkNode(x_71, x_72, x_48); +x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_39, x_36); +lean_dec(x_36); +return x_74; +} +} +else +{ +lean_object* x_75; +lean_dec(x_46); +lean_dec(x_1); +x_75 = l_Lean_Parser_mergeOrElseErrors(x_45, x_39, x_36); +lean_dec(x_36); +return x_75; } } } @@ -8011,11 +8490,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Term_sorry___closed__1() { _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_sorry___elambda__1___closed__5; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_sorry___closed__2() { @@ -8031,16 +8509,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_sorry___closed__3() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_sorry___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_sorry___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_sorry___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_sorry___closed__2; +x_3 = l_Lean_Parser_Term_sorry___closed__3; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_sorry___closed__4() { +lean_object* _init_l_Lean_Parser_Term_sorry___closed__5() { _start: { lean_object* x_1; @@ -8048,12 +8536,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_sorry___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_sorry___closed__5() { +lean_object* _init_l_Lean_Parser_Term_sorry___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_sorry___closed__3; -x_2 = l_Lean_Parser_Term_sorry___closed__4; +x_1 = l_Lean_Parser_Term_sorry___closed__4; +x_2 = l_Lean_Parser_Term_sorry___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); @@ -8064,7 +8552,7 @@ lean_object* _init_l_Lean_Parser_Term_sorry() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_sorry___closed__5; +x_1 = l_Lean_Parser_Term_sorry___closed__6; return x_1; } } @@ -8180,188 +8668,221 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = lean_ctor_get(x_2, 1); -lean_inc(x_8); -x_9 = l_Lean_Parser_tokenFn(x_1, x_2); -x_10 = lean_ctor_get(x_9, 3); +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = lean_ctor_get(x_8, 0); lean_inc(x_10); -if (lean_obj_tag(x_10) == 0) +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_13 = l_Lean_Parser_tokenFn(x_1, x_8); +x_14 = lean_ctor_get(x_13, 3); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 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_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_checkStackTopFn___spec__1(x_15); +lean_dec(x_15); +if (lean_obj_tag(x_16) == 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_Lean_Parser_Term_cdot___elambda__1___closed__6; -x_15 = lean_string_dec_eq(x_13, x_14); -lean_dec(x_13); -if (x_15 == 0) +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_Lean_Parser_Term_cdot___elambda__1___closed__6; +x_19 = lean_string_dec_eq(x_17, x_18); +lean_dec(x_17); +if (x_19 == 0) { -lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_16 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; -x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_16, x_8); -x_18 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; -x_19 = l_Lean_Parser_ParserState_mkNode(x_17, x_18, x_7); -return x_19; +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_20 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; +x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); +x_22 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; +x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_11); +return x_23; } else { -lean_object* x_20; lean_object* x_21; -lean_dec(x_8); -x_20 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; -x_21 = l_Lean_Parser_ParserState_mkNode(x_9, x_20, x_7); -return x_21; -} -} -else -{ -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_object* x_24; lean_object* x_25; lean_dec(x_12); -x_22 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_22, x_8); x_24 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); +x_25 = l_Lean_Parser_ParserState_mkNode(x_13, x_24, x_11); return x_25; } } else { lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -lean_dec(x_10); +lean_dec(x_16); x_26 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_26, x_8); +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); return x_29; } } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_30 = lean_ctor_get(x_2, 0); -lean_inc(x_30); -x_31 = lean_array_get_size(x_30); -lean_dec(x_30); -x_32 = lean_ctor_get(x_2, 1); -lean_inc(x_32); -lean_inc(x_1); -x_33 = lean_apply_2(x_4, x_1, x_2); -x_34 = lean_ctor_get(x_33, 3); +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_cdot___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_32 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); +return x_33; +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_2, 0); lean_inc(x_34); -if (lean_obj_tag(x_34) == 0) -{ -lean_dec(x_32); -lean_dec(x_31); -lean_dec(x_1); -return x_33; -} -else -{ -lean_object* x_35; lean_object* x_36; uint8_t x_37; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); +x_35 = lean_array_get_size(x_34); lean_dec(x_34); -x_36 = lean_ctor_get(x_33, 1); +x_36 = lean_ctor_get(x_2, 1); lean_inc(x_36); -x_37 = lean_nat_dec_eq(x_36, x_32); -lean_dec(x_36); -if (x_37 == 0) +lean_inc(x_1); +x_37 = lean_apply_2(x_4, x_1, x_2); +x_38 = lean_ctor_get(x_37, 3); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) { +lean_dec(x_36); lean_dec(x_35); -lean_dec(x_32); -lean_dec(x_31); lean_dec(x_1); -return x_33; +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_inc(x_32); -x_38 = l_Lean_Parser_ParserState_restore(x_33, x_31, x_32); -lean_dec(x_31); +lean_object* x_39; lean_object* x_40; uint8_t x_41; x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -x_40 = lean_array_get_size(x_39); +lean_dec(x_38); +x_40 = lean_ctor_get(x_37, 1); +lean_inc(x_40); +x_41 = lean_nat_dec_eq(x_40, x_36); +lean_dec(x_40); +if (x_41 == 0) +{ lean_dec(x_39); -x_41 = l_Lean_Parser_tokenFn(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_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_Lean_Parser_Term_cdot___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_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_48 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; -lean_inc(x_32); -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_32); -x_50 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; -x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_40); -x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_35, x_32); -lean_dec(x_32); -return x_52; +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_1); +return x_37; } else { -lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_53 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; -x_54 = l_Lean_Parser_ParserState_mkNode(x_41, x_53, x_40); -x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_35, x_32); -lean_dec(x_32); -return x_55; +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_inc(x_36); +x_42 = l_Lean_Parser_ParserState_restore(x_37, x_35, x_36); +lean_dec(x_35); +x_43 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_44 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_45 = l_Lean_Parser_checkRbpLtFn(x_43, 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) +{ +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); +x_48 = lean_array_get_size(x_47); +lean_dec(x_47); +x_49 = lean_ctor_get(x_45, 1); +lean_inc(x_49); +x_50 = l_Lean_Parser_tokenFn(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_52; lean_object* x_53; +x_52 = lean_ctor_get(x_50, 0); +lean_inc(x_52); +x_53 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_52); +lean_dec(x_52); +if (lean_obj_tag(x_53) == 2) +{ +lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_54); +lean_dec(x_53); +x_55 = l_Lean_Parser_Term_cdot___elambda__1___closed__6; +x_56 = lean_string_dec_eq(x_54, x_55); +lean_dec(x_54); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; +x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_57, x_49); +x_59 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_48); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_39, x_36); +lean_dec(x_36); +return x_61; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_49); +x_62 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; +x_63 = l_Lean_Parser_ParserState_mkNode(x_50, x_62, x_48); +x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_39, x_36); +lean_dec(x_36); +return x_64; } } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -lean_dec(x_44); -x_56 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; -lean_inc(x_32); -x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_56, x_32); -x_58 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; -x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_40); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_35, x_32); -lean_dec(x_32); -return x_60; +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_53); +x_65 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; +x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_65, x_49); +x_67 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; +x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_48); +x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_39, x_36); +lean_dec(x_36); +return x_69; } } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -lean_dec(x_42); -x_61 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; -lean_inc(x_32); -x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_61, x_32); -x_63 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; -x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_40); -x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_35, x_32); -lean_dec(x_32); -return x_65; +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_51); +x_70 = l_Lean_Parser_Term_cdot___elambda__1___closed__9; +x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_70, x_49); +x_72 = l_Lean_Parser_Term_cdot___elambda__1___closed__2; +x_73 = l_Lean_Parser_ParserState_mkNode(x_71, x_72, x_48); +x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_39, x_36); +lean_dec(x_36); +return x_74; +} +} +else +{ +lean_object* x_75; +lean_dec(x_46); +lean_dec(x_1); +x_75 = l_Lean_Parser_mergeOrElseErrors(x_45, x_39, x_36); +lean_dec(x_36); +return x_75; } } } @@ -8371,11 +8892,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Term_cdot___closed__1() { _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_cdot___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_cdot___closed__2() { @@ -8391,16 +8911,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_cdot___closed__3() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_cdot___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_cdot___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_cdot___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_cdot___closed__2; +x_3 = l_Lean_Parser_Term_cdot___closed__3; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_cdot___closed__4() { +lean_object* _init_l_Lean_Parser_Term_cdot___closed__5() { _start: { lean_object* x_1; @@ -8408,12 +8938,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_cdot___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_cdot___closed__5() { +lean_object* _init_l_Lean_Parser_Term_cdot___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_cdot___closed__3; -x_2 = l_Lean_Parser_Term_cdot___closed__4; +x_1 = l_Lean_Parser_Term_cdot___closed__4; +x_2 = l_Lean_Parser_Term_cdot___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); @@ -8424,7 +8954,7 @@ lean_object* _init_l_Lean_Parser_Term_cdot() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_cdot___closed__5; +x_1 = l_Lean_Parser_Term_cdot___closed__6; return x_1; } } @@ -8540,188 +9070,221 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = lean_ctor_get(x_2, 1); -lean_inc(x_8); -x_9 = l_Lean_Parser_tokenFn(x_1, x_2); -x_10 = lean_ctor_get(x_9, 3); +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = lean_ctor_get(x_8, 0); lean_inc(x_10); -if (lean_obj_tag(x_10) == 0) +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_13 = l_Lean_Parser_tokenFn(x_1, x_8); +x_14 = lean_ctor_get(x_13, 3); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 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_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_checkStackTopFn___spec__1(x_15); +lean_dec(x_15); +if (lean_obj_tag(x_16) == 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_Lean_Parser_Term_emptyC___elambda__1___closed__6; -x_15 = lean_string_dec_eq(x_13, x_14); -lean_dec(x_13); -if (x_15 == 0) +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_Lean_Parser_Term_emptyC___elambda__1___closed__6; +x_19 = lean_string_dec_eq(x_17, x_18); +lean_dec(x_17); +if (x_19 == 0) { -lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_16 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; -x_17 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_16, x_8); -x_18 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; -x_19 = l_Lean_Parser_ParserState_mkNode(x_17, x_18, x_7); -return x_19; +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_20 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; +x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); +x_22 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; +x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_11); +return x_23; } else { -lean_object* x_20; lean_object* x_21; -lean_dec(x_8); -x_20 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; -x_21 = l_Lean_Parser_ParserState_mkNode(x_9, x_20, x_7); -return x_21; -} -} -else -{ -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_object* x_24; lean_object* x_25; lean_dec(x_12); -x_22 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_22, x_8); x_24 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); +x_25 = l_Lean_Parser_ParserState_mkNode(x_13, x_24, x_11); return x_25; } } else { lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -lean_dec(x_10); +lean_dec(x_16); x_26 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_9, x_26, x_8); +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); return x_29; } } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_30 = lean_ctor_get(x_2, 0); -lean_inc(x_30); -x_31 = lean_array_get_size(x_30); -lean_dec(x_30); -x_32 = lean_ctor_get(x_2, 1); -lean_inc(x_32); -lean_inc(x_1); -x_33 = lean_apply_2(x_4, x_1, x_2); -x_34 = lean_ctor_get(x_33, 3); +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_emptyC___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_32 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); +return x_33; +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_2, 0); lean_inc(x_34); -if (lean_obj_tag(x_34) == 0) -{ -lean_dec(x_32); -lean_dec(x_31); -lean_dec(x_1); -return x_33; -} -else -{ -lean_object* x_35; lean_object* x_36; uint8_t x_37; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); +x_35 = lean_array_get_size(x_34); lean_dec(x_34); -x_36 = lean_ctor_get(x_33, 1); +x_36 = lean_ctor_get(x_2, 1); lean_inc(x_36); -x_37 = lean_nat_dec_eq(x_36, x_32); -lean_dec(x_36); -if (x_37 == 0) +lean_inc(x_1); +x_37 = lean_apply_2(x_4, x_1, x_2); +x_38 = lean_ctor_get(x_37, 3); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) { +lean_dec(x_36); lean_dec(x_35); -lean_dec(x_32); -lean_dec(x_31); lean_dec(x_1); -return x_33; +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_inc(x_32); -x_38 = l_Lean_Parser_ParserState_restore(x_33, x_31, x_32); -lean_dec(x_31); +lean_object* x_39; lean_object* x_40; uint8_t x_41; x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -x_40 = lean_array_get_size(x_39); +lean_dec(x_38); +x_40 = lean_ctor_get(x_37, 1); +lean_inc(x_40); +x_41 = lean_nat_dec_eq(x_40, x_36); +lean_dec(x_40); +if (x_41 == 0) +{ lean_dec(x_39); -x_41 = l_Lean_Parser_tokenFn(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_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_Lean_Parser_Term_emptyC___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_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_48 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; -lean_inc(x_32); -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_32); -x_50 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; -x_51 = l_Lean_Parser_ParserState_mkNode(x_49, x_50, x_40); -x_52 = l_Lean_Parser_mergeOrElseErrors(x_51, x_35, x_32); -lean_dec(x_32); -return x_52; +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_1); +return x_37; } else { -lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_53 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; -x_54 = l_Lean_Parser_ParserState_mkNode(x_41, x_53, x_40); -x_55 = l_Lean_Parser_mergeOrElseErrors(x_54, x_35, x_32); -lean_dec(x_32); -return x_55; +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_inc(x_36); +x_42 = l_Lean_Parser_ParserState_restore(x_37, x_35, x_36); +lean_dec(x_35); +x_43 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_44 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_45 = l_Lean_Parser_checkRbpLtFn(x_43, 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) +{ +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); +x_48 = lean_array_get_size(x_47); +lean_dec(x_47); +x_49 = lean_ctor_get(x_45, 1); +lean_inc(x_49); +x_50 = l_Lean_Parser_tokenFn(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_52; lean_object* x_53; +x_52 = lean_ctor_get(x_50, 0); +lean_inc(x_52); +x_53 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_52); +lean_dec(x_52); +if (lean_obj_tag(x_53) == 2) +{ +lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_54); +lean_dec(x_53); +x_55 = l_Lean_Parser_Term_emptyC___elambda__1___closed__6; +x_56 = lean_string_dec_eq(x_54, x_55); +lean_dec(x_54); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; +x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_57, x_49); +x_59 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_58, x_59, x_48); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_39, x_36); +lean_dec(x_36); +return x_61; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_49); +x_62 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; +x_63 = l_Lean_Parser_ParserState_mkNode(x_50, x_62, x_48); +x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_39, x_36); +lean_dec(x_36); +return x_64; } } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -lean_dec(x_44); -x_56 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; -lean_inc(x_32); -x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_56, x_32); -x_58 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; -x_59 = l_Lean_Parser_ParserState_mkNode(x_57, x_58, x_40); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_35, x_32); -lean_dec(x_32); -return x_60; +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_53); +x_65 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; +x_66 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_65, x_49); +x_67 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; +x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_48); +x_69 = l_Lean_Parser_mergeOrElseErrors(x_68, x_39, x_36); +lean_dec(x_36); +return x_69; } } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -lean_dec(x_42); -x_61 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; -lean_inc(x_32); -x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_61, x_32); -x_63 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; -x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_40); -x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_35, x_32); -lean_dec(x_32); -return x_65; +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_51); +x_70 = l_Lean_Parser_Term_emptyC___elambda__1___closed__9; +x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_50, x_70, x_49); +x_72 = l_Lean_Parser_Term_emptyC___elambda__1___closed__2; +x_73 = l_Lean_Parser_ParserState_mkNode(x_71, x_72, x_48); +x_74 = l_Lean_Parser_mergeOrElseErrors(x_73, x_39, x_36); +lean_dec(x_36); +return x_74; +} +} +else +{ +lean_object* x_75; +lean_dec(x_46); +lean_dec(x_1); +x_75 = l_Lean_Parser_mergeOrElseErrors(x_45, x_39, x_36); +lean_dec(x_36); +return x_75; } } } @@ -8731,11 +9294,10 @@ return x_65; lean_object* _init_l_Lean_Parser_Term_emptyC___closed__1() { _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_emptyC___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_emptyC___closed__2() { @@ -8751,16 +9313,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_emptyC___closed__3() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_emptyC___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_emptyC___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_emptyC___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_emptyC___closed__2; +x_3 = l_Lean_Parser_Term_emptyC___closed__3; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_emptyC___closed__4() { +lean_object* _init_l_Lean_Parser_Term_emptyC___closed__5() { _start: { lean_object* x_1; @@ -8768,12 +9340,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_emptyC___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_emptyC___closed__5() { +lean_object* _init_l_Lean_Parser_Term_emptyC___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_emptyC___closed__3; -x_2 = l_Lean_Parser_Term_emptyC___closed__4; +x_1 = l_Lean_Parser_Term_emptyC___closed__4; +x_2 = l_Lean_Parser_Term_emptyC___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); @@ -8784,7 +9356,7 @@ lean_object* _init_l_Lean_Parser_Term_emptyC() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_emptyC___closed__5; +x_1 = l_Lean_Parser_Term_emptyC___closed__6; return x_1; } } @@ -9121,18 +9693,17 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__1() { _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_typeAscription___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_typeAscription___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_typeAscription___closed__1; @@ -9695,7 +10266,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_explicitUniv___closed__2; @@ -9972,547 +10543,580 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_35; lean_object* x_65; lean_object* x_66; lean_object* x_67; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_65 = lean_ctor_get(x_2, 1); -lean_inc(x_65); -lean_inc(x_1); -x_66 = l_Lean_Parser_tokenFn(x_1, x_2); -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_dec(x_69); -x_71 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; -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_antiquotNestedExpr___elambda__1___closed__10; -x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_73, x_65); -x_35 = x_74; -goto block_64; -} -else -{ -lean_dec(x_65); -x_35 = x_66; -goto block_64; -} -} -else -{ -lean_object* x_75; lean_object* x_76; -lean_dec(x_69); -x_75 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_75, x_65); -x_35 = x_76; -goto block_64; -} -} -else -{ -lean_object* x_77; lean_object* x_78; -lean_dec(x_67); -x_77 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_66, x_77, x_65); -x_35 = x_78; -goto block_64; -} -block_34: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; -x_10 = lean_ctor_get(x_8, 1); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_39; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_10 = lean_ctor_get(x_8, 0); 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_Lean_Parser_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_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_18, x_10); -x_20 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_7); -return x_21; -} -else -{ -lean_object* x_22; lean_object* x_23; +x_11 = lean_array_get_size(x_10); lean_dec(x_10); -x_22 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_23 = l_Lean_Parser_ParserState_mkNode(x_11, x_22, x_7); -return x_23; +x_69 = lean_ctor_get(x_8, 1); +lean_inc(x_69); +lean_inc(x_1); +x_70 = l_Lean_Parser_tokenFn(x_1, x_8); +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_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); +lean_dec(x_73); +x_75 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; +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; +x_77 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_78 = l_Lean_Parser_ParserState_mkErrorsAt(x_70, x_77, x_69); +x_39 = x_78; +goto block_68; +} +else +{ +lean_dec(x_69); +x_39 = x_70; +goto block_68; } } else { -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_object* x_79; lean_object* x_80; +lean_dec(x_73); +x_79 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_70, x_79, x_69); +x_39 = x_80; +goto block_68; +} +} +else +{ +lean_object* x_81; lean_object* x_82; +lean_dec(x_71); +x_81 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_82 = l_Lean_Parser_ParserState_mkErrorsAt(x_70, x_81, x_69); +x_39 = x_82; +goto block_68; +} +block_38: +{ +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; +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +x_15 = l_Lean_Parser_tokenFn(x_1, 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_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); +lean_dec(x_18); +x_20 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; +x_21 = lean_string_dec_eq(x_19, x_20); +lean_dec(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); +x_24 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_11); +return x_25; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_dec(x_14); -x_24 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_24, x_10); x_26 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_7); +x_27 = l_Lean_Parser_ParserState_mkNode(x_15, x_26, x_11); return x_27; } } else { lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_12); +lean_dec(x_18); x_28 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_28, x_10); +x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_28, x_14); x_30 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_7); +x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_11); 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_paren___elambda__1___closed__1; -x_33 = l_Lean_Parser_ParserState_mkNode(x_8, x_32, x_7); -return x_33; +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_dec(x_16); +x_32 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_32, x_14); +x_34 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_11); +return x_35; } } -block_64: -{ -lean_object* x_36; -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_object* x_41; lean_object* x_42; lean_object* x_43; -x_37 = lean_ctor_get(x_35, 0); -lean_inc(x_37); -x_38 = lean_array_get_size(x_37); -lean_dec(x_37); -x_39 = lean_ctor_get(x_35, 1); -lean_inc(x_39); -x_40 = l_Lean_Parser_termParser___closed__2; -x_41 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_42 = l_Lean_Parser_categoryParser___elambda__1(x_40, x_41, x_1, x_35); -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_1); -x_44 = l_Lean_Parser_Term_parenSpecial___elambda__1(x_1, 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_dec(x_39); -x_46 = l_Lean_nullKind; -x_47 = l_Lean_Parser_ParserState_mkNode(x_44, x_46, x_38); -x_8 = x_47; -goto block_34; -} else { -lean_object* x_48; uint8_t x_49; -lean_dec(x_45); -x_48 = lean_ctor_get(x_44, 1); -lean_inc(x_48); -x_49 = lean_nat_dec_eq(x_48, x_39); -lean_dec(x_48); -if (x_49 == 0) +lean_object* x_36; lean_object* x_37; +lean_dec(x_13); +lean_dec(x_1); +x_36 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_37 = l_Lean_Parser_ParserState_mkNode(x_12, x_36, x_11); +return x_37; +} +} +block_68: +{ +lean_object* x_40; +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; lean_object* x_47; +x_41 = lean_ctor_get(x_39, 0); +lean_inc(x_41); +x_42 = lean_array_get_size(x_41); +lean_dec(x_41); +x_43 = lean_ctor_get(x_39, 1); +lean_inc(x_43); +x_44 = l_Lean_Parser_termParser___closed__2; +x_45 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_46 = l_Lean_Parser_categoryParser___elambda__1(x_44, x_45, x_1, x_39); +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_1); +x_48 = l_Lean_Parser_Term_parenSpecial___elambda__1(x_1, 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_dec(x_39); -x_50 = l_Lean_nullKind; -x_51 = l_Lean_Parser_ParserState_mkNode(x_44, x_50, x_38); -x_8 = x_51; -goto block_34; -} -else -{ -lean_object* x_52; lean_object* x_53; lean_object* x_54; -x_52 = l_Lean_Parser_ParserState_restore(x_44, x_38, x_39); -x_53 = l_Lean_nullKind; -x_54 = l_Lean_Parser_ParserState_mkNode(x_52, x_53, x_38); -x_8 = x_54; -goto block_34; -} -} -} -else -{ -lean_object* x_55; uint8_t x_56; lean_dec(x_43); -x_55 = lean_ctor_get(x_42, 1); -lean_inc(x_55); -x_56 = lean_nat_dec_eq(x_55, x_39); -lean_dec(x_55); -if (x_56 == 0) +x_50 = l_Lean_nullKind; +x_51 = l_Lean_Parser_ParserState_mkNode(x_48, x_50, x_42); +x_12 = x_51; +goto block_38; +} +else { -lean_object* x_57; lean_object* x_58; -lean_dec(x_39); +lean_object* x_52; uint8_t x_53; +lean_dec(x_49); +x_52 = lean_ctor_get(x_48, 1); +lean_inc(x_52); +x_53 = lean_nat_dec_eq(x_52, x_43); +lean_dec(x_52); +if (x_53 == 0) +{ +lean_object* x_54; lean_object* x_55; +lean_dec(x_43); +x_54 = l_Lean_nullKind; +x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_42); +x_12 = x_55; +goto block_38; +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = l_Lean_Parser_ParserState_restore(x_48, x_42, x_43); x_57 = l_Lean_nullKind; -x_58 = l_Lean_Parser_ParserState_mkNode(x_42, x_57, x_38); -x_8 = x_58; -goto block_34; -} -else -{ -lean_object* x_59; lean_object* x_60; lean_object* x_61; -x_59 = l_Lean_Parser_ParserState_restore(x_42, x_38, x_39); -x_60 = l_Lean_nullKind; -x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_38); -x_8 = x_61; -goto block_34; +x_58 = l_Lean_Parser_ParserState_mkNode(x_56, x_57, x_42); +x_12 = x_58; +goto block_38; } } } else { -lean_object* x_62; lean_object* x_63; -lean_dec(x_36); +lean_object* x_59; uint8_t x_60; +lean_dec(x_47); +x_59 = lean_ctor_get(x_46, 1); +lean_inc(x_59); +x_60 = lean_nat_dec_eq(x_59, x_43); +lean_dec(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; +lean_dec(x_43); +x_61 = l_Lean_nullKind; +x_62 = l_Lean_Parser_ParserState_mkNode(x_46, x_61, x_42); +x_12 = x_62; +goto block_38; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = l_Lean_Parser_ParserState_restore(x_46, x_42, x_43); +x_64 = l_Lean_nullKind; +x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_42); +x_12 = x_65; +goto block_38; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; +lean_dec(x_40); lean_dec(x_1); -x_62 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_63 = l_Lean_Parser_ParserState_mkNode(x_35, x_62, x_7); -return x_63; +x_66 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_67 = l_Lean_Parser_ParserState_mkNode(x_39, x_66, x_11); +return x_67; } } } else { -lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_79 = lean_ctor_get(x_2, 0); -lean_inc(x_79); -x_80 = lean_array_get_size(x_79); -lean_dec(x_79); -x_81 = lean_ctor_get(x_2, 1); -lean_inc(x_81); -lean_inc(x_1); -x_82 = lean_apply_2(x_4, x_1, x_2); -x_83 = lean_ctor_get(x_82, 3); +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_83 = lean_ctor_get(x_2, 0); lean_inc(x_83); -if (lean_obj_tag(x_83) == 0) -{ -lean_dec(x_81); -lean_dec(x_80); -lean_dec(x_1); -return x_82; -} -else -{ -lean_object* x_84; lean_object* x_85; uint8_t x_86; -x_84 = lean_ctor_get(x_83, 0); -lean_inc(x_84); +x_84 = lean_array_get_size(x_83); lean_dec(x_83); -x_85 = lean_ctor_get(x_82, 1); +x_85 = lean_ctor_get(x_2, 1); lean_inc(x_85); -x_86 = lean_nat_dec_eq(x_85, x_81); -lean_dec(x_85); -if (x_86 == 0) +lean_inc(x_1); +x_86 = lean_apply_2(x_4, x_1, x_2); +x_87 = lean_ctor_get(x_86, 3); +lean_inc(x_87); +if (lean_obj_tag(x_87) == 0) { +lean_dec(x_85); lean_dec(x_84); -lean_dec(x_81); -lean_dec(x_80); lean_dec(x_1); -return x_82; +return x_86; } else { -lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_122; lean_object* x_153; lean_object* x_154; -lean_inc(x_81); -x_87 = l_Lean_Parser_ParserState_restore(x_82, x_80, x_81); -lean_dec(x_80); +lean_object* x_88; lean_object* x_89; uint8_t x_90; x_88 = lean_ctor_get(x_87, 0); lean_inc(x_88); -x_89 = lean_array_get_size(x_88); +lean_dec(x_87); +x_89 = lean_ctor_get(x_86, 1); +lean_inc(x_89); +x_90 = lean_nat_dec_eq(x_89, x_85); +lean_dec(x_89); +if (x_90 == 0) +{ lean_dec(x_88); +lean_dec(x_85); +lean_dec(x_84); +lean_dec(x_1); +return x_86; +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_inc(x_85); +x_91 = l_Lean_Parser_ParserState_restore(x_86, x_84, x_85); +lean_dec(x_84); +x_92 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_93 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_94 = l_Lean_Parser_checkRbpLtFn(x_92, x_93, x_1, x_91); +x_95 = lean_ctor_get(x_94, 3); +lean_inc(x_95); +if (lean_obj_tag(x_95) == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_130; lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_96 = lean_ctor_get(x_94, 0); +lean_inc(x_96); +x_97 = lean_array_get_size(x_96); +lean_dec(x_96); +x_161 = lean_ctor_get(x_94, 1); +lean_inc(x_161); lean_inc(x_1); -x_153 = l_Lean_Parser_tokenFn(x_1, x_87); -x_154 = lean_ctor_get(x_153, 3); -lean_inc(x_154); -if (lean_obj_tag(x_154) == 0) -{ -lean_object* x_155; lean_object* x_156; -x_155 = lean_ctor_get(x_153, 0); -lean_inc(x_155); -x_156 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_155); -lean_dec(x_155); -if (lean_obj_tag(x_156) == 2) -{ -lean_object* x_157; lean_object* x_158; uint8_t x_159; -x_157 = lean_ctor_get(x_156, 1); -lean_inc(x_157); -lean_dec(x_156); -x_158 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; -x_159 = lean_string_dec_eq(x_157, x_158); -lean_dec(x_157); -if (x_159 == 0) -{ -lean_object* x_160; lean_object* x_161; -x_160 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_81); -x_161 = l_Lean_Parser_ParserState_mkErrorsAt(x_153, x_160, x_81); -x_122 = x_161; -goto block_152; -} -else -{ -x_122 = x_153; -goto block_152; -} -} -else -{ -lean_object* x_162; lean_object* x_163; -lean_dec(x_156); -x_162 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_81); -x_163 = l_Lean_Parser_ParserState_mkErrorsAt(x_153, x_162, x_81); -x_122 = x_163; -goto block_152; -} -} -else +x_162 = l_Lean_Parser_tokenFn(x_1, x_94); +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_dec(x_154); -x_164 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; -lean_inc(x_81); -x_165 = l_Lean_Parser_ParserState_mkErrorsAt(x_153, x_164, x_81); -x_122 = x_165; -goto block_152; -} -block_121: +x_164 = lean_ctor_get(x_162, 0); +lean_inc(x_164); +x_165 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_164); +lean_dec(x_164); +if (lean_obj_tag(x_165) == 2) { -lean_object* x_91; -x_91 = lean_ctor_get(x_90, 3); -lean_inc(x_91); -if (lean_obj_tag(x_91) == 0) +lean_object* x_166; lean_object* x_167; uint8_t x_168; +x_166 = lean_ctor_get(x_165, 1); +lean_inc(x_166); +lean_dec(x_165); +x_167 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__3; +x_168 = lean_string_dec_eq(x_166, x_167); +lean_dec(x_166); +if (x_168 == 0) { -lean_object* x_92; lean_object* x_93; lean_object* x_94; -x_92 = lean_ctor_get(x_90, 1); -lean_inc(x_92); -x_93 = l_Lean_Parser_tokenFn(x_1, x_90); -x_94 = lean_ctor_get(x_93, 3); -lean_inc(x_94); -if (lean_obj_tag(x_94) == 0) -{ -lean_object* x_95; lean_object* x_96; -x_95 = lean_ctor_get(x_93, 0); -lean_inc(x_95); -x_96 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_95); -lean_dec(x_95); -if (lean_obj_tag(x_96) == 2) -{ -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_antiquotNestedExpr___elambda__1___closed__4; -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; lean_object* x_102; lean_object* x_103; lean_object* x_104; -x_100 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_101 = l_Lean_Parser_ParserState_mkErrorsAt(x_93, x_100, x_92); -x_102 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_103 = l_Lean_Parser_ParserState_mkNode(x_101, x_102, x_89); -x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_84, x_81); -lean_dec(x_81); -return x_104; +lean_object* x_169; lean_object* x_170; +x_169 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_170 = l_Lean_Parser_ParserState_mkErrorsAt(x_162, x_169, x_161); +x_130 = x_170; +goto block_160; } else { -lean_object* x_105; lean_object* x_106; lean_object* x_107; -lean_dec(x_92); -x_105 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_106 = l_Lean_Parser_ParserState_mkNode(x_93, x_105, x_89); -x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_84, x_81); -lean_dec(x_81); -return x_107; +lean_dec(x_161); +x_130 = x_162; +goto block_160; } } else { +lean_object* x_171; lean_object* x_172; +lean_dec(x_165); +x_171 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_172 = l_Lean_Parser_ParserState_mkErrorsAt(x_162, x_171, x_161); +x_130 = x_172; +goto block_160; +} +} +else +{ +lean_object* x_173; lean_object* x_174; +lean_dec(x_163); +x_173 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10; +x_174 = l_Lean_Parser_ParserState_mkErrorsAt(x_162, x_173, x_161); +x_130 = x_174; +goto block_160; +} +block_129: +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 3); +lean_inc(x_99); +if (lean_obj_tag(x_99) == 0) +{ +lean_object* x_100; lean_object* x_101; lean_object* x_102; +x_100 = lean_ctor_get(x_98, 1); +lean_inc(x_100); +x_101 = l_Lean_Parser_tokenFn(x_1, x_98); +x_102 = lean_ctor_get(x_101, 3); +lean_inc(x_102); +if (lean_obj_tag(x_102) == 0) +{ +lean_object* x_103; lean_object* x_104; +x_103 = lean_ctor_get(x_101, 0); +lean_inc(x_103); +x_104 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_103); +lean_dec(x_103); +if (lean_obj_tag(x_104) == 2) +{ +lean_object* x_105; lean_object* x_106; uint8_t x_107; +x_105 = lean_ctor_get(x_104, 1); +lean_inc(x_105); +lean_dec(x_104); +x_106 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; +x_107 = lean_string_dec_eq(x_105, x_106); +lean_dec(x_105); +if (x_107 == 0) +{ lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; -lean_dec(x_96); x_108 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_109 = l_Lean_Parser_ParserState_mkErrorsAt(x_93, x_108, x_92); +x_109 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_108, x_100); x_110 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_111 = l_Lean_Parser_ParserState_mkNode(x_109, x_110, x_89); -x_112 = l_Lean_Parser_mergeOrElseErrors(x_111, x_84, x_81); -lean_dec(x_81); +x_111 = l_Lean_Parser_ParserState_mkNode(x_109, x_110, x_97); +x_112 = l_Lean_Parser_mergeOrElseErrors(x_111, x_88, x_85); +lean_dec(x_85); return x_112; } -} else { -lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; -lean_dec(x_94); -x_113 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_114 = l_Lean_Parser_ParserState_mkErrorsAt(x_93, x_113, x_92); -x_115 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_116 = l_Lean_Parser_ParserState_mkNode(x_114, x_115, x_89); -x_117 = l_Lean_Parser_mergeOrElseErrors(x_116, x_84, x_81); -lean_dec(x_81); -return x_117; +lean_object* x_113; lean_object* x_114; lean_object* x_115; +lean_dec(x_100); +x_113 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_114 = l_Lean_Parser_ParserState_mkNode(x_101, x_113, x_97); +x_115 = l_Lean_Parser_mergeOrElseErrors(x_114, x_88, x_85); +lean_dec(x_85); +return x_115; } } else { -lean_object* x_118; lean_object* x_119; lean_object* x_120; -lean_dec(x_91); -lean_dec(x_1); +lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; +lean_dec(x_104); +x_116 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_117 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_116, x_100); x_118 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_119 = l_Lean_Parser_ParserState_mkNode(x_90, x_118, x_89); -x_120 = l_Lean_Parser_mergeOrElseErrors(x_119, x_84, x_81); -lean_dec(x_81); +x_119 = l_Lean_Parser_ParserState_mkNode(x_117, x_118, x_97); +x_120 = l_Lean_Parser_mergeOrElseErrors(x_119, x_88, x_85); +lean_dec(x_85); return x_120; } } -block_152: -{ -lean_object* x_123; -x_123 = lean_ctor_get(x_122, 3); -lean_inc(x_123); -if (lean_obj_tag(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; -x_124 = lean_ctor_get(x_122, 0); -lean_inc(x_124); -x_125 = lean_array_get_size(x_124); -lean_dec(x_124); -x_126 = lean_ctor_get(x_122, 1); -lean_inc(x_126); -x_127 = l_Lean_Parser_termParser___closed__2; -x_128 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_129 = l_Lean_Parser_categoryParser___elambda__1(x_127, x_128, x_1, x_122); -x_130 = lean_ctor_get(x_129, 3); -lean_inc(x_130); -if (lean_obj_tag(x_130) == 0) -{ -lean_object* x_131; lean_object* x_132; -lean_inc(x_1); -x_131 = l_Lean_Parser_Term_parenSpecial___elambda__1(x_1, x_129); -x_132 = lean_ctor_get(x_131, 3); -lean_inc(x_132); -if (lean_obj_tag(x_132) == 0) -{ -lean_object* x_133; lean_object* x_134; -lean_dec(x_126); -x_133 = l_Lean_nullKind; -x_134 = l_Lean_Parser_ParserState_mkNode(x_131, x_133, x_125); -x_90 = x_134; -goto block_121; -} else { -lean_object* x_135; uint8_t x_136; -lean_dec(x_132); -x_135 = lean_ctor_get(x_131, 1); -lean_inc(x_135); -x_136 = lean_nat_dec_eq(x_135, x_126); -lean_dec(x_135); -if (x_136 == 0) -{ -lean_object* x_137; lean_object* x_138; -lean_dec(x_126); -x_137 = l_Lean_nullKind; -x_138 = l_Lean_Parser_ParserState_mkNode(x_131, x_137, x_125); -x_90 = x_138; -goto block_121; -} -else -{ -lean_object* x_139; lean_object* x_140; lean_object* x_141; -x_139 = l_Lean_Parser_ParserState_restore(x_131, x_125, x_126); -x_140 = l_Lean_nullKind; -x_141 = l_Lean_Parser_ParserState_mkNode(x_139, x_140, x_125); -x_90 = x_141; -goto block_121; -} +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; +lean_dec(x_102); +x_121 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_121, x_100); +x_123 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_124 = l_Lean_Parser_ParserState_mkNode(x_122, x_123, x_97); +x_125 = l_Lean_Parser_mergeOrElseErrors(x_124, x_88, x_85); +lean_dec(x_85); +return x_125; } } else { -lean_object* x_142; uint8_t x_143; -lean_dec(x_130); -x_142 = lean_ctor_get(x_129, 1); -lean_inc(x_142); -x_143 = lean_nat_dec_eq(x_142, x_126); -lean_dec(x_142); -if (x_143 == 0) -{ -lean_object* x_144; lean_object* x_145; -lean_dec(x_126); -x_144 = l_Lean_nullKind; -x_145 = l_Lean_Parser_ParserState_mkNode(x_129, x_144, x_125); -x_90 = x_145; -goto block_121; -} -else -{ -lean_object* x_146; lean_object* x_147; lean_object* x_148; -x_146 = l_Lean_Parser_ParserState_restore(x_129, x_125, x_126); -x_147 = l_Lean_nullKind; -x_148 = l_Lean_Parser_ParserState_mkNode(x_146, x_147, x_125); -x_90 = x_148; -goto block_121; -} -} -} -else -{ -lean_object* x_149; lean_object* x_150; lean_object* x_151; -lean_dec(x_123); +lean_object* x_126; lean_object* x_127; lean_object* x_128; +lean_dec(x_99); lean_dec(x_1); -x_149 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_150 = l_Lean_Parser_ParserState_mkNode(x_122, x_149, x_89); -x_151 = l_Lean_Parser_mergeOrElseErrors(x_150, x_84, x_81); -lean_dec(x_81); -return x_151; +x_126 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_127 = l_Lean_Parser_ParserState_mkNode(x_98, x_126, x_97); +x_128 = l_Lean_Parser_mergeOrElseErrors(x_127, x_88, x_85); +lean_dec(x_85); +return x_128; } } +block_160: +{ +lean_object* x_131; +x_131 = lean_ctor_get(x_130, 3); +lean_inc(x_131); +if (lean_obj_tag(x_131) == 0) +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; +x_132 = lean_ctor_get(x_130, 0); +lean_inc(x_132); +x_133 = lean_array_get_size(x_132); +lean_dec(x_132); +x_134 = lean_ctor_get(x_130, 1); +lean_inc(x_134); +x_135 = l_Lean_Parser_termParser___closed__2; +x_136 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_137 = l_Lean_Parser_categoryParser___elambda__1(x_135, x_136, x_1, x_130); +x_138 = lean_ctor_get(x_137, 3); +lean_inc(x_138); +if (lean_obj_tag(x_138) == 0) +{ +lean_object* x_139; lean_object* x_140; +lean_inc(x_1); +x_139 = l_Lean_Parser_Term_parenSpecial___elambda__1(x_1, x_137); +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_dec(x_134); +x_141 = l_Lean_nullKind; +x_142 = l_Lean_Parser_ParserState_mkNode(x_139, x_141, x_133); +x_98 = x_142; +goto block_129; +} +else +{ +lean_object* x_143; uint8_t x_144; +lean_dec(x_140); +x_143 = lean_ctor_get(x_139, 1); +lean_inc(x_143); +x_144 = lean_nat_dec_eq(x_143, x_134); +lean_dec(x_143); +if (x_144 == 0) +{ +lean_object* x_145; lean_object* x_146; +lean_dec(x_134); +x_145 = l_Lean_nullKind; +x_146 = l_Lean_Parser_ParserState_mkNode(x_139, x_145, x_133); +x_98 = x_146; +goto block_129; +} +else +{ +lean_object* x_147; lean_object* x_148; lean_object* x_149; +x_147 = l_Lean_Parser_ParserState_restore(x_139, x_133, x_134); +x_148 = l_Lean_nullKind; +x_149 = l_Lean_Parser_ParserState_mkNode(x_147, x_148, x_133); +x_98 = x_149; +goto block_129; +} +} +} +else +{ +lean_object* x_150; uint8_t x_151; +lean_dec(x_138); +x_150 = lean_ctor_get(x_137, 1); +lean_inc(x_150); +x_151 = lean_nat_dec_eq(x_150, x_134); +lean_dec(x_150); +if (x_151 == 0) +{ +lean_object* x_152; lean_object* x_153; +lean_dec(x_134); +x_152 = l_Lean_nullKind; +x_153 = l_Lean_Parser_ParserState_mkNode(x_137, x_152, x_133); +x_98 = x_153; +goto block_129; +} +else +{ +lean_object* x_154; lean_object* x_155; lean_object* x_156; +x_154 = l_Lean_Parser_ParserState_restore(x_137, x_133, x_134); +x_155 = l_Lean_nullKind; +x_156 = l_Lean_Parser_ParserState_mkNode(x_154, x_155, x_133); +x_98 = x_156; +goto block_129; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; +lean_dec(x_131); +lean_dec(x_1); +x_157 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_158 = l_Lean_Parser_ParserState_mkNode(x_130, x_157, x_97); +x_159 = l_Lean_Parser_mergeOrElseErrors(x_158, x_88, x_85); +lean_dec(x_85); +return x_159; +} +} +} +else +{ +lean_object* x_175; +lean_dec(x_95); +lean_dec(x_1); +x_175 = l_Lean_Parser_mergeOrElseErrors(x_94, x_88, x_85); +lean_dec(x_85); +return x_175; +} } } } @@ -10522,7 +11126,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_parenSpecial; @@ -10546,7 +11150,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_Lean_Parser_antiquotNestedExpr___closed__4; +x_2 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } @@ -10555,7 +11159,7 @@ lean_object* _init_l_Lean_Parser_Term_paren___closed__4() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__1; x_2 = l_Lean_Parser_Term_paren___closed__3; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; @@ -10574,16 +11178,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_paren___closed__6() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_paren___closed__5; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_paren___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_paren___elambda__1___closed__3; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_paren___closed__5; +x_3 = l_Lean_Parser_Term_paren___closed__6; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_paren___closed__7() { +lean_object* _init_l_Lean_Parser_Term_paren___closed__8() { _start: { lean_object* x_1; @@ -10591,12 +11205,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_paren___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_paren___closed__8() { +lean_object* _init_l_Lean_Parser_Term_paren___closed__9() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_paren___closed__6; -x_2 = l_Lean_Parser_Term_paren___closed__7; +x_1 = l_Lean_Parser_Term_paren___closed__7; +x_2 = l_Lean_Parser_Term_paren___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); @@ -10607,7 +11221,7 @@ lean_object* _init_l_Lean_Parser_Term_paren() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_paren___closed__8; +x_1 = l_Lean_Parser_Term_paren___closed__9; return x_1; } } @@ -10770,379 +11384,412 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_40; lean_object* x_41; lean_object* x_42; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_40 = lean_ctor_get(x_2, 1); -lean_inc(x_40); -lean_inc(x_1); -x_41 = l_Lean_Parser_tokenFn(x_1, x_2); -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_Lean_Parser_Term_anonymousCtor___elambda__1___closed__5; -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_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40); -x_8 = x_49; -goto block_39; -} -else -{ -lean_dec(x_40); -x_8 = x_41; -goto block_39; -} -} -else -{ -lean_object* x_50; lean_object* x_51; -lean_dec(x_44); -x_50 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; -x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40); -x_8 = x_51; -goto block_39; -} -} -else -{ -lean_object* x_52; lean_object* x_53; -lean_dec(x_42); -x_52 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; -x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40); -x_8 = x_53; -goto block_39; -} -block_39: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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) { -uint8_t x_10; lean_object* x_11; lean_object* x_12; -x_10 = 0; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_44; 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_44 = lean_ctor_get(x_8, 1); +lean_inc(x_44); lean_inc(x_1); -x_11 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(x_10, x_1, x_8); -x_12 = lean_ctor_get(x_11, 3); -lean_inc(x_12); -if (lean_obj_tag(x_12) == 0) +x_45 = l_Lean_Parser_tokenFn(x_1, x_8); +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; -x_13 = lean_ctor_get(x_11, 1); +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_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_anonymousCtor___elambda__1___closed__5; +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_anonymousCtor___elambda__1___closed__12; +x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_44); +x_12 = x_53; +goto block_43; +} +else +{ +lean_dec(x_44); +x_12 = x_45; +goto block_43; +} +} +else +{ +lean_object* x_54; lean_object* x_55; +lean_dec(x_48); +x_54 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; +x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_44); +x_12 = x_55; +goto block_43; +} +} +else +{ +lean_object* x_56; lean_object* x_57; +lean_dec(x_46); +x_56 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; +x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_44); +x_12 = x_57; +goto block_43; +} +block_43: +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_12, 3); 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) +if (lean_obj_tag(x_13) == 0) { -lean_object* x_16; lean_object* x_17; -x_16 = lean_ctor_get(x_14, 0); +uint8_t x_14; lean_object* x_15; lean_object* x_16; +x_14 = 0; +lean_inc(x_1); +x_15 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(x_14, x_1, x_12); +x_16 = lean_ctor_get(x_15, 3); 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) +if (lean_obj_tag(x_16) == 0) { -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_Term_anonymousCtor___elambda__1___closed__6; -x_20 = lean_string_dec_eq(x_18, x_19); -lean_dec(x_18); -if (x_20 == 0) +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_15, 1); +lean_inc(x_17); +x_18 = l_Lean_Parser_tokenFn(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; -x_21 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9; -x_22 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_21, x_13); -x_23 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_7); -return x_24; +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_18, 0); +lean_inc(x_20); +x_21 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_20); +lean_dec(x_20); +if (lean_obj_tag(x_21) == 2) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; +x_22 = lean_ctor_get(x_21, 1); +lean_inc(x_22); +lean_dec(x_21); +x_23 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__6; +x_24 = lean_string_dec_eq(x_22, x_23); +lean_dec(x_22); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_25 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9; +x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_25, x_17); +x_27 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_11); +return x_28; } else { -lean_object* x_25; lean_object* x_26; -lean_dec(x_13); -x_25 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_26 = l_Lean_Parser_ParserState_mkNode(x_14, x_25, x_7); -return x_26; -} -} -else -{ -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_object* x_29; lean_object* x_30; lean_dec(x_17); -x_27 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9; -x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_27, x_13); x_29 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_7); +x_30 = l_Lean_Parser_ParserState_mkNode(x_18, x_29, x_11); return x_30; } } else { lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_15); +lean_dec(x_21); x_31 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9; -x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_31, x_13); +x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_31, x_17); x_33 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_7); +x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_11); return x_34; } } else { -lean_object* x_35; lean_object* x_36; -lean_dec(x_12); -lean_dec(x_1); -x_35 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_11, x_35, x_7); -return x_36; -} -} -else -{ -lean_object* x_37; lean_object* x_38; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_19); +x_35 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9; +x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_35, x_17); x_37 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkNode(x_8, x_37, x_7); +x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_11); return x_38; } } +else +{ +lean_object* x_39; lean_object* x_40; +lean_dec(x_16); +lean_dec(x_1); +x_39 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_40 = l_Lean_Parser_ParserState_mkNode(x_15, x_39, x_11); +return x_40; +} } else { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_2, 0); -lean_inc(x_54); -x_55 = lean_array_get_size(x_54); -lean_dec(x_54); -x_56 = lean_ctor_get(x_2, 1); -lean_inc(x_56); -lean_inc(x_1); -x_57 = lean_apply_2(x_4, x_1, x_2); -x_58 = lean_ctor_get(x_57, 3); +lean_object* x_41; lean_object* x_42; +lean_dec(x_13); +lean_dec(x_1); +x_41 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkNode(x_12, x_41, x_11); +return x_42; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_58); -if (lean_obj_tag(x_58) == 0) -{ -lean_dec(x_56); -lean_dec(x_55); -lean_dec(x_1); -return x_57; -} -else -{ -lean_object* x_59; lean_object* x_60; uint8_t x_61; -x_59 = lean_ctor_get(x_58, 0); -lean_inc(x_59); +x_59 = lean_array_get_size(x_58); lean_dec(x_58); -x_60 = lean_ctor_get(x_57, 1); +x_60 = lean_ctor_get(x_2, 1); lean_inc(x_60); -x_61 = lean_nat_dec_eq(x_60, x_56); -lean_dec(x_60); -if (x_61 == 0) +lean_inc(x_1); +x_61 = lean_apply_2(x_4, x_1, x_2); +x_62 = lean_ctor_get(x_61, 3); +lean_inc(x_62); +if (lean_obj_tag(x_62) == 0) { +lean_dec(x_60); lean_dec(x_59); -lean_dec(x_56); -lean_dec(x_55); lean_dec(x_1); -return x_57; +return x_61; } else { -lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_103; lean_object* x_104; -lean_inc(x_56); -x_62 = l_Lean_Parser_ParserState_restore(x_57, x_55, x_56); -lean_dec(x_55); +lean_object* x_63; lean_object* x_64; uint8_t x_65; x_63 = lean_ctor_get(x_62, 0); lean_inc(x_63); -x_64 = lean_array_get_size(x_63); +lean_dec(x_62); +x_64 = lean_ctor_get(x_61, 1); +lean_inc(x_64); +x_65 = lean_nat_dec_eq(x_64, x_60); +lean_dec(x_64); +if (x_65 == 0) +{ lean_dec(x_63); +lean_dec(x_60); +lean_dec(x_59); +lean_dec(x_1); +return x_61; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_inc(x_60); +x_66 = l_Lean_Parser_ParserState_restore(x_61, x_59, x_60); +lean_dec(x_59); +x_67 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_68 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_69 = l_Lean_Parser_checkRbpLtFn(x_67, 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_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_71 = lean_ctor_get(x_69, 0); +lean_inc(x_71); +x_72 = lean_array_get_size(x_71); +lean_dec(x_71); +x_111 = lean_ctor_get(x_69, 1); +lean_inc(x_111); lean_inc(x_1); -x_103 = l_Lean_Parser_tokenFn(x_1, x_62); -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; -x_105 = lean_ctor_get(x_103, 0); -lean_inc(x_105); -x_106 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_Lean_Parser_Term_anonymousCtor___elambda__1___closed__5; -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_Term_anonymousCtor___elambda__1___closed__12; -lean_inc(x_56); -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_110, x_56); -x_65 = x_111; -goto block_102; -} -else -{ -x_65 = x_103; -goto block_102; -} -} -else -{ -lean_object* x_112; lean_object* x_113; -lean_dec(x_106); -x_112 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; -lean_inc(x_56); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_112, x_56); -x_65 = x_113; -goto block_102; -} -} -else +x_112 = l_Lean_Parser_tokenFn(x_1, x_69); +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_dec(x_104); -x_114 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; -lean_inc(x_56); -x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_114, x_56); -x_65 = x_115; -goto block_102; +x_114 = lean_ctor_get(x_112, 0); +lean_inc(x_114); +x_115 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_114); +lean_dec(x_114); +if (lean_obj_tag(x_115) == 2) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +lean_dec(x_115); +x_117 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__5; +x_118 = lean_string_dec_eq(x_116, x_117); +lean_dec(x_116); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; +x_119 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; +x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_119, x_111); +x_73 = x_120; +goto block_110; } -block_102: +else { -lean_object* x_66; -x_66 = lean_ctor_get(x_65, 3); -lean_inc(x_66); -if (lean_obj_tag(x_66) == 0) +lean_dec(x_111); +x_73 = x_112; +goto block_110; +} +} +else { -uint8_t x_67; lean_object* x_68; lean_object* x_69; -x_67 = 0; +lean_object* x_121; lean_object* x_122; +lean_dec(x_115); +x_121 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_121, x_111); +x_73 = x_122; +goto block_110; +} +} +else +{ +lean_object* x_123; lean_object* x_124; +lean_dec(x_113); +x_123 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__12; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_123, x_111); +x_73 = x_124; +goto block_110; +} +block_110: +{ +lean_object* x_74; +x_74 = lean_ctor_get(x_73, 3); +lean_inc(x_74); +if (lean_obj_tag(x_74) == 0) +{ +uint8_t x_75; lean_object* x_76; lean_object* x_77; +x_75 = 0; lean_inc(x_1); -x_68 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(x_67, x_1, x_65); -x_69 = lean_ctor_get(x_68, 3); -lean_inc(x_69); -if (lean_obj_tag(x_69) == 0) +x_76 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_anonymousCtor___elambda__1___spec__1(x_75, x_1, x_73); +x_77 = lean_ctor_get(x_76, 3); +lean_inc(x_77); +if (lean_obj_tag(x_77) == 0) { -lean_object* x_70; lean_object* x_71; lean_object* x_72; -x_70 = lean_ctor_get(x_68, 1); -lean_inc(x_70); -x_71 = l_Lean_Parser_tokenFn(x_1, x_68); -x_72 = lean_ctor_get(x_71, 3); -lean_inc(x_72); -if (lean_obj_tag(x_72) == 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); +x_79 = l_Lean_Parser_tokenFn(x_1, x_76); +x_80 = lean_ctor_get(x_79, 3); +lean_inc(x_80); +if (lean_obj_tag(x_80) == 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_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_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_anonymousCtor___elambda__1___closed__6; -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_anonymousCtor___elambda__1___closed__9; -x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_78, x_70); -x_80 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_81 = l_Lean_Parser_ParserState_mkNode(x_79, x_80, x_64); -x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_59, x_56); -lean_dec(x_56); -return x_82; -} -else -{ -lean_object* x_83; lean_object* x_84; lean_object* x_85; -lean_dec(x_70); -x_83 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_84 = l_Lean_Parser_ParserState_mkNode(x_71, x_83, x_64); -x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_59, x_56); -lean_dec(x_56); -return x_85; -} -} -else +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_anonymousCtor___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; lean_object* x_88; lean_object* x_89; lean_object* x_90; -lean_dec(x_74); x_86 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9; -x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_86, x_70); +x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_78); x_88 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_64); -x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_59, x_56); -lean_dec(x_56); +x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_72); +x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_63, x_60); +lean_dec(x_60); 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_72); -x_91 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9; -x_92 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_91, x_70); -x_93 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_94 = l_Lean_Parser_ParserState_mkNode(x_92, x_93, x_64); -x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_59, x_56); -lean_dec(x_56); -return x_95; +lean_object* x_91; lean_object* x_92; lean_object* x_93; +lean_dec(x_78); +x_91 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_92 = l_Lean_Parser_ParserState_mkNode(x_79, x_91, x_72); +x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_63, x_60); +lean_dec(x_60); +return x_93; } } else { -lean_object* x_96; lean_object* x_97; lean_object* x_98; -lean_dec(x_69); -lean_dec(x_1); +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_Term_anonymousCtor___elambda__1___closed__9; +x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_94, x_78); x_96 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_97 = l_Lean_Parser_ParserState_mkNode(x_68, x_96, x_64); -x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_59, x_56); -lean_dec(x_56); +x_97 = l_Lean_Parser_ParserState_mkNode(x_95, x_96, x_72); +x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_63, x_60); +lean_dec(x_60); return x_98; } } else { -lean_object* x_99; lean_object* x_100; lean_object* x_101; -lean_dec(x_66); -lean_dec(x_1); -x_99 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_100 = l_Lean_Parser_ParserState_mkNode(x_65, x_99, x_64); -x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_59, x_56); -lean_dec(x_56); -return x_101; +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_Term_anonymousCtor___elambda__1___closed__9; +x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_99, x_78); +x_101 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_72); +x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_63, x_60); +lean_dec(x_60); +return x_103; } } +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +lean_dec(x_77); +lean_dec(x_1); +x_104 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_105 = l_Lean_Parser_ParserState_mkNode(x_76, x_104, x_72); +x_106 = l_Lean_Parser_mergeOrElseErrors(x_105, x_63, x_60); +lean_dec(x_60); +return x_106; +} +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; +lean_dec(x_74); +lean_dec(x_1); +x_107 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_108 = l_Lean_Parser_ParserState_mkNode(x_73, x_107, x_72); +x_109 = l_Lean_Parser_mergeOrElseErrors(x_108, x_63, x_60); +lean_dec(x_60); +return x_109; +} +} +} +else +{ +lean_object* x_125; +lean_dec(x_70); +lean_dec(x_1); +x_125 = l_Lean_Parser_mergeOrElseErrors(x_69, x_63, x_60); +lean_dec(x_60); +return x_125; +} } } } @@ -11151,18 +11798,17 @@ return x_101; lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__1() { _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_anonymousCtor___elambda__1___closed__5; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_explicitUniv___closed__2; @@ -11173,11 +11819,10 @@ return x_4; lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__3() { _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_anonymousCtor___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__4() { @@ -11213,16 +11858,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__7() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_anonymousCtor___closed__6; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__8() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_anonymousCtor___closed__6; +x_3 = l_Lean_Parser_Term_anonymousCtor___closed__7; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__8() { +lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__9() { _start: { lean_object* x_1; @@ -11230,12 +11885,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_anonymousCtor___elambda__1), return x_1; } } -lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__9() { +lean_object* _init_l_Lean_Parser_Term_anonymousCtor___closed__10() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_anonymousCtor___closed__7; -x_2 = l_Lean_Parser_Term_anonymousCtor___closed__8; +x_1 = l_Lean_Parser_Term_anonymousCtor___closed__8; +x_2 = l_Lean_Parser_Term_anonymousCtor___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); @@ -11246,7 +11901,7 @@ lean_object* _init_l_Lean_Parser_Term_anonymousCtor() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_anonymousCtor___closed__9; +x_1 = l_Lean_Parser_Term_anonymousCtor___closed__10; return x_1; } } @@ -11617,9 +12272,9 @@ lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__11() { _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_if___elambda__1___closed__10; -x_3 = lean_string_append(x_1, x_2); +x_1 = l_Lean_Parser_Term_leadPrec; +x_2 = lean_unsigned_to_nat(1u); +x_3 = lean_nat_add(x_1, x_2); return x_3; } } @@ -11627,8 +12282,8 @@ lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__12() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_if___elambda__1___closed__11; -x_2 = l_Char_HasRepr___closed__1; +x_1 = l_Char_HasRepr___closed__1; +x_2 = l_Lean_Parser_Term_if___elambda__1___closed__10; x_3 = lean_string_append(x_1, x_2); return x_3; } @@ -11637,15 +12292,25 @@ lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__13() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Term_if___elambda__1___closed__12; +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_if___elambda__1___closed__14() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Parser_Term_if___elambda__1___closed__12; +x_2 = l_Lean_Parser_Term_if___elambda__1___closed__13; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__14() { +lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__15() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -11655,29 +12320,29 @@ x_3 = lean_string_append(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__15() { +lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__16() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_if___elambda__1___closed__14; +x_1 = l_Lean_Parser_Term_if___elambda__1___closed__15; 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_if___elambda__1___closed__16() { +lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__17() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Parser_Term_if___elambda__1___closed__15; +x_2 = l_Lean_Parser_Term_if___elambda__1___closed__16; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__17() { +lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__18() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -11687,25 +12352,13 @@ x_3 = lean_string_append(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Parser_Term_if___elambda__1___closed__18() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_if___elambda__1___closed__17; -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_if___elambda__1___closed__19() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = lean_box(0); -x_2 = l_Lean_Parser_Term_if___elambda__1___closed__18; -x_3 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_3, 0, x_2); -lean_ctor_set(x_3, 1, x_1); +x_1 = l_Lean_Parser_Term_if___elambda__1___closed__18; +x_2 = l_Char_HasRepr___closed__1; +x_3 = lean_string_append(x_1, x_2); return x_3; } } @@ -11714,7 +12367,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Parser_Term_if___elambda__1___closed__12; +x_2 = l_Lean_Parser_Term_if___elambda__1___closed__19; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); @@ -11733,622 +12386,651 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_42; lean_object* x_71; lean_object* x_72; lean_object* x_73; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_71 = lean_ctor_get(x_2, 1); -lean_inc(x_71); -lean_inc(x_1); -x_72 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_74 = lean_ctor_get(x_72, 0); -lean_inc(x_74); -x_75 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_74); -lean_dec(x_74); -if (lean_obj_tag(x_75) == 2) -{ -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_if___elambda__1___closed__6; -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_if___elambda__1___closed__19; -x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_79, x_71); -x_42 = x_80; -goto block_70; -} -else -{ -lean_dec(x_71); -x_42 = x_72; -goto block_70; -} -} -else -{ -lean_object* x_81; lean_object* x_82; -lean_dec(x_75); -x_81 = l_Lean_Parser_Term_if___elambda__1___closed__19; -x_82 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_81, x_71); -x_42 = x_82; -goto block_70; -} -} -else -{ -lean_object* x_83; lean_object* x_84; -lean_dec(x_73); -x_83 = l_Lean_Parser_Term_if___elambda__1___closed__19; -x_84 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_83, x_71); -x_42 = x_84; -goto block_70; -} -block_41: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(0u); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_46; lean_object* x_75; lean_object* x_76; lean_object* x_77; +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_75 = lean_ctor_get(x_8, 1); +lean_inc(x_75); lean_inc(x_1); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); +x_76 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_78 = lean_ctor_get(x_76, 0); +lean_inc(x_78); +x_79 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_Term_if___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_Term_if___elambda__1___closed__20; +x_84 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_83, x_75); +x_46 = x_84; +goto block_74; +} +else +{ +lean_dec(x_75); +x_46 = x_76; +goto block_74; +} +} +else +{ +lean_object* x_85; lean_object* x_86; +lean_dec(x_79); +x_85 = l_Lean_Parser_Term_if___elambda__1___closed__20; +x_86 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_85, x_75); +x_46 = x_86; +goto block_74; +} +} +else +{ +lean_object* x_87; lean_object* x_88; +lean_dec(x_77); +x_87 = l_Lean_Parser_Term_if___elambda__1___closed__20; +x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_87, x_75); +x_46 = x_88; +goto block_74; +} +block_45: +{ +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; -x_14 = lean_ctor_get(x_12, 1); -lean_inc(x_14); +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_15 = l_Lean_Parser_tokenFn(x_1, 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_object* x_18; -x_17 = lean_ctor_get(x_15, 0); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = lean_ctor_get(x_16, 3); 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) +if (lean_obj_tag(x_17) == 0) { -lean_object* x_19; lean_object* x_20; uint8_t x_21; -x_19 = lean_ctor_get(x_18, 1); -lean_inc(x_19); -lean_dec(x_18); -x_20 = l_Lean_Parser_Term_if___elambda__1___closed__10; -x_21 = lean_string_dec_eq(x_19, x_20); -lean_dec(x_19); -if (x_21 == 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_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_19, 0); +lean_inc(x_21); +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); +lean_dec(x_22); +x_24 = l_Lean_Parser_Term_if___elambda__1___closed__10; +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_dec(x_1); -x_22 = l_Lean_Parser_Term_if___elambda__1___closed__13; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); -x_24 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); -return x_25; +x_26 = l_Lean_Parser_Term_if___elambda__1___closed__14; +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); +x_28 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); +return x_29; } else { -lean_object* x_26; lean_object* x_27; lean_object* x_28; -lean_dec(x_14); -x_26 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_15); -x_27 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_7); -return x_28; -} -} -else -{ -lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_dec(x_18); -lean_dec(x_1); -x_29 = l_Lean_Parser_Term_if___elambda__1___closed__13; -x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_29, x_14); +x_30 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_19); x_31 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_7); +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_11); return x_32; } } else { lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -lean_dec(x_16); +lean_dec(x_22); lean_dec(x_1); -x_33 = l_Lean_Parser_Term_if___elambda__1___closed__13; -x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_33, x_14); +x_33 = l_Lean_Parser_Term_if___elambda__1___closed__14; +x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_33, x_18); x_35 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_7); +x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_11); return x_36; } } else { -lean_object* x_37; lean_object* x_38; -lean_dec(x_13); +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +lean_dec(x_20); lean_dec(x_1); -x_37 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkNode(x_12, x_37, x_7); -return x_38; +x_37 = l_Lean_Parser_Term_if___elambda__1___closed__14; +x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_37, x_18); +x_39 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_11); +return x_40; } } else { -lean_object* x_39; lean_object* x_40; -lean_dec(x_9); +lean_object* x_41; lean_object* x_42; +lean_dec(x_17); lean_dec(x_1); -x_39 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_40 = l_Lean_Parser_ParserState_mkNode(x_8, x_39, x_7); -return x_40; +x_41 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkNode(x_16, x_41, x_11); +return x_42; } } -block_70: +else { -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_43; lean_object* x_44; +lean_dec(x_13); +lean_dec(x_1); +x_43 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_44 = l_Lean_Parser_ParserState_mkNode(x_12, x_43, x_11); +return x_44; +} +} +block_74: { -lean_object* x_44; lean_object* x_45; +lean_object* x_47; +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_1); -x_44 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, 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_termParser___closed__2; -x_47 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_48 = l_Lean_Parser_categoryParser___elambda__1(x_46, x_47, x_1, x_44); +x_48 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, 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_inc(x_50); +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_50 = l_Lean_Parser_termParser___closed__2; +x_51 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_51 = l_Lean_Parser_tokenFn(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; -x_53 = lean_ctor_get(x_51, 0); +x_52 = l_Lean_Parser_categoryParser___elambda__1(x_50, x_51, x_1, x_48); +x_53 = lean_ctor_get(x_52, 3); 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) +if (lean_obj_tag(x_53) == 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_if___elambda__1___closed__8; -x_57 = lean_string_dec_eq(x_55, x_56); -lean_dec(x_55); -if (x_57 == 0) +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_52, 1); +lean_inc(x_54); +lean_inc(x_1); +x_55 = l_Lean_Parser_tokenFn(x_1, x_52); +x_56 = lean_ctor_get(x_55, 3); +lean_inc(x_56); +if (lean_obj_tag(x_56) == 0) { -lean_object* x_58; lean_object* x_59; -x_58 = l_Lean_Parser_Term_if___elambda__1___closed__16; -x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_58, x_50); -x_8 = x_59; -goto block_41; -} -else +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_dec(x_50); -x_8 = x_51; -goto block_41; -} -} -else -{ -lean_object* x_60; lean_object* x_61; -lean_dec(x_54); -x_60 = l_Lean_Parser_Term_if___elambda__1___closed__16; -x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_60, x_50); -x_8 = x_61; -goto block_41; -} -} -else +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_if___elambda__1___closed__8; +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; -lean_dec(x_52); -x_62 = l_Lean_Parser_Term_if___elambda__1___closed__16; -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_62, x_50); -x_8 = x_63; -goto block_41; +x_62 = l_Lean_Parser_Term_if___elambda__1___closed__17; +x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_54); +x_12 = x_63; +goto block_45; +} +else +{ +lean_dec(x_54); +x_12 = x_55; +goto block_45; } } else { lean_object* x_64; lean_object* x_65; -lean_dec(x_49); -lean_dec(x_1); -x_64 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_65 = l_Lean_Parser_ParserState_mkNode(x_48, x_64, x_7); -return x_65; +lean_dec(x_58); +x_64 = l_Lean_Parser_Term_if___elambda__1___closed__17; +x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_54); +x_12 = x_65; +goto block_45; } } else { lean_object* x_66; lean_object* x_67; -lean_dec(x_45); -lean_dec(x_1); -x_66 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_67 = l_Lean_Parser_ParserState_mkNode(x_44, x_66, x_7); -return x_67; +lean_dec(x_56); +x_66 = l_Lean_Parser_Term_if___elambda__1___closed__17; +x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_54); +x_12 = x_67; +goto block_45; } } else { lean_object* x_68; lean_object* x_69; -lean_dec(x_43); +lean_dec(x_53); lean_dec(x_1); x_68 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_69 = l_Lean_Parser_ParserState_mkNode(x_42, x_68, x_7); +x_69 = l_Lean_Parser_ParserState_mkNode(x_52, x_68, x_11); return x_69; } } +else +{ +lean_object* x_70; lean_object* x_71; +lean_dec(x_49); +lean_dec(x_1); +x_70 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_71 = l_Lean_Parser_ParserState_mkNode(x_48, x_70, x_11); +return x_71; +} } else { -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_2, 0); -lean_inc(x_85); -x_86 = lean_array_get_size(x_85); -lean_dec(x_85); -x_87 = lean_ctor_get(x_2, 1); -lean_inc(x_87); -lean_inc(x_1); -x_88 = lean_apply_2(x_4, x_1, x_2); -x_89 = lean_ctor_get(x_88, 3); +lean_object* x_72; lean_object* x_73; +lean_dec(x_47); +lean_dec(x_1); +x_72 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_73 = l_Lean_Parser_ParserState_mkNode(x_46, x_72, x_11); +return x_73; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_89 = lean_ctor_get(x_2, 0); lean_inc(x_89); -if (lean_obj_tag(x_89) == 0) -{ -lean_dec(x_87); -lean_dec(x_86); -lean_dec(x_1); -return x_88; -} -else -{ -lean_object* x_90; lean_object* x_91; uint8_t x_92; -x_90 = lean_ctor_get(x_89, 0); -lean_inc(x_90); +x_90 = lean_array_get_size(x_89); lean_dec(x_89); -x_91 = lean_ctor_get(x_88, 1); +x_91 = lean_ctor_get(x_2, 1); lean_inc(x_91); -x_92 = lean_nat_dec_eq(x_91, x_87); -lean_dec(x_91); -if (x_92 == 0) +lean_inc(x_1); +x_92 = lean_apply_2(x_4, x_1, x_2); +x_93 = lean_ctor_get(x_92, 3); +lean_inc(x_93); +if (lean_obj_tag(x_93) == 0) { +lean_dec(x_91); lean_dec(x_90); -lean_dec(x_87); -lean_dec(x_86); lean_dec(x_1); -return x_88; +return x_92; } else { -lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_136; lean_object* x_171; lean_object* x_172; -lean_inc(x_87); -x_93 = l_Lean_Parser_ParserState_restore(x_88, x_86, x_87); -lean_dec(x_86); +lean_object* x_94; lean_object* x_95; uint8_t x_96; x_94 = lean_ctor_get(x_93, 0); lean_inc(x_94); -x_95 = lean_array_get_size(x_94); +lean_dec(x_93); +x_95 = lean_ctor_get(x_92, 1); +lean_inc(x_95); +x_96 = lean_nat_dec_eq(x_95, x_91); +lean_dec(x_95); +if (x_96 == 0) +{ lean_dec(x_94); -lean_inc(x_1); -x_171 = l_Lean_Parser_tokenFn(x_1, x_93); -x_172 = lean_ctor_get(x_171, 3); -lean_inc(x_172); -if (lean_obj_tag(x_172) == 0) -{ -lean_object* x_173; lean_object* x_174; -x_173 = lean_ctor_get(x_171, 0); -lean_inc(x_173); -x_174 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_173); -lean_dec(x_173); -if (lean_obj_tag(x_174) == 2) -{ -lean_object* x_175; lean_object* x_176; uint8_t x_177; -x_175 = lean_ctor_get(x_174, 1); -lean_inc(x_175); -lean_dec(x_174); -x_176 = l_Lean_Parser_Term_if___elambda__1___closed__6; -x_177 = lean_string_dec_eq(x_175, x_176); -lean_dec(x_175); -if (x_177 == 0) -{ -lean_object* x_178; lean_object* x_179; -x_178 = l_Lean_Parser_Term_if___elambda__1___closed__19; -lean_inc(x_87); -x_179 = l_Lean_Parser_ParserState_mkErrorsAt(x_171, x_178, x_87); -x_136 = x_179; -goto block_170; +lean_dec(x_91); +lean_dec(x_90); +lean_dec(x_1); +return x_92; } else { -x_136 = x_171; -goto block_170; -} -} -else -{ -lean_object* x_180; lean_object* x_181; -lean_dec(x_174); -x_180 = l_Lean_Parser_Term_if___elambda__1___closed__19; -lean_inc(x_87); -x_181 = l_Lean_Parser_ParserState_mkErrorsAt(x_171, x_180, x_87); -x_136 = x_181; -goto block_170; -} -} -else -{ -lean_object* x_182; lean_object* x_183; -lean_dec(x_172); -x_182 = l_Lean_Parser_Term_if___elambda__1___closed__19; -lean_inc(x_87); -x_183 = l_Lean_Parser_ParserState_mkErrorsAt(x_171, x_182, x_87); -x_136 = x_183; -goto block_170; -} -block_135: -{ -lean_object* x_97; -x_97 = lean_ctor_get(x_96, 3); -lean_inc(x_97); -if (lean_obj_tag(x_97) == 0) -{ -lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; -x_98 = l_Lean_Parser_termParser___closed__2; -x_99 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_100 = l_Lean_Parser_categoryParser___elambda__1(x_98, x_99, x_1, x_96); +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +lean_inc(x_91); +x_97 = l_Lean_Parser_ParserState_restore(x_92, x_90, x_91); +lean_dec(x_90); +x_98 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_99 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_100 = l_Lean_Parser_checkRbpLtFn(x_98, x_99, x_1, x_97); x_101 = lean_ctor_get(x_100, 3); lean_inc(x_101); if (lean_obj_tag(x_101) == 0) { -lean_object* x_102; lean_object* x_103; lean_object* x_104; -x_102 = lean_ctor_get(x_100, 1); +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_144; lean_object* x_176; lean_object* x_177; lean_object* x_178; +x_102 = lean_ctor_get(x_100, 0); lean_inc(x_102); -lean_inc(x_1); -x_103 = l_Lean_Parser_tokenFn(x_1, x_100); -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; -x_105 = lean_ctor_get(x_103, 0); -lean_inc(x_105); -x_106 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_Lean_Parser_Term_if___elambda__1___closed__10; -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; lean_object* x_112; lean_object* x_113; lean_object* x_114; -lean_dec(x_1); -x_110 = l_Lean_Parser_Term_if___elambda__1___closed__13; -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_110, x_102); -x_112 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_113 = l_Lean_Parser_ParserState_mkNode(x_111, x_112, x_95); -x_114 = l_Lean_Parser_mergeOrElseErrors(x_113, x_90, x_87); -lean_dec(x_87); -return x_114; -} -else -{ -lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; +x_103 = lean_array_get_size(x_102); lean_dec(x_102); -x_115 = l_Lean_Parser_categoryParser___elambda__1(x_98, x_99, x_1, x_103); -x_116 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_117 = l_Lean_Parser_ParserState_mkNode(x_115, x_116, x_95); -x_118 = l_Lean_Parser_mergeOrElseErrors(x_117, x_90, x_87); -lean_dec(x_87); -return x_118; +x_176 = lean_ctor_get(x_100, 1); +lean_inc(x_176); +lean_inc(x_1); +x_177 = l_Lean_Parser_tokenFn(x_1, x_100); +x_178 = lean_ctor_get(x_177, 3); +lean_inc(x_178); +if (lean_obj_tag(x_178) == 0) +{ +lean_object* x_179; lean_object* x_180; +x_179 = lean_ctor_get(x_177, 0); +lean_inc(x_179); +x_180 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_179); +lean_dec(x_179); +if (lean_obj_tag(x_180) == 2) +{ +lean_object* x_181; lean_object* x_182; uint8_t x_183; +x_181 = lean_ctor_get(x_180, 1); +lean_inc(x_181); +lean_dec(x_180); +x_182 = l_Lean_Parser_Term_if___elambda__1___closed__6; +x_183 = lean_string_dec_eq(x_181, x_182); +lean_dec(x_181); +if (x_183 == 0) +{ +lean_object* x_184; lean_object* x_185; +x_184 = l_Lean_Parser_Term_if___elambda__1___closed__20; +x_185 = l_Lean_Parser_ParserState_mkErrorsAt(x_177, x_184, x_176); +x_144 = x_185; +goto block_175; +} +else +{ +lean_dec(x_176); +x_144 = x_177; +goto block_175; } } else { -lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; -lean_dec(x_106); -lean_dec(x_1); -x_119 = l_Lean_Parser_Term_if___elambda__1___closed__13; -x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_119, x_102); -x_121 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_122 = l_Lean_Parser_ParserState_mkNode(x_120, x_121, x_95); -x_123 = l_Lean_Parser_mergeOrElseErrors(x_122, x_90, x_87); -lean_dec(x_87); -return x_123; +lean_object* x_186; lean_object* x_187; +lean_dec(x_180); +x_186 = l_Lean_Parser_Term_if___elambda__1___closed__20; +x_187 = l_Lean_Parser_ParserState_mkErrorsAt(x_177, x_186, x_176); +x_144 = x_187; +goto block_175; } } else { -lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; -lean_dec(x_104); +lean_object* x_188; lean_object* x_189; +lean_dec(x_178); +x_188 = l_Lean_Parser_Term_if___elambda__1___closed__20; +x_189 = l_Lean_Parser_ParserState_mkErrorsAt(x_177, x_188, x_176); +x_144 = x_189; +goto block_175; +} +block_143: +{ +lean_object* x_105; +x_105 = lean_ctor_get(x_104, 3); +lean_inc(x_105); +if (lean_obj_tag(x_105) == 0) +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_106 = l_Lean_Parser_termParser___closed__2; +x_107 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_108 = l_Lean_Parser_categoryParser___elambda__1(x_106, x_107, x_1, x_104); +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; lean_object* x_112; +x_110 = lean_ctor_get(x_108, 1); +lean_inc(x_110); +lean_inc(x_1); +x_111 = l_Lean_Parser_tokenFn(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; +x_113 = lean_ctor_get(x_111, 0); +lean_inc(x_113); +x_114 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_113); +lean_dec(x_113); +if (lean_obj_tag(x_114) == 2) +{ +lean_object* x_115; lean_object* x_116; uint8_t x_117; +x_115 = lean_ctor_get(x_114, 1); +lean_inc(x_115); +lean_dec(x_114); +x_116 = l_Lean_Parser_Term_if___elambda__1___closed__10; +x_117 = lean_string_dec_eq(x_115, x_116); +lean_dec(x_115); +if (x_117 == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_dec(x_1); -x_124 = l_Lean_Parser_Term_if___elambda__1___closed__13; -x_125 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_124, x_102); -x_126 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_127 = l_Lean_Parser_ParserState_mkNode(x_125, x_126, x_95); -x_128 = l_Lean_Parser_mergeOrElseErrors(x_127, x_90, x_87); -lean_dec(x_87); -return x_128; +x_118 = l_Lean_Parser_Term_if___elambda__1___closed__14; +x_119 = l_Lean_Parser_ParserState_mkErrorsAt(x_111, x_118, x_110); +x_120 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_121 = l_Lean_Parser_ParserState_mkNode(x_119, x_120, x_103); +x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_94, x_91); +lean_dec(x_91); +return x_122; +} +else +{ +lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; +lean_dec(x_110); +x_123 = l_Lean_Parser_categoryParser___elambda__1(x_106, x_107, x_1, x_111); +x_124 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_125 = l_Lean_Parser_ParserState_mkNode(x_123, x_124, x_103); +x_126 = l_Lean_Parser_mergeOrElseErrors(x_125, x_94, x_91); +lean_dec(x_91); +return x_126; } } else { -lean_object* x_129; lean_object* x_130; lean_object* x_131; -lean_dec(x_101); +lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; +lean_dec(x_114); lean_dec(x_1); +x_127 = l_Lean_Parser_Term_if___elambda__1___closed__14; +x_128 = l_Lean_Parser_ParserState_mkErrorsAt(x_111, x_127, x_110); x_129 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_130 = l_Lean_Parser_ParserState_mkNode(x_100, x_129, x_95); -x_131 = l_Lean_Parser_mergeOrElseErrors(x_130, x_90, x_87); -lean_dec(x_87); +x_130 = l_Lean_Parser_ParserState_mkNode(x_128, x_129, x_103); +x_131 = l_Lean_Parser_mergeOrElseErrors(x_130, x_94, x_91); +lean_dec(x_91); return x_131; } } else { -lean_object* x_132; lean_object* x_133; lean_object* x_134; -lean_dec(x_97); +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; +lean_dec(x_112); lean_dec(x_1); -x_132 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_133 = l_Lean_Parser_ParserState_mkNode(x_96, x_132, x_95); -x_134 = l_Lean_Parser_mergeOrElseErrors(x_133, x_90, x_87); -lean_dec(x_87); -return x_134; +x_132 = l_Lean_Parser_Term_if___elambda__1___closed__14; +x_133 = l_Lean_Parser_ParserState_mkErrorsAt(x_111, x_132, x_110); +x_134 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_135 = l_Lean_Parser_ParserState_mkNode(x_133, x_134, x_103); +x_136 = l_Lean_Parser_mergeOrElseErrors(x_135, x_94, x_91); +lean_dec(x_91); +return x_136; } } -block_170: +else { -lean_object* x_137; -x_137 = lean_ctor_get(x_136, 3); -lean_inc(x_137); -if (lean_obj_tag(x_137) == 0) +lean_object* x_137; lean_object* x_138; lean_object* x_139; +lean_dec(x_109); +lean_dec(x_1); +x_137 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_138 = l_Lean_Parser_ParserState_mkNode(x_108, x_137, x_103); +x_139 = l_Lean_Parser_mergeOrElseErrors(x_138, x_94, x_91); +lean_dec(x_91); +return x_139; +} +} +else { -lean_object* x_138; lean_object* x_139; +lean_object* x_140; lean_object* x_141; lean_object* x_142; +lean_dec(x_105); +lean_dec(x_1); +x_140 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_141 = l_Lean_Parser_ParserState_mkNode(x_104, x_140, x_103); +x_142 = l_Lean_Parser_mergeOrElseErrors(x_141, x_94, x_91); +lean_dec(x_91); +return x_142; +} +} +block_175: +{ +lean_object* x_145; +x_145 = lean_ctor_get(x_144, 3); +lean_inc(x_145); +if (lean_obj_tag(x_145) == 0) +{ +lean_object* x_146; lean_object* x_147; lean_inc(x_1); -x_138 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_136); -x_139 = lean_ctor_get(x_138, 3); -lean_inc(x_139); -if (lean_obj_tag(x_139) == 0) -{ -lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; -x_140 = l_Lean_Parser_termParser___closed__2; -x_141 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_142 = l_Lean_Parser_categoryParser___elambda__1(x_140, x_141, x_1, x_138); -x_143 = lean_ctor_get(x_142, 3); -lean_inc(x_143); -if (lean_obj_tag(x_143) == 0) -{ -lean_object* x_144; lean_object* x_145; lean_object* x_146; -x_144 = lean_ctor_get(x_142, 1); -lean_inc(x_144); -lean_inc(x_1); -x_145 = l_Lean_Parser_tokenFn(x_1, x_142); -x_146 = lean_ctor_get(x_145, 3); -lean_inc(x_146); -if (lean_obj_tag(x_146) == 0) -{ -lean_object* x_147; lean_object* x_148; -x_147 = lean_ctor_get(x_145, 0); +x_146 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_144); +x_147 = lean_ctor_get(x_146, 3); lean_inc(x_147); -x_148 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_147); +if (lean_obj_tag(x_147) == 0) +{ +lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_148 = l_Lean_Parser_termParser___closed__2; +x_149 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_150 = l_Lean_Parser_categoryParser___elambda__1(x_148, x_149, x_1, x_146); +x_151 = lean_ctor_get(x_150, 3); +lean_inc(x_151); +if (lean_obj_tag(x_151) == 0) +{ +lean_object* x_152; lean_object* x_153; lean_object* x_154; +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +lean_inc(x_1); +x_153 = l_Lean_Parser_tokenFn(x_1, x_150); +x_154 = lean_ctor_get(x_153, 3); +lean_inc(x_154); +if (lean_obj_tag(x_154) == 0) +{ +lean_object* x_155; lean_object* x_156; +x_155 = lean_ctor_get(x_153, 0); +lean_inc(x_155); +x_156 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_155); +lean_dec(x_155); +if (lean_obj_tag(x_156) == 2) +{ +lean_object* x_157; lean_object* x_158; uint8_t x_159; +x_157 = lean_ctor_get(x_156, 1); +lean_inc(x_157); +lean_dec(x_156); +x_158 = l_Lean_Parser_Term_if___elambda__1___closed__8; +x_159 = lean_string_dec_eq(x_157, x_158); +lean_dec(x_157); +if (x_159 == 0) +{ +lean_object* x_160; lean_object* x_161; +x_160 = l_Lean_Parser_Term_if___elambda__1___closed__17; +x_161 = l_Lean_Parser_ParserState_mkErrorsAt(x_153, x_160, x_152); +x_104 = x_161; +goto block_143; +} +else +{ +lean_dec(x_152); +x_104 = x_153; +goto block_143; +} +} +else +{ +lean_object* x_162; lean_object* x_163; +lean_dec(x_156); +x_162 = l_Lean_Parser_Term_if___elambda__1___closed__17; +x_163 = l_Lean_Parser_ParserState_mkErrorsAt(x_153, x_162, x_152); +x_104 = x_163; +goto block_143; +} +} +else +{ +lean_object* x_164; lean_object* x_165; +lean_dec(x_154); +x_164 = l_Lean_Parser_Term_if___elambda__1___closed__17; +x_165 = l_Lean_Parser_ParserState_mkErrorsAt(x_153, x_164, x_152); +x_104 = x_165; +goto block_143; +} +} +else +{ +lean_object* x_166; lean_object* x_167; lean_object* x_168; +lean_dec(x_151); +lean_dec(x_1); +x_166 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_167 = l_Lean_Parser_ParserState_mkNode(x_150, x_166, x_103); +x_168 = l_Lean_Parser_mergeOrElseErrors(x_167, x_94, x_91); +lean_dec(x_91); +return x_168; +} +} +else +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_dec(x_147); -if (lean_obj_tag(x_148) == 2) -{ -lean_object* x_149; lean_object* x_150; uint8_t x_151; -x_149 = lean_ctor_get(x_148, 1); -lean_inc(x_149); -lean_dec(x_148); -x_150 = l_Lean_Parser_Term_if___elambda__1___closed__8; -x_151 = lean_string_dec_eq(x_149, x_150); -lean_dec(x_149); -if (x_151 == 0) -{ -lean_object* x_152; lean_object* x_153; -x_152 = l_Lean_Parser_Term_if___elambda__1___closed__16; -x_153 = l_Lean_Parser_ParserState_mkErrorsAt(x_145, x_152, x_144); -x_96 = x_153; -goto block_135; -} -else -{ -lean_dec(x_144); -x_96 = x_145; -goto block_135; -} -} -else -{ -lean_object* x_154; lean_object* x_155; -lean_dec(x_148); -x_154 = l_Lean_Parser_Term_if___elambda__1___closed__16; -x_155 = l_Lean_Parser_ParserState_mkErrorsAt(x_145, x_154, x_144); -x_96 = x_155; -goto block_135; -} -} -else -{ -lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; -lean_dec(x_146); lean_dec(x_1); -x_156 = l_Lean_Parser_Term_if___elambda__1___closed__16; -x_157 = l_Lean_Parser_ParserState_mkErrorsAt(x_145, x_156, x_144); -x_158 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_159 = l_Lean_Parser_ParserState_mkNode(x_157, x_158, x_95); -x_160 = l_Lean_Parser_mergeOrElseErrors(x_159, x_90, x_87); -lean_dec(x_87); -return x_160; +x_169 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_170 = l_Lean_Parser_ParserState_mkNode(x_146, x_169, x_103); +x_171 = l_Lean_Parser_mergeOrElseErrors(x_170, x_94, x_91); +lean_dec(x_91); +return x_171; } } else { -lean_object* x_161; lean_object* x_162; lean_object* x_163; -lean_dec(x_143); +lean_object* x_172; lean_object* x_173; lean_object* x_174; +lean_dec(x_145); lean_dec(x_1); -x_161 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_162 = l_Lean_Parser_ParserState_mkNode(x_142, x_161, x_95); -x_163 = l_Lean_Parser_mergeOrElseErrors(x_162, x_90, x_87); -lean_dec(x_87); -return x_163; +x_172 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_173 = l_Lean_Parser_ParserState_mkNode(x_144, x_172, x_103); +x_174 = l_Lean_Parser_mergeOrElseErrors(x_173, x_94, x_91); +lean_dec(x_91); +return x_174; +} } } else { -lean_object* x_164; lean_object* x_165; lean_object* x_166; -lean_dec(x_139); +lean_object* x_190; +lean_dec(x_101); lean_dec(x_1); -x_164 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_165 = l_Lean_Parser_ParserState_mkNode(x_138, x_164, x_95); -x_166 = l_Lean_Parser_mergeOrElseErrors(x_165, x_90, x_87); -lean_dec(x_87); -return x_166; -} -} -else -{ -lean_object* x_167; lean_object* x_168; lean_object* x_169; -lean_dec(x_137); -lean_dec(x_1); -x_167 = l_Lean_Parser_Term_if___elambda__1___closed__2; -x_168 = l_Lean_Parser_ParserState_mkNode(x_136, x_167, x_95); -x_169 = l_Lean_Parser_mergeOrElseErrors(x_168, x_90, x_87); -lean_dec(x_87); -return x_169; -} +x_190 = l_Lean_Parser_mergeOrElseErrors(x_100, x_94, x_91); +lean_dec(x_91); +return x_190; } } } @@ -12359,81 +13041,80 @@ lean_object* _init_l_Lean_Parser_Term_if___closed__1() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_Term_leadPrec; -x_2 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_2, 0, x_1); +x_1 = l_Lean_Parser_Term_if___elambda__1___closed__6; +x_2 = l_Lean_Parser_symbolInfo(x_1); return x_2; } } lean_object* _init_l_Lean_Parser_Term_if___closed__2() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_if___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Parser_Term_if___elambda__1___closed__8; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_if___closed__3() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_if___elambda__1___closed__8; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Parser_Term_if___elambda__1___closed__10; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_if___closed__4() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_if___elambda__1___closed__10; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +x_3 = l_Lean_Parser_Term_if___closed__3; +x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); +return x_4; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_if___closed__4; -x_4 = l_Lean_Parser_andthenInfo(x_3, x_2); +x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } } lean_object* _init_l_Lean_Parser_Term_if___closed__6() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; -x_2 = lean_ctor_get(x_1, 0); -lean_inc(x_2); -x_3 = l_Lean_Parser_Term_if___closed__5; -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_if___closed__2; +x_2 = l_Lean_Parser_Term_if___closed__5; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_if___closed__7() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_if___closed__3; -x_2 = l_Lean_Parser_Term_if___closed__6; -x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +x_3 = l_Lean_Parser_Term_if___closed__6; +x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); +return x_4; } } lean_object* _init_l_Lean_Parser_Term_if___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_Term_optIdent; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_if___closed__7; @@ -12444,22 +13125,20 @@ return x_4; lean_object* _init_l_Lean_Parser_Term_if___closed__9() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Term_optIdent; -x_2 = lean_ctor_get(x_1, 0); -lean_inc(x_2); -x_3 = l_Lean_Parser_Term_if___closed__8; -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_if___closed__1; +x_2 = l_Lean_Parser_Term_if___closed__8; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_if___closed__10() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_if___closed__2; +x_1 = l_Lean_Parser_Term_if___elambda__1___closed__2; x_2 = l_Lean_Parser_Term_if___closed__9; -x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); return x_3; } } @@ -12467,9 +13146,9 @@ lean_object* _init_l_Lean_Parser_Term_if___closed__11() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_if___elambda__1___closed__2; +x_1 = l_Lean_Parser_epsilonInfo; x_2 = l_Lean_Parser_Term_if___closed__10; -x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } } @@ -12854,18 +13533,17 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_fromTerm___closed__1() { _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_fromTerm___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_fromTerm___closed__1; @@ -13244,18 +13922,17 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_haveAssign___closed__1() { _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_haveAssign___elambda__1___closed__5; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_haveAssign___closed__1; @@ -13413,642 +14090,603 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_38; lean_object* x_64; lean_object* x_65; lean_object* x_66; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_64 = lean_ctor_get(x_2, 1); -lean_inc(x_64); -lean_inc(x_1); -x_65 = l_Lean_Parser_tokenFn(x_1, x_2); -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__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_have___elambda__1___closed__9; -x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_72, x_64); -x_38 = x_73; -goto block_63; -} -else -{ -lean_dec(x_64); -x_38 = x_65; -goto block_63; -} -} -else -{ -lean_object* x_74; lean_object* x_75; -lean_dec(x_68); -x_74 = l_Lean_Parser_Term_have___elambda__1___closed__9; -x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_74, x_64); -x_38 = x_75; -goto block_63; -} -} -else -{ -lean_object* x_76; lean_object* x_77; -lean_dec(x_66); -x_76 = l_Lean_Parser_Term_have___elambda__1___closed__9; -x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_65, x_76, x_64); -x_38 = x_77; -goto block_63; -} -block_37: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; -x_10 = lean_ctor_get(x_8, 1); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_42; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_10 = lean_ctor_get(x_8, 0); lean_inc(x_10); -lean_inc(x_1); -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_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -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; -lean_dec(x_1); -x_18 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_18, x_10); -x_20 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_7); -return x_21; -} -else -{ -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_11 = lean_array_get_size(x_10); lean_dec(x_10); -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_11); -x_25 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_7); -return x_26; +x_68 = lean_ctor_get(x_8, 1); +lean_inc(x_68); +lean_inc(x_1); +x_69 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_71 = lean_ctor_get(x_69, 0); +lean_inc(x_71); +x_72 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_71); +lean_dec(x_71); +if (lean_obj_tag(x_72) == 2) +{ +lean_object* x_73; lean_object* x_74; uint8_t x_75; +x_73 = lean_ctor_get(x_72, 1); +lean_inc(x_73); +lean_dec(x_72); +x_74 = l_Lean_Parser_Term_have___elambda__1___closed__6; +x_75 = lean_string_dec_eq(x_73, x_74); +lean_dec(x_73); +if (x_75 == 0) +{ +lean_object* x_76; lean_object* x_77; +x_76 = l_Lean_Parser_Term_have___elambda__1___closed__9; +x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_76, x_68); +x_42 = x_77; +goto block_67; +} +else +{ +lean_dec(x_68); +x_42 = x_69; +goto block_67; } } else { -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; -lean_dec(x_14); +lean_object* x_78; lean_object* x_79; +lean_dec(x_72); +x_78 = l_Lean_Parser_Term_have___elambda__1___closed__9; +x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_78, x_68); +x_42 = x_79; +goto block_67; +} +} +else +{ +lean_object* x_80; lean_object* x_81; +lean_dec(x_70); +x_80 = l_Lean_Parser_Term_have___elambda__1___closed__9; +x_81 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_80, x_68); +x_42 = x_81; +goto block_67; +} +block_41: +{ +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; +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_inc(x_1); +x_15 = l_Lean_Parser_tokenFn(x_1, 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_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); +lean_dec(x_18); +x_20 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; +x_21 = lean_string_dec_eq(x_19, x_20); +lean_dec(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_dec(x_1); -x_27 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_27, x_10); +x_22 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); +x_24 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_11); +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_dec(x_14); +x_26 = l_Lean_Parser_termParser___closed__2; +x_27 = lean_unsigned_to_nat(0u); +x_28 = l_Lean_Parser_categoryParser___elambda__1(x_26, x_27, x_1, x_15); x_29 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_7); +x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_11); return x_30; } } else { lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_12); +lean_dec(x_18); lean_dec(x_1); x_31 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_31, x_10); +x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_31, x_14); x_33 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_7); +x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_11); return x_34; } } else { -lean_object* x_35; lean_object* x_36; -lean_dec(x_9); +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_16); lean_dec(x_1); -x_35 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_8, x_35, x_7); -return x_36; +x_35 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_35, x_14); +x_37 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_11); +return x_38; } } -block_63: +else { -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_39; lean_object* x_40; +lean_dec(x_13); +lean_dec(x_1); +x_39 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_40 = l_Lean_Parser_ParserState_mkNode(x_12, x_39, x_11); +return x_40; +} +} +block_67: { -lean_object* x_40; lean_object* x_41; +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_44; lean_object* x_45; lean_inc(x_1); -x_40 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_38); -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; -x_42 = l_Lean_Parser_termParser___closed__2; -x_43 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_44 = l_Lean_Parser_categoryParser___elambda__1(x_42, x_43, x_1, x_40); +x_44 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, 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; lean_object* x_50; -x_46 = lean_ctor_get(x_44, 0); -lean_inc(x_46); -x_47 = lean_array_get_size(x_46); -lean_dec(x_46); -x_48 = lean_ctor_get(x_44, 1); -lean_inc(x_48); +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_46 = l_Lean_Parser_termParser___closed__2; +x_47 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_49 = l_Lean_Parser_Term_haveAssign___elambda__1(x_1, x_44); -x_50 = lean_ctor_get(x_49, 3); +x_48 = l_Lean_Parser_categoryParser___elambda__1(x_46, x_47, x_1, x_44); +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); -if (lean_obj_tag(x_50) == 0) -{ -lean_dec(x_48); -lean_dec(x_47); -x_8 = x_49; -goto block_37; -} -else -{ -lean_object* x_51; lean_object* x_52; uint8_t x_53; -x_51 = lean_ctor_get(x_50, 0); -lean_inc(x_51); +x_51 = lean_array_get_size(x_50); lean_dec(x_50); -x_52 = lean_ctor_get(x_49, 1); +x_52 = lean_ctor_get(x_48, 1); lean_inc(x_52); -x_53 = lean_nat_dec_eq(x_52, x_48); -lean_dec(x_52); -if (x_53 == 0) -{ -lean_dec(x_51); -lean_dec(x_48); -lean_dec(x_47); -x_8 = x_49; -goto block_37; -} -else -{ -lean_object* x_54; lean_object* x_55; lean_object* x_56; -lean_inc(x_48); -x_54 = l_Lean_Parser_ParserState_restore(x_49, x_47, x_48); -lean_dec(x_47); lean_inc(x_1); -x_55 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_54); -x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_51, x_48); -lean_dec(x_48); -x_8 = x_56; -goto block_37; -} -} +x_53 = l_Lean_Parser_Term_haveAssign___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_dec(x_52); +lean_dec(x_51); +x_12 = x_53; +goto block_41; } else { -lean_object* x_57; lean_object* x_58; -lean_dec(x_45); -lean_dec(x_1); -x_57 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_58 = l_Lean_Parser_ParserState_mkNode(x_44, x_57, x_7); -return x_58; -} +lean_object* x_55; lean_object* x_56; uint8_t x_57; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +lean_dec(x_54); +x_56 = lean_ctor_get(x_53, 1); +lean_inc(x_56); +x_57 = lean_nat_dec_eq(x_56, x_52); +lean_dec(x_56); +if (x_57 == 0) +{ +lean_dec(x_55); +lean_dec(x_52); +lean_dec(x_51); +x_12 = x_53; +goto block_41; } else { -lean_object* x_59; lean_object* x_60; -lean_dec(x_41); -lean_dec(x_1); -x_59 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_60 = l_Lean_Parser_ParserState_mkNode(x_40, x_59, x_7); -return x_60; +lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_inc(x_52); +x_58 = l_Lean_Parser_ParserState_restore(x_53, x_51, x_52); +lean_dec(x_51); +lean_inc(x_1); +x_59 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_58); +x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_55, x_52); +lean_dec(x_52); +x_12 = x_60; +goto block_41; +} } } else { lean_object* x_61; lean_object* x_62; -lean_dec(x_39); +lean_dec(x_49); lean_dec(x_1); x_61 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_62 = l_Lean_Parser_ParserState_mkNode(x_38, x_61, x_7); +x_62 = l_Lean_Parser_ParserState_mkNode(x_48, x_61, x_11); return x_62; } } +else +{ +lean_object* x_63; lean_object* x_64; +lean_dec(x_45); +lean_dec(x_1); +x_63 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_64 = l_Lean_Parser_ParserState_mkNode(x_44, x_63, x_11); +return x_64; +} } else { -lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_78 = lean_ctor_get(x_2, 0); -lean_inc(x_78); -x_79 = lean_array_get_size(x_78); -lean_dec(x_78); -x_80 = lean_ctor_get(x_2, 1); -lean_inc(x_80); -lean_inc(x_1); -x_81 = lean_apply_2(x_4, x_1, x_2); -x_82 = lean_ctor_get(x_81, 3); +lean_object* x_65; lean_object* x_66; +lean_dec(x_43); +lean_dec(x_1); +x_65 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_66 = l_Lean_Parser_ParserState_mkNode(x_42, x_65, x_11); +return x_66; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_2, 0); lean_inc(x_82); -if (lean_obj_tag(x_82) == 0) -{ -lean_dec(x_80); -lean_dec(x_79); -lean_dec(x_1); -return x_81; -} -else -{ -lean_object* x_83; lean_object* x_84; uint8_t x_85; -x_83 = lean_ctor_get(x_82, 0); -lean_inc(x_83); +x_83 = lean_array_get_size(x_82); lean_dec(x_82); -x_84 = lean_ctor_get(x_81, 1); +x_84 = lean_ctor_get(x_2, 1); lean_inc(x_84); -x_85 = lean_nat_dec_eq(x_84, x_80); -lean_dec(x_84); -if (x_85 == 0) +lean_inc(x_1); +x_85 = lean_apply_2(x_4, x_1, x_2); +x_86 = lean_ctor_get(x_85, 3); +lean_inc(x_86); +if (lean_obj_tag(x_86) == 0) { +lean_dec(x_84); lean_dec(x_83); -lean_dec(x_80); -lean_dec(x_79); lean_dec(x_1); -return x_81; +return x_85; } else { -lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_124; lean_object* x_180; lean_object* x_181; -lean_inc(x_80); -x_86 = l_Lean_Parser_ParserState_restore(x_81, x_79, x_80); -lean_dec(x_79); +lean_object* x_87; lean_object* x_88; uint8_t x_89; x_87 = lean_ctor_get(x_86, 0); lean_inc(x_87); -x_88 = lean_array_get_size(x_87); +lean_dec(x_86); +x_88 = lean_ctor_get(x_85, 1); +lean_inc(x_88); +x_89 = lean_nat_dec_eq(x_88, x_84); +lean_dec(x_88); +if (x_89 == 0) +{ lean_dec(x_87); -lean_inc(x_1); -x_180 = l_Lean_Parser_tokenFn(x_1, x_86); -x_181 = lean_ctor_get(x_180, 3); -lean_inc(x_181); -if (lean_obj_tag(x_181) == 0) -{ -lean_object* x_182; lean_object* x_183; -x_182 = lean_ctor_get(x_180, 0); -lean_inc(x_182); -x_183 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_182); -lean_dec(x_182); -if (lean_obj_tag(x_183) == 2) -{ -lean_object* x_184; lean_object* x_185; uint8_t x_186; -x_184 = lean_ctor_get(x_183, 1); -lean_inc(x_184); -lean_dec(x_183); -x_185 = l_Lean_Parser_Term_have___elambda__1___closed__6; -x_186 = lean_string_dec_eq(x_184, x_185); -lean_dec(x_184); -if (x_186 == 0) -{ -lean_object* x_187; lean_object* x_188; -x_187 = l_Lean_Parser_Term_have___elambda__1___closed__9; -lean_inc(x_80); -x_188 = l_Lean_Parser_ParserState_mkErrorsAt(x_180, x_187, x_80); -x_124 = x_188; -goto block_179; +lean_dec(x_84); +lean_dec(x_83); +lean_dec(x_1); +return x_85; } else { -x_124 = x_180; -goto block_179; -} -} -else -{ -lean_object* x_189; lean_object* x_190; -lean_dec(x_183); -x_189 = l_Lean_Parser_Term_have___elambda__1___closed__9; -lean_inc(x_80); -x_190 = l_Lean_Parser_ParserState_mkErrorsAt(x_180, x_189, x_80); -x_124 = x_190; -goto block_179; -} -} -else -{ -lean_object* x_191; lean_object* x_192; -lean_dec(x_181); -x_191 = l_Lean_Parser_Term_have___elambda__1___closed__9; -lean_inc(x_80); -x_192 = l_Lean_Parser_ParserState_mkErrorsAt(x_180, x_191, x_80); -x_124 = x_192; -goto block_179; -} -block_123: -{ -lean_object* x_90; -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; -x_91 = lean_ctor_get(x_89, 1); -lean_inc(x_91); -lean_inc(x_1); -x_92 = l_Lean_Parser_tokenFn(x_1, x_89); -x_93 = lean_ctor_get(x_92, 3); -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_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; +lean_inc(x_84); +x_90 = l_Lean_Parser_ParserState_restore(x_85, x_83, x_84); +lean_dec(x_83); +x_91 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_92 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_93 = l_Lean_Parser_checkRbpLtFn(x_91, x_92, x_1, x_90); +x_94 = lean_ctor_get(x_93, 3); lean_inc(x_94); -x_95 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_94); -lean_dec(x_94); -if (lean_obj_tag(x_95) == 2) +if (lean_obj_tag(x_94) == 0) { -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_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_132; lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_95 = lean_ctor_get(x_93, 0); +lean_inc(x_95); +x_96 = lean_array_get_size(x_95); lean_dec(x_95); -x_97 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -x_98 = lean_string_dec_eq(x_96, x_97); -lean_dec(x_96); -if (x_98 == 0) +x_161 = lean_ctor_get(x_93, 1); +lean_inc(x_161); +lean_inc(x_1); +x_162 = l_Lean_Parser_tokenFn(x_1, x_93); +x_163 = lean_ctor_get(x_162, 3); +lean_inc(x_163); +if (lean_obj_tag(x_163) == 0) { -lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; -lean_dec(x_1); -x_99 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_99, x_91); -x_101 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_88); -x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_83, x_80); -lean_dec(x_80); -return x_103; +lean_object* x_164; lean_object* x_165; +x_164 = lean_ctor_get(x_162, 0); +lean_inc(x_164); +x_165 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_164); +lean_dec(x_164); +if (lean_obj_tag(x_165) == 2) +{ +lean_object* x_166; lean_object* x_167; uint8_t x_168; +x_166 = lean_ctor_get(x_165, 1); +lean_inc(x_166); +lean_dec(x_165); +x_167 = l_Lean_Parser_Term_have___elambda__1___closed__6; +x_168 = lean_string_dec_eq(x_166, x_167); +lean_dec(x_166); +if (x_168 == 0) +{ +lean_object* x_169; lean_object* x_170; +x_169 = l_Lean_Parser_Term_have___elambda__1___closed__9; +x_170 = l_Lean_Parser_ParserState_mkErrorsAt(x_162, x_169, x_161); +x_132 = x_170; +goto block_160; } else { -lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; -lean_dec(x_91); -x_104 = l_Lean_Parser_termParser___closed__2; -x_105 = lean_unsigned_to_nat(0u); -x_106 = l_Lean_Parser_categoryParser___elambda__1(x_104, x_105, x_1, x_92); -x_107 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_108 = l_Lean_Parser_ParserState_mkNode(x_106, x_107, x_88); -x_109 = l_Lean_Parser_mergeOrElseErrors(x_108, x_83, x_80); -lean_dec(x_80); -return x_109; +lean_dec(x_161); +x_132 = x_162; +goto block_160; } } else { -lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; -lean_dec(x_95); -lean_dec(x_1); -x_110 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_110, x_91); -x_112 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_113 = l_Lean_Parser_ParserState_mkNode(x_111, x_112, x_88); -x_114 = l_Lean_Parser_mergeOrElseErrors(x_113, x_83, x_80); -lean_dec(x_80); -return x_114; +lean_object* x_171; lean_object* x_172; +lean_dec(x_165); +x_171 = l_Lean_Parser_Term_have___elambda__1___closed__9; +x_172 = l_Lean_Parser_ParserState_mkErrorsAt(x_162, x_171, x_161); +x_132 = x_172; +goto block_160; } } else { -lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; -lean_dec(x_93); +lean_object* x_173; lean_object* x_174; +lean_dec(x_163); +x_173 = l_Lean_Parser_Term_have___elambda__1___closed__9; +x_174 = l_Lean_Parser_ParserState_mkErrorsAt(x_162, x_173, x_161); +x_132 = x_174; +goto block_160; +} +block_131: +{ +lean_object* x_98; +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; +x_99 = lean_ctor_get(x_97, 1); +lean_inc(x_99); +lean_inc(x_1); +x_100 = l_Lean_Parser_tokenFn(x_1, x_97); +x_101 = lean_ctor_get(x_100, 3); +lean_inc(x_101); +if (lean_obj_tag(x_101) == 0) +{ +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_104; lean_object* x_105; uint8_t x_106; +x_104 = lean_ctor_get(x_103, 1); +lean_inc(x_104); +lean_dec(x_103); +x_105 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; +x_106 = lean_string_dec_eq(x_104, x_105); +lean_dec(x_104); +if (x_106 == 0) +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_dec(x_1); -x_115 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_116 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_115, x_91); -x_117 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_118 = l_Lean_Parser_ParserState_mkNode(x_116, x_117, x_88); -x_119 = l_Lean_Parser_mergeOrElseErrors(x_118, x_83, x_80); -lean_dec(x_80); -return x_119; +x_107 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_108 = l_Lean_Parser_ParserState_mkErrorsAt(x_100, x_107, x_99); +x_109 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_110 = l_Lean_Parser_ParserState_mkNode(x_108, x_109, x_96); +x_111 = l_Lean_Parser_mergeOrElseErrors(x_110, x_87, x_84); +lean_dec(x_84); +return x_111; +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +lean_dec(x_99); +x_112 = l_Lean_Parser_termParser___closed__2; +x_113 = lean_unsigned_to_nat(0u); +x_114 = l_Lean_Parser_categoryParser___elambda__1(x_112, x_113, x_1, x_100); +x_115 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_116 = l_Lean_Parser_ParserState_mkNode(x_114, x_115, x_96); +x_117 = l_Lean_Parser_mergeOrElseErrors(x_116, x_87, x_84); +lean_dec(x_84); +return x_117; } } else { -lean_object* x_120; lean_object* x_121; lean_object* x_122; -lean_dec(x_90); +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; +lean_dec(x_103); lean_dec(x_1); +x_118 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_119 = l_Lean_Parser_ParserState_mkErrorsAt(x_100, x_118, x_99); x_120 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_121 = l_Lean_Parser_ParserState_mkNode(x_89, x_120, x_88); -x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_83, x_80); -lean_dec(x_80); +x_121 = l_Lean_Parser_ParserState_mkNode(x_119, x_120, x_96); +x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_87, x_84); +lean_dec(x_84); return x_122; } } -block_179: +else { -lean_object* x_125; -x_125 = lean_ctor_get(x_124, 3); -lean_inc(x_125); -if (lean_obj_tag(x_125) == 0) +lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; +lean_dec(x_101); +lean_dec(x_1); +x_123 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_100, x_123, x_99); +x_125 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_126 = l_Lean_Parser_ParserState_mkNode(x_124, x_125, x_96); +x_127 = l_Lean_Parser_mergeOrElseErrors(x_126, x_87, x_84); +lean_dec(x_84); +return x_127; +} +} +else { -lean_object* x_126; lean_object* x_127; +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_98); +lean_dec(x_1); +x_128 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_129 = l_Lean_Parser_ParserState_mkNode(x_97, x_128, x_96); +x_130 = l_Lean_Parser_mergeOrElseErrors(x_129, x_87, x_84); +lean_dec(x_84); +return x_130; +} +} +block_160: +{ +lean_object* x_133; +x_133 = lean_ctor_get(x_132, 3); +lean_inc(x_133); +if (lean_obj_tag(x_133) == 0) +{ +lean_object* x_134; lean_object* x_135; lean_inc(x_1); -x_126 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_124); -x_127 = lean_ctor_get(x_126, 3); -lean_inc(x_127); -if (lean_obj_tag(x_127) == 0) +x_134 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_132); +x_135 = lean_ctor_get(x_134, 3); +lean_inc(x_135); +if (lean_obj_tag(x_135) == 0) { -lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; -x_128 = l_Lean_Parser_termParser___closed__2; -x_129 = lean_unsigned_to_nat(0u); +lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_136 = l_Lean_Parser_termParser___closed__2; +x_137 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_130 = l_Lean_Parser_categoryParser___elambda__1(x_128, x_129, x_1, x_126); -x_131 = lean_ctor_get(x_130, 3); -lean_inc(x_131); -if (lean_obj_tag(x_131) == 0) -{ -lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; -x_132 = lean_ctor_get(x_130, 0); -lean_inc(x_132); -x_133 = lean_array_get_size(x_132); -lean_dec(x_132); -x_134 = lean_ctor_get(x_130, 1); -lean_inc(x_134); -lean_inc(x_1); -x_135 = l_Lean_Parser_Term_haveAssign___elambda__1(x_1, x_130); -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_dec(x_134); -lean_dec(x_133); -x_137 = lean_ctor_get(x_135, 1); -lean_inc(x_137); -lean_inc(x_1); -x_138 = l_Lean_Parser_tokenFn(x_1, x_135); +x_138 = l_Lean_Parser_categoryParser___elambda__1(x_136, x_137, x_1, x_134); x_139 = lean_ctor_get(x_138, 3); lean_inc(x_139); if (lean_obj_tag(x_139) == 0) { -lean_object* x_140; lean_object* x_141; +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; x_140 = lean_ctor_get(x_138, 0); lean_inc(x_140); -x_141 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_140); +x_141 = lean_array_get_size(x_140); lean_dec(x_140); -if (lean_obj_tag(x_141) == 2) -{ -lean_object* x_142; lean_object* x_143; uint8_t x_144; -x_142 = lean_ctor_get(x_141, 1); +x_142 = lean_ctor_get(x_138, 1); lean_inc(x_142); -lean_dec(x_141); -x_143 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -x_144 = lean_string_dec_eq(x_142, x_143); -lean_dec(x_142); -if (x_144 == 0) +lean_inc(x_1); +x_143 = l_Lean_Parser_Term_haveAssign___elambda__1(x_1, x_138); +x_144 = lean_ctor_get(x_143, 3); +lean_inc(x_144); +if (lean_obj_tag(x_144) == 0) { -lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; -lean_dec(x_1); -x_145 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_146 = l_Lean_Parser_ParserState_mkErrorsAt(x_138, x_145, x_137); -x_147 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_148 = l_Lean_Parser_ParserState_mkNode(x_146, x_147, x_88); -x_149 = l_Lean_Parser_mergeOrElseErrors(x_148, x_83, x_80); -lean_dec(x_80); -return x_149; +lean_dec(x_142); +lean_dec(x_141); +x_97 = x_143; +goto block_131; } else { -lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; -lean_dec(x_137); -x_150 = l_Lean_Parser_categoryParser___elambda__1(x_128, x_129, x_1, x_138); +lean_object* x_145; lean_object* x_146; uint8_t x_147; +x_145 = lean_ctor_get(x_144, 0); +lean_inc(x_145); +lean_dec(x_144); +x_146 = lean_ctor_get(x_143, 1); +lean_inc(x_146); +x_147 = lean_nat_dec_eq(x_146, x_142); +lean_dec(x_146); +if (x_147 == 0) +{ +lean_dec(x_145); +lean_dec(x_142); +lean_dec(x_141); +x_97 = x_143; +goto block_131; +} +else +{ +lean_object* x_148; lean_object* x_149; lean_object* x_150; +lean_inc(x_142); +x_148 = l_Lean_Parser_ParserState_restore(x_143, x_141, x_142); +lean_dec(x_141); +lean_inc(x_1); +x_149 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_148); +x_150 = l_Lean_Parser_mergeOrElseErrors(x_149, x_145, x_142); +lean_dec(x_142); +x_97 = x_150; +goto block_131; +} +} +} +else +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; +lean_dec(x_139); +lean_dec(x_1); x_151 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_152 = l_Lean_Parser_ParserState_mkNode(x_150, x_151, x_88); -x_153 = l_Lean_Parser_mergeOrElseErrors(x_152, x_83, x_80); -lean_dec(x_80); +x_152 = l_Lean_Parser_ParserState_mkNode(x_138, x_151, x_96); +x_153 = l_Lean_Parser_mergeOrElseErrors(x_152, x_87, x_84); +lean_dec(x_84); return x_153; } } else { -lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; -lean_dec(x_141); +lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_135); lean_dec(x_1); -x_154 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_155 = l_Lean_Parser_ParserState_mkErrorsAt(x_138, x_154, x_137); -x_156 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_157 = l_Lean_Parser_ParserState_mkNode(x_155, x_156, x_88); -x_158 = l_Lean_Parser_mergeOrElseErrors(x_157, x_83, x_80); -lean_dec(x_80); -return x_158; +x_154 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_155 = l_Lean_Parser_ParserState_mkNode(x_134, x_154, x_96); +x_156 = l_Lean_Parser_mergeOrElseErrors(x_155, x_87, x_84); +lean_dec(x_84); +return x_156; } } else { -lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; -lean_dec(x_139); -lean_dec(x_1); -x_159 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_160 = l_Lean_Parser_ParserState_mkErrorsAt(x_138, x_159, x_137); -x_161 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_162 = l_Lean_Parser_ParserState_mkNode(x_160, x_161, x_88); -x_163 = l_Lean_Parser_mergeOrElseErrors(x_162, x_83, x_80); -lean_dec(x_80); -return x_163; -} -} -else -{ -lean_object* x_164; lean_object* x_165; uint8_t x_166; -x_164 = lean_ctor_get(x_136, 0); -lean_inc(x_164); -lean_dec(x_136); -x_165 = lean_ctor_get(x_135, 1); -lean_inc(x_165); -x_166 = lean_nat_dec_eq(x_165, x_134); -lean_dec(x_165); -if (x_166 == 0) -{ -lean_dec(x_164); -lean_dec(x_134); +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_dec(x_133); -x_89 = x_135; -goto block_123; -} -else -{ -lean_object* x_167; lean_object* x_168; lean_object* x_169; -lean_inc(x_134); -x_167 = l_Lean_Parser_ParserState_restore(x_135, x_133, x_134); -lean_dec(x_133); -lean_inc(x_1); -x_168 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_167); -x_169 = l_Lean_Parser_mergeOrElseErrors(x_168, x_164, x_134); -lean_dec(x_134); -x_89 = x_169; -goto block_123; -} -} -} -else -{ -lean_object* x_170; lean_object* x_171; lean_object* x_172; -lean_dec(x_131); lean_dec(x_1); -x_170 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_171 = l_Lean_Parser_ParserState_mkNode(x_130, x_170, x_88); -x_172 = l_Lean_Parser_mergeOrElseErrors(x_171, x_83, x_80); -lean_dec(x_80); -return x_172; +x_157 = l_Lean_Parser_Term_have___elambda__1___closed__2; +x_158 = l_Lean_Parser_ParserState_mkNode(x_132, x_157, x_96); +x_159 = l_Lean_Parser_mergeOrElseErrors(x_158, x_87, x_84); +lean_dec(x_84); +return x_159; +} } } else { -lean_object* x_173; lean_object* x_174; lean_object* x_175; -lean_dec(x_127); +lean_object* x_175; +lean_dec(x_94); lean_dec(x_1); -x_173 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_174 = l_Lean_Parser_ParserState_mkNode(x_126, x_173, x_88); -x_175 = l_Lean_Parser_mergeOrElseErrors(x_174, x_83, x_80); -lean_dec(x_80); +x_175 = l_Lean_Parser_mergeOrElseErrors(x_93, x_87, x_84); +lean_dec(x_84); return x_175; } } -else -{ -lean_object* x_176; lean_object* x_177; lean_object* x_178; -lean_dec(x_125); -lean_dec(x_1); -x_176 = l_Lean_Parser_Term_have___elambda__1___closed__2; -x_177 = l_Lean_Parser_ParserState_mkNode(x_124, x_176, x_88); -x_178 = l_Lean_Parser_mergeOrElseErrors(x_177, x_83, x_80); -lean_dec(x_80); -return x_178; -} -} -} } } } @@ -14056,11 +14694,10 @@ return x_178; lean_object* _init_l_Lean_Parser_Term_have___closed__1() { _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_have___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_have___closed__2() { @@ -14081,7 +14718,7 @@ lean_object* _init_l_Lean_Parser_Term_have___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Tactic_seq___closed__2; @@ -14103,7 +14740,7 @@ lean_object* _init_l_Lean_Parser_Term_have___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_have___closed__4; @@ -14146,16 +14783,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_have___closed__9() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_have___closed__8; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_have___closed__10() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_have___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_have___closed__8; +x_3 = l_Lean_Parser_Term_have___closed__9; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_have___closed__10() { +lean_object* _init_l_Lean_Parser_Term_have___closed__11() { _start: { lean_object* x_1; @@ -14163,12 +14810,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_have___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_have___closed__11() { +lean_object* _init_l_Lean_Parser_Term_have___closed__12() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_have___closed__9; -x_2 = l_Lean_Parser_Term_have___closed__10; +x_1 = l_Lean_Parser_Term_have___closed__10; +x_2 = l_Lean_Parser_Term_have___closed__11; x_3 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_3, 0, x_1); lean_ctor_set(x_3, 1, x_2); @@ -14179,7 +14826,7 @@ lean_object* _init_l_Lean_Parser_Term_have() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_have___closed__11; +x_1 = l_Lean_Parser_Term_have___closed__12; return x_1; } } @@ -14295,463 +14942,496 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_50; lean_object* x_51; lean_object* x_52; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_50 = lean_ctor_get(x_2, 1); -lean_inc(x_50); -lean_inc(x_1); -x_51 = l_Lean_Parser_tokenFn(x_1, x_2); -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_suffices___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_suffices___elambda__1___closed__9; -x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_58, x_50); -x_8 = x_59; -goto block_49; -} -else -{ -lean_dec(x_50); -x_8 = x_51; -goto block_49; -} -} -else -{ -lean_object* x_60; lean_object* x_61; -lean_dec(x_54); -x_60 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; -x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_60, x_50); -x_8 = x_61; -goto block_49; -} -} -else -{ -lean_object* x_62; lean_object* x_63; -lean_dec(x_52); -x_62 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_62, x_50); -x_8 = x_63; -goto block_49; -} -block_49: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_54; lean_object* x_55; lean_object* x_56; +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_54 = lean_ctor_get(x_8, 1); +lean_inc(x_54); lean_inc(x_1); -x_10 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_8); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 0) +x_55 = l_Lean_Parser_tokenFn(x_1, x_8); +x_56 = lean_ctor_get(x_55, 3); +lean_inc(x_56); +if (lean_obj_tag(x_56) == 0) { -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; -x_12 = l_Lean_Parser_termParser___closed__2; -x_13 = lean_unsigned_to_nat(0u); +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_suffices___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_suffices___elambda__1___closed__9; +x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_54); +x_12 = x_63; +goto block_53; +} +else +{ +lean_dec(x_54); +x_12 = x_55; +goto block_53; +} +} +else +{ +lean_object* x_64; lean_object* x_65; +lean_dec(x_58); +x_64 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; +x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_54); +x_12 = x_65; +goto block_53; +} +} +else +{ +lean_object* x_66; lean_object* x_67; +lean_dec(x_56); +x_66 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; +x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_54); +x_12 = x_67; +goto block_53; +} +block_53: +{ +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_inc(x_1); -x_14 = l_Lean_Parser_categoryParser___elambda__1(x_12, x_13, x_1, x_10); +x_14 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_12); x_15 = lean_ctor_get(x_14, 3); lean_inc(x_15); if (lean_obj_tag(x_15) == 0) { -lean_object* x_16; lean_object* x_17; +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_16 = l_Lean_Parser_termParser___closed__2; +x_17 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_16 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_14); -x_17 = lean_ctor_get(x_16, 3); -lean_inc(x_17); -if (lean_obj_tag(x_17) == 0) +x_18 = l_Lean_Parser_categoryParser___elambda__1(x_16, x_17, x_1, x_14); +x_19 = lean_ctor_get(x_18, 3); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 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_object* x_20; lean_object* x_21; 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; -x_21 = lean_ctor_get(x_19, 0); +x_20 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_18); +x_21 = lean_ctor_get(x_20, 3); lean_inc(x_21); -x_22 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_21); -lean_dec(x_21); -if (lean_obj_tag(x_22) == 2) +if (lean_obj_tag(x_21) == 0) { -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_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -x_25 = lean_string_dec_eq(x_23, x_24); -lean_dec(x_23); -if (x_25 == 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); +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_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +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_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); +lean_dec(x_26); +x_28 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; +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_dec(x_1); -x_26 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); -x_28 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); -return x_29; +x_30 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); +x_32 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); +return x_33; } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; -lean_dec(x_18); -x_30 = l_Lean_Parser_categoryParser___elambda__1(x_12, x_13, x_1, x_19); -x_31 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, 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_34; lean_object* x_35; lean_object* x_36; lean_dec(x_22); -lean_dec(x_1); -x_33 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_33, x_18); +x_34 = l_Lean_Parser_categoryParser___elambda__1(x_16, x_17, x_1, x_23); x_35 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_7); +x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_11); return x_36; } } else { lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; -lean_dec(x_20); +lean_dec(x_26); lean_dec(x_1); x_37 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_37, x_18); +x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_37, x_22); x_39 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_7); +x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_11); return x_40; } } else { -lean_object* x_41; lean_object* x_42; -lean_dec(x_17); -lean_dec(x_1); -x_41 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_42 = l_Lean_Parser_ParserState_mkNode(x_16, x_41, x_7); -return x_42; -} -} -else -{ -lean_object* x_43; lean_object* x_44; -lean_dec(x_15); +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_24); lean_dec(x_1); +x_41 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_41, x_22); x_43 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_44 = l_Lean_Parser_ParserState_mkNode(x_14, x_43, x_7); +x_44 = l_Lean_Parser_ParserState_mkNode(x_42, x_43, x_11); return x_44; } } else { lean_object* x_45; lean_object* x_46; -lean_dec(x_11); +lean_dec(x_21); lean_dec(x_1); x_45 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_46 = l_Lean_Parser_ParserState_mkNode(x_10, x_45, x_7); +x_46 = l_Lean_Parser_ParserState_mkNode(x_20, x_45, x_11); return x_46; } } else { lean_object* x_47; lean_object* x_48; -lean_dec(x_9); +lean_dec(x_19); lean_dec(x_1); x_47 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_48 = l_Lean_Parser_ParserState_mkNode(x_8, x_47, x_7); +x_48 = l_Lean_Parser_ParserState_mkNode(x_18, x_47, x_11); return x_48; } } +else +{ +lean_object* x_49; lean_object* x_50; +lean_dec(x_15); +lean_dec(x_1); +x_49 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_50 = l_Lean_Parser_ParserState_mkNode(x_14, x_49, x_11); +return x_50; +} } else { -lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; -x_64 = lean_ctor_get(x_2, 0); -lean_inc(x_64); -x_65 = lean_array_get_size(x_64); -lean_dec(x_64); -x_66 = lean_ctor_get(x_2, 1); -lean_inc(x_66); -lean_inc(x_1); -x_67 = lean_apply_2(x_4, x_1, x_2); -x_68 = lean_ctor_get(x_67, 3); +lean_object* x_51; lean_object* x_52; +lean_dec(x_13); +lean_dec(x_1); +x_51 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_52 = l_Lean_Parser_ParserState_mkNode(x_12, x_51, x_11); +return x_52; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_68); -if (lean_obj_tag(x_68) == 0) -{ -lean_dec(x_66); -lean_dec(x_65); -lean_dec(x_1); -return x_67; -} -else -{ -lean_object* x_69; lean_object* x_70; uint8_t x_71; -x_69 = lean_ctor_get(x_68, 0); -lean_inc(x_69); +x_69 = lean_array_get_size(x_68); lean_dec(x_68); -x_70 = lean_ctor_get(x_67, 1); +x_70 = lean_ctor_get(x_2, 1); lean_inc(x_70); -x_71 = lean_nat_dec_eq(x_70, x_66); -lean_dec(x_70); -if (x_71 == 0) +lean_inc(x_1); +x_71 = lean_apply_2(x_4, x_1, x_2); +x_72 = lean_ctor_get(x_71, 3); +lean_inc(x_72); +if (lean_obj_tag(x_72) == 0) { +lean_dec(x_70); lean_dec(x_69); -lean_dec(x_66); -lean_dec(x_65); lean_dec(x_1); -return x_67; +return x_71; } else { -lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_125; lean_object* x_126; -lean_inc(x_66); -x_72 = l_Lean_Parser_ParserState_restore(x_67, x_65, x_66); -lean_dec(x_65); +lean_object* x_73; lean_object* x_74; uint8_t x_75; x_73 = lean_ctor_get(x_72, 0); lean_inc(x_73); -x_74 = lean_array_get_size(x_73); +lean_dec(x_72); +x_74 = lean_ctor_get(x_71, 1); +lean_inc(x_74); +x_75 = lean_nat_dec_eq(x_74, x_70); +lean_dec(x_74); +if (x_75 == 0) +{ lean_dec(x_73); +lean_dec(x_70); +lean_dec(x_69); +lean_dec(x_1); +return x_71; +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; +lean_inc(x_70); +x_76 = l_Lean_Parser_ParserState_restore(x_71, x_69, x_70); +lean_dec(x_69); +x_77 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_78 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_79 = l_Lean_Parser_checkRbpLtFn(x_77, x_78, x_1, 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; lean_object* x_83; lean_object* x_133; lean_object* x_134; lean_object* x_135; +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_133 = lean_ctor_get(x_79, 1); +lean_inc(x_133); lean_inc(x_1); -x_125 = l_Lean_Parser_tokenFn(x_1, x_72); -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 = lean_ctor_get(x_125, 0); -lean_inc(x_127); -x_128 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_127); -lean_dec(x_127); -if (lean_obj_tag(x_128) == 2) -{ -lean_object* x_129; lean_object* x_130; uint8_t x_131; -x_129 = lean_ctor_get(x_128, 1); -lean_inc(x_129); -lean_dec(x_128); -x_130 = l_Lean_Parser_Term_suffices___elambda__1___closed__6; -x_131 = lean_string_dec_eq(x_129, x_130); -lean_dec(x_129); -if (x_131 == 0) -{ -lean_object* x_132; lean_object* x_133; -x_132 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; -lean_inc(x_66); -x_133 = l_Lean_Parser_ParserState_mkErrorsAt(x_125, x_132, x_66); -x_75 = x_133; -goto block_124; -} -else -{ -x_75 = x_125; -goto block_124; -} -} -else -{ -lean_object* x_134; lean_object* x_135; -lean_dec(x_128); -x_134 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; -lean_inc(x_66); -x_135 = l_Lean_Parser_ParserState_mkErrorsAt(x_125, x_134, x_66); -x_75 = x_135; -goto block_124; -} -} -else +x_134 = l_Lean_Parser_tokenFn(x_1, x_79); +x_135 = lean_ctor_get(x_134, 3); +lean_inc(x_135); +if (lean_obj_tag(x_135) == 0) { lean_object* x_136; lean_object* x_137; -lean_dec(x_126); -x_136 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; -lean_inc(x_66); -x_137 = l_Lean_Parser_ParserState_mkErrorsAt(x_125, x_136, x_66); -x_75 = x_137; -goto block_124; +x_136 = lean_ctor_get(x_134, 0); +lean_inc(x_136); +x_137 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_136); +lean_dec(x_136); +if (lean_obj_tag(x_137) == 2) +{ +lean_object* x_138; lean_object* x_139; uint8_t x_140; +x_138 = lean_ctor_get(x_137, 1); +lean_inc(x_138); +lean_dec(x_137); +x_139 = l_Lean_Parser_Term_suffices___elambda__1___closed__6; +x_140 = lean_string_dec_eq(x_138, x_139); +lean_dec(x_138); +if (x_140 == 0) +{ +lean_object* x_141; lean_object* x_142; +x_141 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; +x_142 = l_Lean_Parser_ParserState_mkErrorsAt(x_134, x_141, x_133); +x_83 = x_142; +goto block_132; } -block_124: +else { -lean_object* x_76; -x_76 = lean_ctor_get(x_75, 3); -lean_inc(x_76); -if (lean_obj_tag(x_76) == 0) +lean_dec(x_133); +x_83 = x_134; +goto block_132; +} +} +else { -lean_object* x_77; lean_object* x_78; -lean_inc(x_1); -x_77 = l_Lean_Parser_Term_optIdent___elambda__1(x_1, x_75); -x_78 = lean_ctor_get(x_77, 3); -lean_inc(x_78); -if (lean_obj_tag(x_78) == 0) +lean_object* x_143; lean_object* x_144; +lean_dec(x_137); +x_143 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; +x_144 = l_Lean_Parser_ParserState_mkErrorsAt(x_134, x_143, x_133); +x_83 = x_144; +goto block_132; +} +} +else { -lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_79 = l_Lean_Parser_termParser___closed__2; -x_80 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_81 = l_Lean_Parser_categoryParser___elambda__1(x_79, x_80, x_1, x_77); -x_82 = lean_ctor_get(x_81, 3); -lean_inc(x_82); -if (lean_obj_tag(x_82) == 0) +lean_object* x_145; lean_object* x_146; +lean_dec(x_135); +x_145 = l_Lean_Parser_Term_suffices___elambda__1___closed__9; +x_146 = l_Lean_Parser_ParserState_mkErrorsAt(x_134, x_145, x_133); +x_83 = x_146; +goto block_132; +} +block_132: { -lean_object* x_83; lean_object* x_84; -lean_inc(x_1); -x_83 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_81); +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_85; lean_object* x_86; lean_object* x_87; -x_85 = lean_ctor_get(x_83, 1); -lean_inc(x_85); +lean_object* x_85; lean_object* x_86; 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) +x_85 = l_Lean_Parser_Term_optIdent___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) { -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_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_87 = l_Lean_Parser_termParser___closed__2; +x_88 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_89 = l_Lean_Parser_categoryParser___elambda__1(x_87, x_88, x_1, x_85); +x_90 = lean_ctor_get(x_89, 3); lean_inc(x_90); -lean_dec(x_89); -x_91 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -x_92 = lean_string_dec_eq(x_90, x_91); -lean_dec(x_90); -if (x_92 == 0) +if (lean_obj_tag(x_90) == 0) { -lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +lean_object* x_91; lean_object* x_92; +lean_inc(x_1); +x_91 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_89); +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_object* x_95; +x_93 = lean_ctor_get(x_91, 1); +lean_inc(x_93); +lean_inc(x_1); +x_94 = l_Lean_Parser_tokenFn(x_1, x_91); +x_95 = lean_ctor_get(x_94, 3); +lean_inc(x_95); +if (lean_obj_tag(x_95) == 0) +{ +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_checkStackTopFn___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___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; +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; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_dec(x_1); -x_93 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_94 = l_Lean_Parser_ParserState_mkErrorsAt(x_86, x_93, x_85); -x_95 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_74); -x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_69, x_66); -lean_dec(x_66); -return x_97; +x_101 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_102 = l_Lean_Parser_ParserState_mkErrorsAt(x_94, x_101, x_93); +x_103 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_104 = l_Lean_Parser_ParserState_mkNode(x_102, x_103, x_82); +x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_73, x_70); +lean_dec(x_70); +return x_105; } else { -lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; -lean_dec(x_85); -x_98 = l_Lean_Parser_categoryParser___elambda__1(x_79, x_80, x_1, x_86); -x_99 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_74); -x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_69, x_66); -lean_dec(x_66); -return x_101; +lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; +lean_dec(x_93); +x_106 = l_Lean_Parser_categoryParser___elambda__1(x_87, x_88, x_1, x_94); +x_107 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_108 = l_Lean_Parser_ParserState_mkNode(x_106, x_107, x_82); +x_109 = l_Lean_Parser_mergeOrElseErrors(x_108, x_73, x_70); +lean_dec(x_70); +return x_109; } } else { -lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; -lean_dec(x_89); -lean_dec(x_1); -x_102 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_103 = l_Lean_Parser_ParserState_mkErrorsAt(x_86, x_102, x_85); -x_104 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_105 = l_Lean_Parser_ParserState_mkNode(x_103, x_104, x_74); -x_106 = l_Lean_Parser_mergeOrElseErrors(x_105, x_69, x_66); -lean_dec(x_66); -return x_106; -} -} -else -{ -lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; -lean_dec(x_87); -lean_dec(x_1); -x_107 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_108 = l_Lean_Parser_ParserState_mkErrorsAt(x_86, x_107, x_85); -x_109 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_110 = l_Lean_Parser_ParserState_mkNode(x_108, x_109, x_74); -x_111 = l_Lean_Parser_mergeOrElseErrors(x_110, x_69, x_66); -lean_dec(x_66); -return x_111; -} -} -else -{ -lean_object* x_112; lean_object* x_113; lean_object* x_114; -lean_dec(x_84); +lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_dec(x_97); lean_dec(x_1); +x_110 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_94, x_110, x_93); x_112 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_113 = l_Lean_Parser_ParserState_mkNode(x_83, x_112, x_74); -x_114 = l_Lean_Parser_mergeOrElseErrors(x_113, x_69, x_66); -lean_dec(x_66); +x_113 = l_Lean_Parser_ParserState_mkNode(x_111, x_112, x_82); +x_114 = l_Lean_Parser_mergeOrElseErrors(x_113, x_73, x_70); +lean_dec(x_70); return x_114; } } else { -lean_object* x_115; lean_object* x_116; lean_object* x_117; -lean_dec(x_82); +lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; +lean_dec(x_95); lean_dec(x_1); -x_115 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_116 = l_Lean_Parser_ParserState_mkNode(x_81, x_115, x_74); -x_117 = l_Lean_Parser_mergeOrElseErrors(x_116, x_69, x_66); -lean_dec(x_66); -return x_117; +x_115 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_116 = l_Lean_Parser_ParserState_mkErrorsAt(x_94, x_115, x_93); +x_117 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_118 = l_Lean_Parser_ParserState_mkNode(x_116, x_117, x_82); +x_119 = l_Lean_Parser_mergeOrElseErrors(x_118, x_73, x_70); +lean_dec(x_70); +return x_119; } } else { -lean_object* x_118; lean_object* x_119; lean_object* x_120; -lean_dec(x_78); +lean_object* x_120; lean_object* x_121; lean_object* x_122; +lean_dec(x_92); lean_dec(x_1); -x_118 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_119 = l_Lean_Parser_ParserState_mkNode(x_77, x_118, x_74); -x_120 = l_Lean_Parser_mergeOrElseErrors(x_119, x_69, x_66); -lean_dec(x_66); -return x_120; +x_120 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_121 = l_Lean_Parser_ParserState_mkNode(x_91, x_120, x_82); +x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_73, x_70); +lean_dec(x_70); +return x_122; } } else { -lean_object* x_121; lean_object* x_122; lean_object* x_123; -lean_dec(x_76); +lean_object* x_123; lean_object* x_124; lean_object* x_125; +lean_dec(x_90); lean_dec(x_1); -x_121 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; -x_122 = l_Lean_Parser_ParserState_mkNode(x_75, x_121, x_74); -x_123 = l_Lean_Parser_mergeOrElseErrors(x_122, x_69, x_66); -lean_dec(x_66); -return x_123; +x_123 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_124 = l_Lean_Parser_ParserState_mkNode(x_89, x_123, x_82); +x_125 = l_Lean_Parser_mergeOrElseErrors(x_124, x_73, x_70); +lean_dec(x_70); +return x_125; } } +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +lean_dec(x_86); +lean_dec(x_1); +x_126 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_127 = l_Lean_Parser_ParserState_mkNode(x_85, x_126, x_82); +x_128 = l_Lean_Parser_mergeOrElseErrors(x_127, x_73, x_70); +lean_dec(x_70); +return x_128; +} +} +else +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; +lean_dec(x_84); +lean_dec(x_1); +x_129 = l_Lean_Parser_Term_suffices___elambda__1___closed__2; +x_130 = l_Lean_Parser_ParserState_mkNode(x_83, x_129, x_82); +x_131 = l_Lean_Parser_mergeOrElseErrors(x_130, x_73, x_70); +lean_dec(x_70); +return x_131; +} +} +} +else +{ +lean_object* x_147; +lean_dec(x_80); +lean_dec(x_1); +x_147 = l_Lean_Parser_mergeOrElseErrors(x_79, x_73, x_70); +lean_dec(x_70); +return x_147; +} } } } @@ -14760,11 +15440,10 @@ return x_123; lean_object* _init_l_Lean_Parser_Term_suffices___closed__1() { _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_suffices___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_suffices___closed__2() { @@ -14783,7 +15462,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_suffices___closed__2; @@ -14826,16 +15505,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_suffices___closed__7() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_suffices___closed__6; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_suffices___closed__8() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_suffices___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_suffices___closed__6; +x_3 = l_Lean_Parser_Term_suffices___closed__7; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_suffices___closed__8() { +lean_object* _init_l_Lean_Parser_Term_suffices___closed__9() { _start: { lean_object* x_1; @@ -14843,12 +15532,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_suffices___elambda__1), 2, 0 return x_1; } } -lean_object* _init_l_Lean_Parser_Term_suffices___closed__9() { +lean_object* _init_l_Lean_Parser_Term_suffices___closed__10() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_suffices___closed__7; -x_2 = l_Lean_Parser_Term_suffices___closed__8; +x_1 = l_Lean_Parser_Term_suffices___closed__8; +x_2 = l_Lean_Parser_Term_suffices___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); @@ -14859,7 +15548,7 @@ lean_object* _init_l_Lean_Parser_Term_suffices() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_suffices___closed__9; +x_1 = l_Lean_Parser_Term_suffices___closed__10; return x_1; } } @@ -14975,262 +15664,295 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_22; lean_object* x_23; lean_object* x_24; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_22 = lean_ctor_get(x_2, 1); -lean_inc(x_22); -lean_inc(x_1); -x_23 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_25 = lean_ctor_get(x_23, 0); -lean_inc(x_25); -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); -lean_dec(x_26); -x_28 = l_Lean_Parser_Term_show___elambda__1___closed__6; -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; -x_30 = l_Lean_Parser_Term_show___elambda__1___closed__9; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); -x_8 = x_31; -goto block_21; -} -else -{ -lean_dec(x_22); -x_8 = x_23; -goto block_21; -} -} -else -{ -lean_object* x_32; lean_object* x_33; -lean_dec(x_26); -x_32 = l_Lean_Parser_Term_show___elambda__1___closed__9; -x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22); -x_8 = x_33; -goto block_21; -} -} -else -{ -lean_object* x_34; lean_object* x_35; -lean_dec(x_24); -x_34 = l_Lean_Parser_Term_show___elambda__1___closed__9; -x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22); -x_8 = x_35; -goto block_21; -} -block_21: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(0u); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_26; lean_object* x_27; lean_object* x_28; +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_26 = lean_ctor_get(x_8, 1); +lean_inc(x_26); lean_inc(x_1); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); +x_27 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +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); +lean_dec(x_30); +x_32 = l_Lean_Parser_Term_show___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_show___elambda__1___closed__9; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_34, x_26); +x_12 = x_35; +goto block_25; +} +else +{ +lean_dec(x_26); +x_12 = x_27; +goto block_25; +} +} +else +{ +lean_object* x_36; lean_object* x_37; +lean_dec(x_30); +x_36 = l_Lean_Parser_Term_show___elambda__1___closed__9; +x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_36, x_26); +x_12 = x_37; +goto block_25; +} +} +else +{ +lean_object* x_38; lean_object* x_39; +lean_dec(x_28); +x_38 = l_Lean_Parser_Term_show___elambda__1___closed__9; +x_39 = l_Lean_Parser_ParserState_mkErrorsAt(x_27, x_38, x_26); +x_12 = x_39; +goto block_25; +} +block_25: +{ +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; -x_14 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_12); -x_15 = l_Lean_Parser_Term_show___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_14, x_15, x_7); -return x_16; -} -else +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = lean_ctor_get(x_16, 3); +lean_inc(x_17); +if (lean_obj_tag(x_17) == 0) { -lean_object* x_17; lean_object* x_18; -lean_dec(x_13); -lean_dec(x_1); -x_17 = l_Lean_Parser_Term_show___elambda__1___closed__2; -x_18 = l_Lean_Parser_ParserState_mkNode(x_12, x_17, x_7); -return x_18; -} -} -else -{ -lean_object* x_19; lean_object* x_20; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_16); x_19 = l_Lean_Parser_Term_show___elambda__1___closed__2; -x_20 = l_Lean_Parser_ParserState_mkNode(x_8, x_19, x_7); +x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_11); return x_20; } +else +{ +lean_object* x_21; lean_object* x_22; +lean_dec(x_17); +lean_dec(x_1); +x_21 = l_Lean_Parser_Term_show___elambda__1___closed__2; +x_22 = l_Lean_Parser_ParserState_mkNode(x_16, x_21, x_11); +return x_22; } } else { -lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; -x_36 = lean_ctor_get(x_2, 0); -lean_inc(x_36); -x_37 = lean_array_get_size(x_36); -lean_dec(x_36); -x_38 = lean_ctor_get(x_2, 1); -lean_inc(x_38); -lean_inc(x_1); -x_39 = lean_apply_2(x_4, x_1, x_2); -x_40 = lean_ctor_get(x_39, 3); +lean_object* x_23; lean_object* x_24; +lean_dec(x_13); +lean_dec(x_1); +x_23 = l_Lean_Parser_Term_show___elambda__1___closed__2; +x_24 = l_Lean_Parser_ParserState_mkNode(x_12, x_23, x_11); +return x_24; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_40 = lean_ctor_get(x_2, 0); lean_inc(x_40); -if (lean_obj_tag(x_40) == 0) -{ -lean_dec(x_38); -lean_dec(x_37); -lean_dec(x_1); -return x_39; -} -else -{ -lean_object* x_41; lean_object* x_42; uint8_t x_43; -x_41 = lean_ctor_get(x_40, 0); -lean_inc(x_41); +x_41 = lean_array_get_size(x_40); lean_dec(x_40); -x_42 = lean_ctor_get(x_39, 1); +x_42 = lean_ctor_get(x_2, 1); lean_inc(x_42); -x_43 = lean_nat_dec_eq(x_42, x_38); -lean_dec(x_42); -if (x_43 == 0) +lean_inc(x_1); +x_43 = lean_apply_2(x_4, x_1, x_2); +x_44 = lean_ctor_get(x_43, 3); +lean_inc(x_44); +if (lean_obj_tag(x_44) == 0) { +lean_dec(x_42); lean_dec(x_41); -lean_dec(x_38); -lean_dec(x_37); lean_dec(x_1); -return x_39; +return x_43; } else { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_64; lean_object* x_65; -lean_inc(x_38); -x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); -lean_dec(x_37); +lean_object* x_45; lean_object* x_46; uint8_t x_47; x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -x_46 = lean_array_get_size(x_45); +lean_dec(x_44); +x_46 = lean_ctor_get(x_43, 1); +lean_inc(x_46); +x_47 = lean_nat_dec_eq(x_46, x_42); +lean_dec(x_46); +if (x_47 == 0) +{ lean_dec(x_45); -lean_inc(x_1); -x_64 = l_Lean_Parser_tokenFn(x_1, x_44); -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; -x_66 = lean_ctor_get(x_64, 0); -lean_inc(x_66); -x_67 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_66); -lean_dec(x_66); -if (lean_obj_tag(x_67) == 2) -{ -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_show___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_71; lean_object* x_72; -x_71 = l_Lean_Parser_Term_show___elambda__1___closed__9; -lean_inc(x_38); -x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_38); -x_47 = x_72; -goto block_63; +lean_dec(x_42); +lean_dec(x_41); +lean_dec(x_1); +return x_43; } else { -x_47 = x_64; -goto block_63; -} -} -else -{ -lean_object* x_73; lean_object* x_74; -lean_dec(x_67); -x_73 = l_Lean_Parser_Term_show___elambda__1___closed__9; -lean_inc(x_38); -x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_38); -x_47 = x_74; -goto block_63; -} -} -else -{ -lean_object* x_75; lean_object* x_76; -lean_dec(x_65); -x_75 = l_Lean_Parser_Term_show___elambda__1___closed__9; -lean_inc(x_38); -x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_38); -x_47 = x_76; -goto block_63; -} -block_63: -{ -lean_object* x_48; -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_termParser___closed__2; -x_50 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_51 = l_Lean_Parser_categoryParser___elambda__1(x_49, x_50, x_1, 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_42); +x_48 = l_Lean_Parser_ParserState_restore(x_43, x_41, x_42); +lean_dec(x_41); +x_49 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_50 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_51 = l_Lean_Parser_checkRbpLtFn(x_49, x_50, 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; -x_53 = l_Lean_Parser_Term_fromTerm___elambda__1(x_1, x_51); -x_54 = l_Lean_Parser_Term_show___elambda__1___closed__2; -x_55 = l_Lean_Parser_ParserState_mkNode(x_53, x_54, x_46); -x_56 = l_Lean_Parser_mergeOrElseErrors(x_55, x_41, x_38); -lean_dec(x_38); -return x_56; +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_72; lean_object* x_73; lean_object* x_74; +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_72 = lean_ctor_get(x_51, 1); +lean_inc(x_72); +lean_inc(x_1); +x_73 = l_Lean_Parser_tokenFn(x_1, x_51); +x_74 = lean_ctor_get(x_73, 3); +lean_inc(x_74); +if (lean_obj_tag(x_74) == 0) +{ +lean_object* x_75; lean_object* x_76; +x_75 = lean_ctor_get(x_73, 0); +lean_inc(x_75); +x_76 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_75); +lean_dec(x_75); +if (lean_obj_tag(x_76) == 2) +{ +lean_object* x_77; lean_object* x_78; uint8_t x_79; +x_77 = lean_ctor_get(x_76, 1); +lean_inc(x_77); +lean_dec(x_76); +x_78 = l_Lean_Parser_Term_show___elambda__1___closed__6; +x_79 = lean_string_dec_eq(x_77, x_78); +lean_dec(x_77); +if (x_79 == 0) +{ +lean_object* x_80; lean_object* x_81; +x_80 = l_Lean_Parser_Term_show___elambda__1___closed__9; +x_81 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_80, x_72); +x_55 = x_81; +goto block_71; } else { -lean_object* x_57; lean_object* x_58; lean_object* x_59; +lean_dec(x_72); +x_55 = x_73; +goto block_71; +} +} +else +{ +lean_object* x_82; lean_object* x_83; +lean_dec(x_76); +x_82 = l_Lean_Parser_Term_show___elambda__1___closed__9; +x_83 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_82, x_72); +x_55 = x_83; +goto block_71; +} +} +else +{ +lean_object* x_84; lean_object* x_85; +lean_dec(x_74); +x_84 = l_Lean_Parser_Term_show___elambda__1___closed__9; +x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_84, x_72); +x_55 = x_85; +goto block_71; +} +block_71: +{ +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_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_57 = l_Lean_Parser_termParser___closed__2; +x_58 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_59 = l_Lean_Parser_categoryParser___elambda__1(x_57, x_58, x_1, x_55); +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_Term_fromTerm___elambda__1(x_1, x_59); +x_62 = l_Lean_Parser_Term_show___elambda__1___closed__2; +x_63 = l_Lean_Parser_ParserState_mkNode(x_61, x_62, x_54); +x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_45, x_42); +lean_dec(x_42); +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_Term_show___elambda__1___closed__2; +x_66 = l_Lean_Parser_ParserState_mkNode(x_59, x_65, x_54); +x_67 = l_Lean_Parser_mergeOrElseErrors(x_66, x_45, x_42); +lean_dec(x_42); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_dec(x_56); +lean_dec(x_1); +x_68 = l_Lean_Parser_Term_show___elambda__1___closed__2; +x_69 = l_Lean_Parser_ParserState_mkNode(x_55, x_68, x_54); +x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_45, x_42); +lean_dec(x_42); +return x_70; +} +} +} +else +{ +lean_object* x_86; lean_dec(x_52); lean_dec(x_1); -x_57 = l_Lean_Parser_Term_show___elambda__1___closed__2; -x_58 = l_Lean_Parser_ParserState_mkNode(x_51, x_57, x_46); -x_59 = l_Lean_Parser_mergeOrElseErrors(x_58, x_41, x_38); -lean_dec(x_38); -return x_59; -} -} -else -{ -lean_object* x_60; lean_object* x_61; lean_object* x_62; -lean_dec(x_48); -lean_dec(x_1); -x_60 = l_Lean_Parser_Term_show___elambda__1___closed__2; -x_61 = l_Lean_Parser_ParserState_mkNode(x_47, x_60, x_46); -x_62 = l_Lean_Parser_mergeOrElseErrors(x_61, x_41, x_38); -lean_dec(x_38); -return x_62; -} +x_86 = l_Lean_Parser_mergeOrElseErrors(x_51, x_45, x_42); +lean_dec(x_42); +return x_86; } } } @@ -15240,18 +15962,17 @@ return x_62; lean_object* _init_l_Lean_Parser_Term_show___closed__1() { _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_show___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_fromTerm; @@ -15284,16 +16005,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_show___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_show___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_show___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_show___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_show___closed__4; +x_3 = l_Lean_Parser_Term_show___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_show___closed__6() { +lean_object* _init_l_Lean_Parser_Term_show___closed__7() { _start: { lean_object* x_1; @@ -15301,12 +16032,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_show___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_show___closed__7() { +lean_object* _init_l_Lean_Parser_Term_show___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_show___closed__5; -x_2 = l_Lean_Parser_Term_show___closed__6; +x_1 = l_Lean_Parser_Term_show___closed__6; +x_2 = l_Lean_Parser_Term_show___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); @@ -15317,7 +16048,7 @@ lean_object* _init_l_Lean_Parser_Term_show() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_show___closed__7; +x_1 = l_Lean_Parser_Term_show___closed__8; return x_1; } } @@ -15849,28 +16580,26 @@ return x_103; lean_object* _init_l_Lean_Parser_Term_structInstArrayRef___closed__1() { _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_structInstArrayRef___elambda__1___closed__5; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_structInstArrayRef___closed__2() { _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_structInstArrayRef___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_structInstArrayRef___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_structInstArrayRef___closed__2; @@ -16484,11 +17213,10 @@ return x_4; lean_object* _init_l_Lean_Parser_Term_structInstLVal___closed__3() { _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_manyAux___main___at_Lean_Parser_Term_structInstLVal___elambda__1___spec__1___closed__1; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_structInstLVal___closed__4() { @@ -17340,1396 +18068,1429 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_35; lean_object* x_79; lean_object* x_117; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_181 = lean_ctor_get(x_2, 1); -lean_inc(x_181); -lean_inc(x_1); -x_182 = l_Lean_Parser_tokenFn(x_1, x_2); -x_183 = lean_ctor_get(x_182, 3); -lean_inc(x_183); -if (lean_obj_tag(x_183) == 0) -{ -lean_object* x_184; lean_object* x_185; -x_184 = lean_ctor_get(x_182, 0); -lean_inc(x_184); -x_185 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_184); -lean_dec(x_184); -if (lean_obj_tag(x_185) == 2) -{ -lean_object* x_186; lean_object* x_187; uint8_t x_188; -x_186 = lean_ctor_get(x_185, 1); -lean_inc(x_186); -lean_dec(x_185); -x_187 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; -x_188 = lean_string_dec_eq(x_186, x_187); -lean_dec(x_186); -if (x_188 == 0) -{ -lean_object* x_189; lean_object* x_190; -x_189 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_190 = l_Lean_Parser_ParserState_mkErrorsAt(x_182, x_189, x_181); -x_117 = x_190; -goto block_180; -} -else -{ -lean_dec(x_181); -x_117 = x_182; -goto block_180; -} -} -else -{ -lean_object* x_191; lean_object* x_192; -lean_dec(x_185); -x_191 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_192 = l_Lean_Parser_ParserState_mkErrorsAt(x_182, x_191, x_181); -x_117 = x_192; -goto block_180; -} -} -else -{ -lean_object* x_193; lean_object* x_194; -lean_dec(x_183); -x_193 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_194 = l_Lean_Parser_ParserState_mkErrorsAt(x_182, x_193, x_181); -x_117 = x_194; -goto block_180; -} -block_34: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; -x_10 = lean_ctor_get(x_8, 1); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_39; lean_object* x_83; lean_object* x_121; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_10 = lean_ctor_get(x_8, 0); 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_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; -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_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_19 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_18, x_10); -x_20 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_21 = l_Lean_Parser_ParserState_mkNode(x_19, x_20, x_7); -return x_21; -} -else -{ -lean_object* x_22; lean_object* x_23; +x_11 = lean_array_get_size(x_10); lean_dec(x_10); -x_22 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_11, x_22, x_7); -return x_23; +x_185 = lean_ctor_get(x_8, 1); +lean_inc(x_185); +lean_inc(x_1); +x_186 = l_Lean_Parser_tokenFn(x_1, x_8); +x_187 = lean_ctor_get(x_186, 3); +lean_inc(x_187); +if (lean_obj_tag(x_187) == 0) +{ +lean_object* x_188; lean_object* x_189; +x_188 = lean_ctor_get(x_186, 0); +lean_inc(x_188); +x_189 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_188); +lean_dec(x_188); +if (lean_obj_tag(x_189) == 2) +{ +lean_object* x_190; lean_object* x_191; uint8_t x_192; +x_190 = lean_ctor_get(x_189, 1); +lean_inc(x_190); +lean_dec(x_189); +x_191 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; +x_192 = lean_string_dec_eq(x_190, x_191); +lean_dec(x_190); +if (x_192 == 0) +{ +lean_object* x_193; lean_object* x_194; +x_193 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_194 = l_Lean_Parser_ParserState_mkErrorsAt(x_186, x_193, x_185); +x_121 = x_194; +goto block_184; +} +else +{ +lean_dec(x_185); +x_121 = x_186; +goto block_184; } } else { -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_object* x_195; lean_object* x_196; +lean_dec(x_189); +x_195 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_196 = l_Lean_Parser_ParserState_mkErrorsAt(x_186, x_195, x_185); +x_121 = x_196; +goto block_184; +} +} +else +{ +lean_object* x_197; lean_object* x_198; +lean_dec(x_187); +x_197 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_198 = l_Lean_Parser_ParserState_mkErrorsAt(x_186, x_197, x_185); +x_121 = x_198; +goto block_184; +} +block_38: +{ +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; +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +x_15 = l_Lean_Parser_tokenFn(x_1, 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_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); +lean_dec(x_18); +x_20 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; +x_21 = lean_string_dec_eq(x_19, x_20); +lean_dec(x_19); +if (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_explicitUniv___elambda__1___closed__11; +x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); +x_24 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_11); +return x_25; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_dec(x_14); -x_24 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_24, x_10); x_26 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_7); +x_27 = l_Lean_Parser_ParserState_mkNode(x_15, x_26, x_11); return x_27; } } else { lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_12); +lean_dec(x_18); x_28 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_28, x_10); +x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_28, x_14); x_30 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_7); +x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_11); return x_31; } } else { -lean_object* x_32; lean_object* x_33; -lean_dec(x_9); +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_dec(x_16); +x_32 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_32, x_14); +x_34 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_11); +return x_35; +} +} +else +{ +lean_object* x_36; lean_object* x_37; +lean_dec(x_13); lean_dec(x_1); -x_32 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_33 = l_Lean_Parser_ParserState_mkNode(x_8, x_32, x_7); -return x_33; +x_36 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_37 = l_Lean_Parser_ParserState_mkNode(x_12, x_36, x_11); +return x_37; } } -block_78: +block_82: { -lean_object* x_36; -x_36 = lean_ctor_get(x_35, 3); -lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) +lean_object* x_40; +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { -lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_63; lean_object* x_64; -x_37 = lean_ctor_get(x_35, 0); -lean_inc(x_37); -x_38 = lean_array_get_size(x_37); -lean_dec(x_37); -x_39 = lean_ctor_get(x_35, 1); -lean_inc(x_39); +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_67; lean_object* x_68; +x_41 = lean_ctor_get(x_39, 0); +lean_inc(x_41); +x_42 = lean_array_get_size(x_41); +lean_dec(x_41); +x_43 = lean_ctor_get(x_39, 1); +lean_inc(x_43); lean_inc(x_1); -x_63 = l_Lean_Parser_tokenFn(x_1, x_35); -x_64 = lean_ctor_get(x_63, 3); -lean_inc(x_64); -if (lean_obj_tag(x_64) == 0) +x_67 = l_Lean_Parser_tokenFn(x_1, x_39); +x_68 = lean_ctor_get(x_67, 3); +lean_inc(x_68); +if (lean_obj_tag(x_68) == 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_checkStackTopFn___spec__1(x_65); -lean_dec(x_65); -if (lean_obj_tag(x_66) == 2) +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_checkStackTopFn___spec__1(x_69); +lean_dec(x_69); +if (lean_obj_tag(x_70) == 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_typeAscription___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_typeAscription___elambda__1___closed__8; -lean_inc(x_39); -x_71 = l_Lean_Parser_ParserState_mkErrorsAt(x_63, x_70, x_39); -x_40 = x_71; -goto block_62; -} -else -{ -x_40 = x_63; -goto block_62; -} -} -else -{ -lean_object* x_72; lean_object* x_73; -lean_dec(x_66); -x_72 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; -lean_inc(x_39); -x_73 = l_Lean_Parser_ParserState_mkErrorsAt(x_63, x_72, x_39); -x_40 = x_73; -goto block_62; -} -} -else +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_typeAscription___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; -lean_dec(x_64); x_74 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; -lean_inc(x_39); -x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_63, x_74, x_39); -x_40 = x_75; -goto block_62; -} -block_62: -{ -lean_object* x_41; -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; -x_42 = l_Lean_Parser_termParser___closed__2; -x_43 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_44 = l_Lean_Parser_categoryParser___elambda__1(x_42, x_43, x_1, x_40); -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_dec(x_39); -x_46 = l_Lean_nullKind; -x_47 = l_Lean_Parser_ParserState_mkNode(x_44, x_46, x_38); -x_8 = x_47; -goto block_34; +lean_inc(x_43); +x_75 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_74, x_43); +x_44 = x_75; +goto block_66; } else { -lean_object* x_48; uint8_t x_49; -lean_dec(x_45); -x_48 = lean_ctor_get(x_44, 1); -lean_inc(x_48); -x_49 = lean_nat_dec_eq(x_48, x_39); -lean_dec(x_48); -if (x_49 == 0) -{ -lean_object* x_50; lean_object* x_51; -lean_dec(x_39); -x_50 = l_Lean_nullKind; -x_51 = l_Lean_Parser_ParserState_mkNode(x_44, x_50, x_38); -x_8 = x_51; -goto block_34; -} -else -{ -lean_object* x_52; lean_object* x_53; lean_object* x_54; -x_52 = l_Lean_Parser_ParserState_restore(x_44, x_38, x_39); -x_53 = l_Lean_nullKind; -x_54 = l_Lean_Parser_ParserState_mkNode(x_52, x_53, x_38); -x_8 = x_54; -goto block_34; -} -} -} -else -{ -lean_object* x_55; uint8_t x_56; -lean_dec(x_41); -x_55 = lean_ctor_get(x_40, 1); -lean_inc(x_55); -x_56 = lean_nat_dec_eq(x_55, x_39); -lean_dec(x_55); -if (x_56 == 0) -{ -lean_object* x_57; lean_object* x_58; -lean_dec(x_39); -x_57 = l_Lean_nullKind; -x_58 = l_Lean_Parser_ParserState_mkNode(x_40, x_57, x_38); -x_8 = x_58; -goto block_34; -} -else -{ -lean_object* x_59; lean_object* x_60; lean_object* x_61; -x_59 = l_Lean_Parser_ParserState_restore(x_40, x_38, x_39); -x_60 = l_Lean_nullKind; -x_61 = l_Lean_Parser_ParserState_mkNode(x_59, x_60, x_38); -x_8 = x_61; -goto block_34; -} -} +x_44 = x_67; +goto block_66; } } else { lean_object* x_76; lean_object* x_77; -lean_dec(x_36); +lean_dec(x_70); +x_76 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; +lean_inc(x_43); +x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_76, x_43); +x_44 = x_77; +goto block_66; +} +} +else +{ +lean_object* x_78; lean_object* x_79; +lean_dec(x_68); +x_78 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; +lean_inc(x_43); +x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_67, x_78, x_43); +x_44 = x_79; +goto block_66; +} +block_66: +{ +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_object* x_48; lean_object* x_49; +x_46 = l_Lean_Parser_termParser___closed__2; +x_47 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_48 = l_Lean_Parser_categoryParser___elambda__1(x_46, x_47, x_1, x_44); +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_dec(x_43); +x_50 = l_Lean_nullKind; +x_51 = l_Lean_Parser_ParserState_mkNode(x_48, x_50, x_42); +x_12 = x_51; +goto block_38; +} +else +{ +lean_object* x_52; uint8_t x_53; +lean_dec(x_49); +x_52 = lean_ctor_get(x_48, 1); +lean_inc(x_52); +x_53 = lean_nat_dec_eq(x_52, x_43); +lean_dec(x_52); +if (x_53 == 0) +{ +lean_object* x_54; lean_object* x_55; +lean_dec(x_43); +x_54 = l_Lean_nullKind; +x_55 = l_Lean_Parser_ParserState_mkNode(x_48, x_54, x_42); +x_12 = x_55; +goto block_38; +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = l_Lean_Parser_ParserState_restore(x_48, x_42, x_43); +x_57 = l_Lean_nullKind; +x_58 = l_Lean_Parser_ParserState_mkNode(x_56, x_57, x_42); +x_12 = x_58; +goto block_38; +} +} +} +else +{ +lean_object* x_59; uint8_t x_60; +lean_dec(x_45); +x_59 = lean_ctor_get(x_44, 1); +lean_inc(x_59); +x_60 = lean_nat_dec_eq(x_59, x_43); +lean_dec(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; +lean_dec(x_43); +x_61 = l_Lean_nullKind; +x_62 = l_Lean_Parser_ParserState_mkNode(x_44, x_61, x_42); +x_12 = x_62; +goto block_38; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = l_Lean_Parser_ParserState_restore(x_44, x_42, x_43); +x_64 = l_Lean_nullKind; +x_65 = l_Lean_Parser_ParserState_mkNode(x_63, x_64, x_42); +x_12 = x_65; +goto block_38; +} +} +} +} +else +{ +lean_object* x_80; lean_object* x_81; +lean_dec(x_40); lean_dec(x_1); -x_76 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_77 = l_Lean_Parser_ParserState_mkNode(x_35, x_76, x_7); -return x_77; +x_80 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_81 = l_Lean_Parser_ParserState_mkNode(x_39, x_80, x_11); +return x_81; } } -block_116: +block_120: { -lean_object* x_80; -x_80 = lean_ctor_get(x_79, 3); -lean_inc(x_80); -if (lean_obj_tag(x_80) == 0) -{ -uint8_t x_81; lean_object* x_82; lean_object* x_83; -x_81 = 1; -lean_inc(x_1); -x_82 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(x_81, x_1, x_79); -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; lean_object* x_87; lean_object* x_99; lean_object* x_100; -x_84 = lean_ctor_get(x_82, 0); +lean_object* x_84; +x_84 = lean_ctor_get(x_83, 3); lean_inc(x_84); -x_85 = lean_array_get_size(x_84); -lean_dec(x_84); -x_86 = lean_ctor_get(x_82, 1); -lean_inc(x_86); +if (lean_obj_tag(x_84) == 0) +{ +uint8_t x_85; lean_object* x_86; lean_object* x_87; +x_85 = 1; lean_inc(x_1); -x_99 = l_Lean_Parser_tokenFn(x_1, x_82); -x_100 = lean_ctor_get(x_99, 3); -lean_inc(x_100); -if (lean_obj_tag(x_100) == 0) +x_86 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(x_85, 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_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_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_103; lean_object* x_104; +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_1); +x_103 = l_Lean_Parser_tokenFn(x_1, x_86); +x_104 = lean_ctor_get(x_103, 3); +lean_inc(x_104); +if (lean_obj_tag(x_104) == 0) { -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_Lean_Parser_Term_structInst___elambda__1___closed__8; -x_105 = lean_string_dec_eq(x_103, x_104); -lean_dec(x_103); -if (x_105 == 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_checkStackTopFn___spec__1(x_105); +lean_dec(x_105); +if (lean_obj_tag(x_106) == 2) { -lean_object* x_106; lean_object* x_107; -x_106 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; -lean_inc(x_86); -x_107 = l_Lean_Parser_ParserState_mkErrorsAt(x_99, x_106, x_86); -x_87 = x_107; -goto block_98; -} -else -{ -x_87 = x_99; -goto block_98; -} -} -else -{ -lean_object* x_108; lean_object* x_109; -lean_dec(x_102); -x_108 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; -lean_inc(x_86); -x_109 = l_Lean_Parser_ParserState_mkErrorsAt(x_99, x_108, x_86); -x_87 = x_109; -goto block_98; -} -} -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_Lean_Parser_Term_structInst___elambda__1___closed__8; +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; -lean_dec(x_100); x_110 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; -lean_inc(x_86); -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_99, x_110, x_86); -x_87 = x_111; -goto block_98; -} -block_98: -{ -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_dec(x_86); -x_89 = l_Lean_nullKind; -x_90 = l_Lean_Parser_ParserState_mkNode(x_87, x_89, x_85); -x_35 = x_90; -goto block_78; +lean_inc(x_90); +x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_110, x_90); +x_91 = x_111; +goto block_102; } else { -lean_object* x_91; uint8_t x_92; -lean_dec(x_88); -x_91 = lean_ctor_get(x_87, 1); -lean_inc(x_91); -x_92 = lean_nat_dec_eq(x_91, x_86); -lean_dec(x_91); -if (x_92 == 0) -{ -lean_object* x_93; lean_object* x_94; -lean_dec(x_86); -x_93 = l_Lean_nullKind; -x_94 = l_Lean_Parser_ParserState_mkNode(x_87, x_93, x_85); -x_35 = x_94; -goto block_78; -} -else -{ -lean_object* x_95; lean_object* x_96; lean_object* x_97; -x_95 = l_Lean_Parser_ParserState_restore(x_87, x_85, x_86); -x_96 = l_Lean_nullKind; -x_97 = l_Lean_Parser_ParserState_mkNode(x_95, x_96, x_85); -x_35 = x_97; -goto block_78; -} -} +x_91 = x_103; +goto block_102; } } else { lean_object* x_112; lean_object* x_113; -lean_dec(x_83); -lean_dec(x_1); -x_112 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_113 = l_Lean_Parser_ParserState_mkNode(x_82, x_112, x_7); -return x_113; +lean_dec(x_106); +x_112 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; +lean_inc(x_90); +x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_112, x_90); +x_91 = x_113; +goto block_102; } } else { lean_object* x_114; lean_object* x_115; -lean_dec(x_80); +lean_dec(x_104); +x_114 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; +lean_inc(x_90); +x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_114, x_90); +x_91 = x_115; +goto block_102; +} +block_102: +{ +lean_object* x_92; +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_39 = x_94; +goto block_82; +} +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_39 = x_98; +goto block_82; +} +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_39 = x_101; +goto block_82; +} +} +} +} +else +{ +lean_object* x_116; lean_object* x_117; +lean_dec(x_87); lean_dec(x_1); -x_114 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_115 = l_Lean_Parser_ParserState_mkNode(x_79, x_114, x_7); -return x_115; -} -} -block_180: -{ -lean_object* x_118; -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; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; -x_119 = lean_ctor_get(x_117, 0); -lean_inc(x_119); -x_120 = lean_ctor_get(x_117, 1); -lean_inc(x_120); -x_121 = lean_array_get_size(x_119); -lean_dec(x_119); -x_145 = l_Lean_Parser_termParser___closed__2; -x_146 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_147 = l_Lean_Parser_categoryParser___elambda__1(x_145, x_146, x_1, x_117); -x_148 = lean_ctor_get(x_147, 3); -lean_inc(x_148); -if (lean_obj_tag(x_148) == 0) -{ -lean_object* x_149; lean_object* x_150; lean_object* x_151; -x_149 = lean_ctor_get(x_147, 1); -lean_inc(x_149); -lean_inc(x_1); -x_150 = l_Lean_Parser_tokenFn(x_1, x_147); -x_151 = lean_ctor_get(x_150, 3); -lean_inc(x_151); -if (lean_obj_tag(x_151) == 0) -{ -lean_object* x_152; lean_object* x_153; -x_152 = lean_ctor_get(x_150, 0); -lean_inc(x_152); -x_153 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_152); -lean_dec(x_152); -if (lean_obj_tag(x_153) == 2) -{ -lean_object* x_154; lean_object* x_155; uint8_t x_156; -x_154 = lean_ctor_get(x_153, 1); -lean_inc(x_154); -lean_dec(x_153); -x_155 = l_Lean_Parser_Term_structInst___elambda__1___closed__7; -x_156 = lean_string_dec_eq(x_154, x_155); -lean_dec(x_154); -if (x_156 == 0) -{ -lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; -x_157 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; -x_158 = l_Lean_Parser_ParserState_mkErrorsAt(x_150, x_157, x_149); -x_159 = lean_ctor_get(x_158, 0); -lean_inc(x_159); -x_160 = lean_ctor_get(x_158, 2); -lean_inc(x_160); -x_161 = lean_ctor_get(x_158, 3); -lean_inc(x_161); -x_122 = x_158; -x_123 = x_159; -x_124 = x_160; -x_125 = x_161; -goto block_144; -} -else -{ -lean_object* x_162; lean_object* x_163; lean_object* x_164; -lean_dec(x_149); -x_162 = lean_ctor_get(x_150, 0); -lean_inc(x_162); -x_163 = lean_ctor_get(x_150, 2); -lean_inc(x_163); -x_164 = lean_ctor_get(x_150, 3); -lean_inc(x_164); -x_122 = x_150; -x_123 = x_162; -x_124 = x_163; -x_125 = x_164; -goto block_144; +x_116 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_117 = l_Lean_Parser_ParserState_mkNode(x_86, x_116, x_11); +return x_117; } } else { -lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; -lean_dec(x_153); -x_165 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; -x_166 = l_Lean_Parser_ParserState_mkErrorsAt(x_150, x_165, x_149); -x_167 = lean_ctor_get(x_166, 0); -lean_inc(x_167); -x_168 = lean_ctor_get(x_166, 2); -lean_inc(x_168); -x_169 = lean_ctor_get(x_166, 3); -lean_inc(x_169); -x_122 = x_166; -x_123 = x_167; -x_124 = x_168; -x_125 = x_169; -goto block_144; +lean_object* x_118; lean_object* x_119; +lean_dec(x_84); +lean_dec(x_1); +x_118 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_119 = l_Lean_Parser_ParserState_mkNode(x_83, x_118, x_11); +return x_119; } } -else +block_184: { -lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; -lean_dec(x_151); -x_170 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; -x_171 = l_Lean_Parser_ParserState_mkErrorsAt(x_150, x_170, x_149); -x_172 = lean_ctor_get(x_171, 0); -lean_inc(x_172); -x_173 = lean_ctor_get(x_171, 2); -lean_inc(x_173); -x_174 = lean_ctor_get(x_171, 3); -lean_inc(x_174); -x_122 = x_171; -x_123 = x_172; -x_124 = x_173; -x_125 = x_174; -goto block_144; -} -} -else +lean_object* x_122; +x_122 = lean_ctor_get(x_121, 3); +lean_inc(x_122); +if (lean_obj_tag(x_122) == 0) { -lean_object* x_175; lean_object* x_176; lean_object* x_177; -lean_dec(x_148); -x_175 = lean_ctor_get(x_147, 0); -lean_inc(x_175); -x_176 = lean_ctor_get(x_147, 2); -lean_inc(x_176); -x_177 = lean_ctor_get(x_147, 3); -lean_inc(x_177); -x_122 = x_147; -x_123 = x_175; -x_124 = x_176; -x_125 = x_177; -goto block_144; -} -block_144: -{ -if (lean_obj_tag(x_125) == 0) -{ -lean_object* x_126; -lean_dec(x_124); +lean_object* x_123; 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_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_123 = lean_ctor_get(x_121, 0); +lean_inc(x_123); +x_124 = lean_ctor_get(x_121, 1); +lean_inc(x_124); +x_125 = lean_array_get_size(x_123); lean_dec(x_123); -x_126 = lean_ctor_get(x_122, 3); -lean_inc(x_126); -if (lean_obj_tag(x_126) == 0) +x_149 = l_Lean_Parser_termParser___closed__2; +x_150 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_151 = l_Lean_Parser_categoryParser___elambda__1(x_149, x_150, x_1, x_121); +x_152 = lean_ctor_get(x_151, 3); +lean_inc(x_152); +if (lean_obj_tag(x_152) == 0) { -lean_object* x_127; lean_object* x_128; -lean_dec(x_120); -x_127 = l_Lean_nullKind; -x_128 = l_Lean_Parser_ParserState_mkNode(x_122, x_127, x_121); -x_79 = x_128; -goto block_116; +lean_object* x_153; lean_object* x_154; lean_object* x_155; +x_153 = lean_ctor_get(x_151, 1); +lean_inc(x_153); +lean_inc(x_1); +x_154 = l_Lean_Parser_tokenFn(x_1, x_151); +x_155 = lean_ctor_get(x_154, 3); +lean_inc(x_155); +if (lean_obj_tag(x_155) == 0) +{ +lean_object* x_156; lean_object* x_157; +x_156 = lean_ctor_get(x_154, 0); +lean_inc(x_156); +x_157 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_156); +lean_dec(x_156); +if (lean_obj_tag(x_157) == 2) +{ +lean_object* x_158; lean_object* x_159; uint8_t x_160; +x_158 = lean_ctor_get(x_157, 1); +lean_inc(x_158); +lean_dec(x_157); +x_159 = l_Lean_Parser_Term_structInst___elambda__1___closed__7; +x_160 = lean_string_dec_eq(x_158, x_159); +lean_dec(x_158); +if (x_160 == 0) +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; +x_161 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; +x_162 = l_Lean_Parser_ParserState_mkErrorsAt(x_154, x_161, x_153); +x_163 = lean_ctor_get(x_162, 0); +lean_inc(x_163); +x_164 = lean_ctor_get(x_162, 2); +lean_inc(x_164); +x_165 = lean_ctor_get(x_162, 3); +lean_inc(x_165); +x_126 = x_162; +x_127 = x_163; +x_128 = x_164; +x_129 = x_165; +goto block_148; } else { -lean_object* x_129; uint8_t x_130; -lean_dec(x_126); -x_129 = lean_ctor_get(x_122, 1); -lean_inc(x_129); -x_130 = lean_nat_dec_eq(x_129, x_120); -lean_dec(x_129); -if (x_130 == 0) +lean_object* x_166; lean_object* x_167; lean_object* x_168; +lean_dec(x_153); +x_166 = lean_ctor_get(x_154, 0); +lean_inc(x_166); +x_167 = lean_ctor_get(x_154, 2); +lean_inc(x_167); +x_168 = lean_ctor_get(x_154, 3); +lean_inc(x_168); +x_126 = x_154; +x_127 = x_166; +x_128 = x_167; +x_129 = x_168; +goto block_148; +} +} +else +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; +lean_dec(x_157); +x_169 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; +x_170 = l_Lean_Parser_ParserState_mkErrorsAt(x_154, x_169, x_153); +x_171 = lean_ctor_get(x_170, 0); +lean_inc(x_171); +x_172 = lean_ctor_get(x_170, 2); +lean_inc(x_172); +x_173 = lean_ctor_get(x_170, 3); +lean_inc(x_173); +x_126 = x_170; +x_127 = x_171; +x_128 = x_172; +x_129 = x_173; +goto block_148; +} +} +else +{ +lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; +lean_dec(x_155); +x_174 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; +x_175 = l_Lean_Parser_ParserState_mkErrorsAt(x_154, x_174, x_153); +x_176 = lean_ctor_get(x_175, 0); +lean_inc(x_176); +x_177 = lean_ctor_get(x_175, 2); +lean_inc(x_177); +x_178 = lean_ctor_get(x_175, 3); +lean_inc(x_178); +x_126 = x_175; +x_127 = x_176; +x_128 = x_177; +x_129 = x_178; +goto block_148; +} +} +else +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; +lean_dec(x_152); +x_179 = lean_ctor_get(x_151, 0); +lean_inc(x_179); +x_180 = lean_ctor_get(x_151, 2); +lean_inc(x_180); +x_181 = lean_ctor_get(x_151, 3); +lean_inc(x_181); +x_126 = x_151; +x_127 = x_179; +x_128 = x_180; +x_129 = x_181; +goto block_148; +} +block_148: +{ +if (lean_obj_tag(x_129) == 0) +{ +lean_object* x_130; +lean_dec(x_128); +lean_dec(x_127); +x_130 = lean_ctor_get(x_126, 3); +lean_inc(x_130); +if (lean_obj_tag(x_130) == 0) { lean_object* x_131; lean_object* x_132; -lean_dec(x_120); +lean_dec(x_124); x_131 = l_Lean_nullKind; -x_132 = l_Lean_Parser_ParserState_mkNode(x_122, x_131, x_121); -x_79 = x_132; -goto block_116; +x_132 = l_Lean_Parser_ParserState_mkNode(x_126, x_131, x_125); +x_83 = x_132; +goto block_120; } else { -lean_object* x_133; lean_object* x_134; lean_object* x_135; -x_133 = l_Lean_Parser_ParserState_restore(x_122, x_121, x_120); -x_134 = l_Lean_nullKind; -x_135 = l_Lean_Parser_ParserState_mkNode(x_133, x_134, x_121); -x_79 = x_135; -goto block_116; +lean_object* x_133; uint8_t x_134; +lean_dec(x_130); +x_133 = lean_ctor_get(x_126, 1); +lean_inc(x_133); +x_134 = lean_nat_dec_eq(x_133, x_124); +lean_dec(x_133); +if (x_134 == 0) +{ +lean_object* x_135; lean_object* x_136; +lean_dec(x_124); +x_135 = l_Lean_nullKind; +x_136 = l_Lean_Parser_ParserState_mkNode(x_126, x_135, x_125); +x_83 = x_136; +goto block_120; +} +else +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_137 = l_Lean_Parser_ParserState_restore(x_126, x_125, x_124); +x_138 = l_Lean_nullKind; +x_139 = l_Lean_Parser_ParserState_mkNode(x_137, x_138, x_125); +x_83 = x_139; +goto block_120; } } } else { -lean_object* x_136; lean_object* x_137; uint8_t x_138; +lean_object* x_140; lean_object* x_141; uint8_t x_142; +lean_dec(x_126); +x_140 = l_Array_shrink___main___rarg(x_127, x_125); +lean_inc(x_124); +x_141 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_141, 0, x_140); +lean_ctor_set(x_141, 1, x_124); +lean_ctor_set(x_141, 2, x_128); +lean_ctor_set(x_141, 3, x_129); +x_142 = lean_nat_dec_eq(x_124, x_124); +if (x_142 == 0) +{ +lean_object* x_143; lean_object* x_144; +lean_dec(x_124); +x_143 = l_Lean_nullKind; +x_144 = l_Lean_Parser_ParserState_mkNode(x_141, x_143, x_125); +x_83 = x_144; +goto block_120; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = l_Lean_Parser_ParserState_restore(x_141, x_125, x_124); +x_146 = l_Lean_nullKind; +x_147 = l_Lean_Parser_ParserState_mkNode(x_145, x_146, x_125); +x_83 = x_147; +goto block_120; +} +} +} +} +else +{ +lean_object* x_182; lean_object* x_183; lean_dec(x_122); -x_136 = l_Array_shrink___main___rarg(x_123, x_121); -lean_inc(x_120); -x_137 = lean_alloc_ctor(0, 4, 0); -lean_ctor_set(x_137, 0, x_136); -lean_ctor_set(x_137, 1, x_120); -lean_ctor_set(x_137, 2, x_124); -lean_ctor_set(x_137, 3, x_125); -x_138 = lean_nat_dec_eq(x_120, x_120); -if (x_138 == 0) -{ -lean_object* x_139; lean_object* x_140; -lean_dec(x_120); -x_139 = l_Lean_nullKind; -x_140 = l_Lean_Parser_ParserState_mkNode(x_137, x_139, x_121); -x_79 = x_140; -goto block_116; -} -else -{ -lean_object* x_141; lean_object* x_142; lean_object* x_143; -x_141 = l_Lean_Parser_ParserState_restore(x_137, x_121, x_120); -x_142 = l_Lean_nullKind; -x_143 = l_Lean_Parser_ParserState_mkNode(x_141, x_142, x_121); -x_79 = x_143; -goto block_116; -} -} -} -} -else -{ -lean_object* x_178; lean_object* x_179; -lean_dec(x_118); lean_dec(x_1); -x_178 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_179 = l_Lean_Parser_ParserState_mkNode(x_117, x_178, x_7); -return x_179; +x_182 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_183 = l_Lean_Parser_ParserState_mkNode(x_121, x_182, x_11); +return x_183; } } } else { -lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; -x_195 = lean_ctor_get(x_2, 0); -lean_inc(x_195); -x_196 = lean_array_get_size(x_195); -lean_dec(x_195); -x_197 = lean_ctor_get(x_2, 1); -lean_inc(x_197); -lean_inc(x_1); -x_198 = lean_apply_2(x_4, x_1, x_2); -x_199 = lean_ctor_get(x_198, 3); +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_199 = lean_ctor_get(x_2, 0); lean_inc(x_199); -if (lean_obj_tag(x_199) == 0) -{ -lean_dec(x_197); -lean_dec(x_196); -lean_dec(x_1); -return x_198; -} -else -{ -lean_object* x_200; lean_object* x_201; uint8_t x_202; -x_200 = lean_ctor_get(x_199, 0); -lean_inc(x_200); +x_200 = lean_array_get_size(x_199); lean_dec(x_199); -x_201 = lean_ctor_get(x_198, 1); +x_201 = lean_ctor_get(x_2, 1); lean_inc(x_201); -x_202 = lean_nat_dec_eq(x_201, x_197); -lean_dec(x_201); -if (x_202 == 0) +lean_inc(x_1); +x_202 = lean_apply_2(x_4, x_1, x_2); +x_203 = lean_ctor_get(x_202, 3); +lean_inc(x_203); +if (lean_obj_tag(x_203) == 0) { +lean_dec(x_201); lean_dec(x_200); -lean_dec(x_197); -lean_dec(x_196); lean_dec(x_1); -return x_198; +return x_202; } else { -lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_238; lean_object* x_283; lean_object* x_323; lean_object* x_388; lean_object* x_389; -lean_inc(x_197); -x_203 = l_Lean_Parser_ParserState_restore(x_198, x_196, x_197); -lean_dec(x_196); +lean_object* x_204; lean_object* x_205; uint8_t x_206; x_204 = lean_ctor_get(x_203, 0); lean_inc(x_204); -x_205 = lean_array_get_size(x_204); +lean_dec(x_203); +x_205 = lean_ctor_get(x_202, 1); +lean_inc(x_205); +x_206 = lean_nat_dec_eq(x_205, x_201); +lean_dec(x_205); +if (x_206 == 0) +{ lean_dec(x_204); +lean_dec(x_201); +lean_dec(x_200); +lean_dec(x_1); +return x_202; +} +else +{ +lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; +lean_inc(x_201); +x_207 = l_Lean_Parser_ParserState_restore(x_202, x_200, x_201); +lean_dec(x_200); +x_208 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_209 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_210 = l_Lean_Parser_checkRbpLtFn(x_208, x_209, x_1, x_207); +x_211 = lean_ctor_get(x_210, 3); +lean_inc(x_211); +if (lean_obj_tag(x_211) == 0) +{ +lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_246; lean_object* x_291; lean_object* x_331; lean_object* x_396; lean_object* x_397; lean_object* x_398; +x_212 = lean_ctor_get(x_210, 0); +lean_inc(x_212); +x_213 = lean_array_get_size(x_212); +lean_dec(x_212); +x_396 = lean_ctor_get(x_210, 1); +lean_inc(x_396); lean_inc(x_1); -x_388 = l_Lean_Parser_tokenFn(x_1, x_203); -x_389 = lean_ctor_get(x_388, 3); -lean_inc(x_389); -if (lean_obj_tag(x_389) == 0) -{ -lean_object* x_390; lean_object* x_391; -x_390 = lean_ctor_get(x_388, 0); -lean_inc(x_390); -x_391 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_390); -lean_dec(x_390); -if (lean_obj_tag(x_391) == 2) -{ -lean_object* x_392; lean_object* x_393; uint8_t x_394; -x_392 = lean_ctor_get(x_391, 1); -lean_inc(x_392); -lean_dec(x_391); -x_393 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; -x_394 = lean_string_dec_eq(x_392, x_393); -lean_dec(x_392); -if (x_394 == 0) -{ -lean_object* x_395; lean_object* x_396; -x_395 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_197); -x_396 = l_Lean_Parser_ParserState_mkErrorsAt(x_388, x_395, x_197); -x_323 = x_396; -goto block_387; -} -else -{ -x_323 = x_388; -goto block_387; -} -} -else -{ -lean_object* x_397; lean_object* x_398; -lean_dec(x_391); -x_397 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_197); -x_398 = l_Lean_Parser_ParserState_mkErrorsAt(x_388, x_397, x_197); -x_323 = x_398; -goto block_387; -} -} -else +x_397 = l_Lean_Parser_tokenFn(x_1, x_210); +x_398 = lean_ctor_get(x_397, 3); +lean_inc(x_398); +if (lean_obj_tag(x_398) == 0) { lean_object* x_399; lean_object* x_400; -lean_dec(x_389); -x_399 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_197); -x_400 = l_Lean_Parser_ParserState_mkErrorsAt(x_388, x_399, x_197); -x_323 = x_400; -goto block_387; -} -block_237: +x_399 = lean_ctor_get(x_397, 0); +lean_inc(x_399); +x_400 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_399); +lean_dec(x_399); +if (lean_obj_tag(x_400) == 2) { -lean_object* x_207; -x_207 = lean_ctor_get(x_206, 3); -lean_inc(x_207); -if (lean_obj_tag(x_207) == 0) +lean_object* x_401; lean_object* x_402; uint8_t x_403; +x_401 = lean_ctor_get(x_400, 1); +lean_inc(x_401); +lean_dec(x_400); +x_402 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; +x_403 = lean_string_dec_eq(x_401, x_402); +lean_dec(x_401); +if (x_403 == 0) { -lean_object* x_208; lean_object* x_209; lean_object* x_210; -x_208 = lean_ctor_get(x_206, 1); -lean_inc(x_208); -x_209 = l_Lean_Parser_tokenFn(x_1, x_206); -x_210 = lean_ctor_get(x_209, 3); -lean_inc(x_210); -if (lean_obj_tag(x_210) == 0) -{ -lean_object* x_211; lean_object* x_212; -x_211 = lean_ctor_get(x_209, 0); -lean_inc(x_211); -x_212 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_211); -lean_dec(x_211); -if (lean_obj_tag(x_212) == 2) -{ -lean_object* x_213; lean_object* x_214; uint8_t x_215; -x_213 = lean_ctor_get(x_212, 1); -lean_inc(x_213); -lean_dec(x_212); -x_214 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; -x_215 = lean_string_dec_eq(x_213, x_214); -lean_dec(x_213); -if (x_215 == 0) -{ -lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; -x_216 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_217 = l_Lean_Parser_ParserState_mkErrorsAt(x_209, x_216, x_208); -x_218 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_219 = l_Lean_Parser_ParserState_mkNode(x_217, x_218, x_205); -x_220 = l_Lean_Parser_mergeOrElseErrors(x_219, x_200, x_197); -lean_dec(x_197); -return x_220; +lean_object* x_404; lean_object* x_405; +x_404 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_405 = l_Lean_Parser_ParserState_mkErrorsAt(x_397, x_404, x_396); +x_331 = x_405; +goto block_395; } else { -lean_object* x_221; lean_object* x_222; lean_object* x_223; -lean_dec(x_208); -x_221 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_222 = l_Lean_Parser_ParserState_mkNode(x_209, x_221, x_205); -x_223 = l_Lean_Parser_mergeOrElseErrors(x_222, x_200, x_197); -lean_dec(x_197); -return x_223; +lean_dec(x_396); +x_331 = x_397; +goto block_395; } } else { +lean_object* x_406; lean_object* x_407; +lean_dec(x_400); +x_406 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_407 = l_Lean_Parser_ParserState_mkErrorsAt(x_397, x_406, x_396); +x_331 = x_407; +goto block_395; +} +} +else +{ +lean_object* x_408; lean_object* x_409; +lean_dec(x_398); +x_408 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_409 = l_Lean_Parser_ParserState_mkErrorsAt(x_397, x_408, x_396); +x_331 = x_409; +goto block_395; +} +block_245: +{ +lean_object* x_215; +x_215 = lean_ctor_get(x_214, 3); +lean_inc(x_215); +if (lean_obj_tag(x_215) == 0) +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; +x_216 = lean_ctor_get(x_214, 1); +lean_inc(x_216); +x_217 = l_Lean_Parser_tokenFn(x_1, x_214); +x_218 = lean_ctor_get(x_217, 3); +lean_inc(x_218); +if (lean_obj_tag(x_218) == 0) +{ +lean_object* x_219; lean_object* x_220; +x_219 = lean_ctor_get(x_217, 0); +lean_inc(x_219); +x_220 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_219); +lean_dec(x_219); +if (lean_obj_tag(x_220) == 2) +{ +lean_object* x_221; lean_object* x_222; uint8_t x_223; +x_221 = lean_ctor_get(x_220, 1); +lean_inc(x_221); +lean_dec(x_220); +x_222 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; +x_223 = lean_string_dec_eq(x_221, x_222); +lean_dec(x_221); +if (x_223 == 0) +{ lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; -lean_dec(x_212); x_224 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_225 = l_Lean_Parser_ParserState_mkErrorsAt(x_209, x_224, x_208); +x_225 = l_Lean_Parser_ParserState_mkErrorsAt(x_217, x_224, x_216); x_226 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_227 = l_Lean_Parser_ParserState_mkNode(x_225, x_226, x_205); -x_228 = l_Lean_Parser_mergeOrElseErrors(x_227, x_200, x_197); -lean_dec(x_197); +x_227 = l_Lean_Parser_ParserState_mkNode(x_225, x_226, x_213); +x_228 = l_Lean_Parser_mergeOrElseErrors(x_227, x_204, x_201); +lean_dec(x_201); return x_228; } -} else { -lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; -lean_dec(x_210); -x_229 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_230 = l_Lean_Parser_ParserState_mkErrorsAt(x_209, x_229, x_208); -x_231 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_232 = l_Lean_Parser_ParserState_mkNode(x_230, x_231, x_205); -x_233 = l_Lean_Parser_mergeOrElseErrors(x_232, x_200, x_197); -lean_dec(x_197); -return x_233; +lean_object* x_229; lean_object* x_230; lean_object* x_231; +lean_dec(x_216); +x_229 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_230 = l_Lean_Parser_ParserState_mkNode(x_217, x_229, x_213); +x_231 = l_Lean_Parser_mergeOrElseErrors(x_230, x_204, x_201); +lean_dec(x_201); +return x_231; } } else { -lean_object* x_234; lean_object* x_235; lean_object* x_236; -lean_dec(x_207); -lean_dec(x_1); +lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; +lean_dec(x_220); +x_232 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_233 = l_Lean_Parser_ParserState_mkErrorsAt(x_217, x_232, x_216); x_234 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_235 = l_Lean_Parser_ParserState_mkNode(x_206, x_234, x_205); -x_236 = l_Lean_Parser_mergeOrElseErrors(x_235, x_200, x_197); -lean_dec(x_197); +x_235 = l_Lean_Parser_ParserState_mkNode(x_233, x_234, x_213); +x_236 = l_Lean_Parser_mergeOrElseErrors(x_235, x_204, x_201); +lean_dec(x_201); return x_236; } } -block_282: +else { -lean_object* x_239; -x_239 = lean_ctor_get(x_238, 3); -lean_inc(x_239); -if (lean_obj_tag(x_239) == 0) +lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; +lean_dec(x_218); +x_237 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_238 = l_Lean_Parser_ParserState_mkErrorsAt(x_217, x_237, x_216); +x_239 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_240 = l_Lean_Parser_ParserState_mkNode(x_238, x_239, x_213); +x_241 = l_Lean_Parser_mergeOrElseErrors(x_240, x_204, x_201); +lean_dec(x_201); +return x_241; +} +} +else { -lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_266; lean_object* x_267; -x_240 = lean_ctor_get(x_238, 0); -lean_inc(x_240); -x_241 = lean_array_get_size(x_240); -lean_dec(x_240); -x_242 = lean_ctor_get(x_238, 1); -lean_inc(x_242); +lean_object* x_242; lean_object* x_243; lean_object* x_244; +lean_dec(x_215); +lean_dec(x_1); +x_242 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_243 = l_Lean_Parser_ParserState_mkNode(x_214, x_242, x_213); +x_244 = l_Lean_Parser_mergeOrElseErrors(x_243, x_204, x_201); +lean_dec(x_201); +return x_244; +} +} +block_290: +{ +lean_object* x_247; +x_247 = lean_ctor_get(x_246, 3); +lean_inc(x_247); +if (lean_obj_tag(x_247) == 0) +{ +lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_274; lean_object* x_275; +x_248 = lean_ctor_get(x_246, 0); +lean_inc(x_248); +x_249 = lean_array_get_size(x_248); +lean_dec(x_248); +x_250 = lean_ctor_get(x_246, 1); +lean_inc(x_250); lean_inc(x_1); -x_266 = l_Lean_Parser_tokenFn(x_1, x_238); -x_267 = lean_ctor_get(x_266, 3); -lean_inc(x_267); -if (lean_obj_tag(x_267) == 0) +x_274 = l_Lean_Parser_tokenFn(x_1, x_246); +x_275 = lean_ctor_get(x_274, 3); +lean_inc(x_275); +if (lean_obj_tag(x_275) == 0) +{ +lean_object* x_276; lean_object* x_277; +x_276 = lean_ctor_get(x_274, 0); +lean_inc(x_276); +x_277 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_276); +lean_dec(x_276); +if (lean_obj_tag(x_277) == 2) +{ +lean_object* x_278; lean_object* x_279; uint8_t x_280; +x_278 = lean_ctor_get(x_277, 1); +lean_inc(x_278); +lean_dec(x_277); +x_279 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5; +x_280 = lean_string_dec_eq(x_278, x_279); +lean_dec(x_278); +if (x_280 == 0) +{ +lean_object* x_281; lean_object* x_282; +x_281 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; +lean_inc(x_250); +x_282 = l_Lean_Parser_ParserState_mkErrorsAt(x_274, x_281, x_250); +x_251 = x_282; +goto block_273; +} +else +{ +x_251 = x_274; +goto block_273; +} +} +else +{ +lean_object* x_283; lean_object* x_284; +lean_dec(x_277); +x_283 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; +lean_inc(x_250); +x_284 = l_Lean_Parser_ParserState_mkErrorsAt(x_274, x_283, x_250); +x_251 = x_284; +goto block_273; +} +} +else +{ +lean_object* x_285; lean_object* x_286; +lean_dec(x_275); +x_285 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; +lean_inc(x_250); +x_286 = l_Lean_Parser_ParserState_mkErrorsAt(x_274, x_285, x_250); +x_251 = x_286; +goto block_273; +} +block_273: +{ +lean_object* x_252; +x_252 = lean_ctor_get(x_251, 3); +lean_inc(x_252); +if (lean_obj_tag(x_252) == 0) +{ +lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; +x_253 = l_Lean_Parser_termParser___closed__2; +x_254 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_255 = l_Lean_Parser_categoryParser___elambda__1(x_253, x_254, x_1, x_251); +x_256 = lean_ctor_get(x_255, 3); +lean_inc(x_256); +if (lean_obj_tag(x_256) == 0) +{ +lean_object* x_257; lean_object* x_258; +lean_dec(x_250); +x_257 = l_Lean_nullKind; +x_258 = l_Lean_Parser_ParserState_mkNode(x_255, x_257, x_249); +x_214 = x_258; +goto block_245; +} +else +{ +lean_object* x_259; uint8_t x_260; +lean_dec(x_256); +x_259 = lean_ctor_get(x_255, 1); +lean_inc(x_259); +x_260 = lean_nat_dec_eq(x_259, x_250); +lean_dec(x_259); +if (x_260 == 0) +{ +lean_object* x_261; lean_object* x_262; +lean_dec(x_250); +x_261 = l_Lean_nullKind; +x_262 = l_Lean_Parser_ParserState_mkNode(x_255, x_261, x_249); +x_214 = x_262; +goto block_245; +} +else +{ +lean_object* x_263; lean_object* x_264; lean_object* x_265; +x_263 = l_Lean_Parser_ParserState_restore(x_255, x_249, x_250); +x_264 = l_Lean_nullKind; +x_265 = l_Lean_Parser_ParserState_mkNode(x_263, x_264, x_249); +x_214 = x_265; +goto block_245; +} +} +} +else +{ +lean_object* x_266; uint8_t x_267; +lean_dec(x_252); +x_266 = lean_ctor_get(x_251, 1); +lean_inc(x_266); +x_267 = lean_nat_dec_eq(x_266, x_250); +lean_dec(x_266); +if (x_267 == 0) { lean_object* x_268; lean_object* x_269; -x_268 = lean_ctor_get(x_266, 0); -lean_inc(x_268); -x_269 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_268); -lean_dec(x_268); -if (lean_obj_tag(x_269) == 2) -{ -lean_object* x_270; lean_object* x_271; uint8_t x_272; -x_270 = lean_ctor_get(x_269, 1); -lean_inc(x_270); -lean_dec(x_269); -x_271 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__5; -x_272 = lean_string_dec_eq(x_270, x_271); -lean_dec(x_270); -if (x_272 == 0) -{ -lean_object* x_273; lean_object* x_274; -x_273 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; -lean_inc(x_242); -x_274 = l_Lean_Parser_ParserState_mkErrorsAt(x_266, x_273, x_242); -x_243 = x_274; -goto block_265; +lean_dec(x_250); +x_268 = l_Lean_nullKind; +x_269 = l_Lean_Parser_ParserState_mkNode(x_251, x_268, x_249); +x_214 = x_269; +goto block_245; } else { -x_243 = x_266; -goto block_265; -} -} -else -{ -lean_object* x_275; lean_object* x_276; -lean_dec(x_269); -x_275 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; -lean_inc(x_242); -x_276 = l_Lean_Parser_ParserState_mkErrorsAt(x_266, x_275, x_242); -x_243 = x_276; -goto block_265; -} -} -else -{ -lean_object* x_277; lean_object* x_278; -lean_dec(x_267); -x_277 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__8; -lean_inc(x_242); -x_278 = l_Lean_Parser_ParserState_mkErrorsAt(x_266, x_277, x_242); -x_243 = x_278; -goto block_265; -} -block_265: -{ -lean_object* x_244; -x_244 = lean_ctor_get(x_243, 3); -lean_inc(x_244); -if (lean_obj_tag(x_244) == 0) -{ -lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; -x_245 = l_Lean_Parser_termParser___closed__2; -x_246 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_247 = l_Lean_Parser_categoryParser___elambda__1(x_245, x_246, x_1, x_243); -x_248 = lean_ctor_get(x_247, 3); -lean_inc(x_248); -if (lean_obj_tag(x_248) == 0) -{ -lean_object* x_249; lean_object* x_250; -lean_dec(x_242); -x_249 = l_Lean_nullKind; -x_250 = l_Lean_Parser_ParserState_mkNode(x_247, x_249, x_241); -x_206 = x_250; -goto block_237; -} -else -{ -lean_object* x_251; uint8_t x_252; -lean_dec(x_248); -x_251 = lean_ctor_get(x_247, 1); -lean_inc(x_251); -x_252 = lean_nat_dec_eq(x_251, x_242); -lean_dec(x_251); -if (x_252 == 0) -{ -lean_object* x_253; lean_object* x_254; -lean_dec(x_242); -x_253 = l_Lean_nullKind; -x_254 = l_Lean_Parser_ParserState_mkNode(x_247, x_253, x_241); -x_206 = x_254; -goto block_237; -} -else -{ -lean_object* x_255; lean_object* x_256; lean_object* x_257; -x_255 = l_Lean_Parser_ParserState_restore(x_247, x_241, x_242); -x_256 = l_Lean_nullKind; -x_257 = l_Lean_Parser_ParserState_mkNode(x_255, x_256, x_241); -x_206 = x_257; -goto block_237; -} -} -} -else -{ -lean_object* x_258; uint8_t x_259; -lean_dec(x_244); -x_258 = lean_ctor_get(x_243, 1); -lean_inc(x_258); -x_259 = lean_nat_dec_eq(x_258, x_242); -lean_dec(x_258); -if (x_259 == 0) -{ -lean_object* x_260; lean_object* x_261; -lean_dec(x_242); -x_260 = l_Lean_nullKind; -x_261 = l_Lean_Parser_ParserState_mkNode(x_243, x_260, x_241); -x_206 = x_261; -goto block_237; -} -else -{ -lean_object* x_262; lean_object* x_263; lean_object* x_264; -x_262 = l_Lean_Parser_ParserState_restore(x_243, x_241, x_242); -x_263 = l_Lean_nullKind; -x_264 = l_Lean_Parser_ParserState_mkNode(x_262, x_263, x_241); -x_206 = x_264; -goto block_237; +lean_object* x_270; lean_object* x_271; lean_object* x_272; +x_270 = l_Lean_Parser_ParserState_restore(x_251, x_249, x_250); +x_271 = l_Lean_nullKind; +x_272 = l_Lean_Parser_ParserState_mkNode(x_270, x_271, x_249); +x_214 = x_272; +goto block_245; } } } } else { -lean_object* x_279; lean_object* x_280; lean_object* x_281; -lean_dec(x_239); +lean_object* x_287; lean_object* x_288; lean_object* x_289; +lean_dec(x_247); lean_dec(x_1); -x_279 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_280 = l_Lean_Parser_ParserState_mkNode(x_238, x_279, x_205); -x_281 = l_Lean_Parser_mergeOrElseErrors(x_280, x_200, x_197); -lean_dec(x_197); -return x_281; +x_287 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_288 = l_Lean_Parser_ParserState_mkNode(x_246, x_287, x_213); +x_289 = l_Lean_Parser_mergeOrElseErrors(x_288, x_204, x_201); +lean_dec(x_201); +return x_289; } } -block_322: -{ -lean_object* x_284; -x_284 = lean_ctor_get(x_283, 3); -lean_inc(x_284); -if (lean_obj_tag(x_284) == 0) -{ -uint8_t x_285; lean_object* x_286; lean_object* x_287; -x_285 = 1; -lean_inc(x_1); -x_286 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(x_285, x_1, x_283); -x_287 = lean_ctor_get(x_286, 3); -lean_inc(x_287); -if (lean_obj_tag(x_287) == 0) -{ -lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_303; lean_object* x_304; -x_288 = lean_ctor_get(x_286, 0); -lean_inc(x_288); -x_289 = lean_array_get_size(x_288); -lean_dec(x_288); -x_290 = lean_ctor_get(x_286, 1); -lean_inc(x_290); -lean_inc(x_1); -x_303 = l_Lean_Parser_tokenFn(x_1, x_286); -x_304 = lean_ctor_get(x_303, 3); -lean_inc(x_304); -if (lean_obj_tag(x_304) == 0) -{ -lean_object* x_305; lean_object* x_306; -x_305 = lean_ctor_get(x_303, 0); -lean_inc(x_305); -x_306 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_305); -lean_dec(x_305); -if (lean_obj_tag(x_306) == 2) -{ -lean_object* x_307; lean_object* x_308; uint8_t x_309; -x_307 = lean_ctor_get(x_306, 1); -lean_inc(x_307); -lean_dec(x_306); -x_308 = l_Lean_Parser_Term_structInst___elambda__1___closed__8; -x_309 = lean_string_dec_eq(x_307, x_308); -lean_dec(x_307); -if (x_309 == 0) -{ -lean_object* x_310; lean_object* x_311; -x_310 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; -lean_inc(x_290); -x_311 = l_Lean_Parser_ParserState_mkErrorsAt(x_303, x_310, x_290); -x_291 = x_311; -goto block_302; -} -else -{ -x_291 = x_303; -goto block_302; -} -} -else -{ -lean_object* x_312; lean_object* x_313; -lean_dec(x_306); -x_312 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; -lean_inc(x_290); -x_313 = l_Lean_Parser_ParserState_mkErrorsAt(x_303, x_312, x_290); -x_291 = x_313; -goto block_302; -} -} -else -{ -lean_object* x_314; lean_object* x_315; -lean_dec(x_304); -x_314 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; -lean_inc(x_290); -x_315 = l_Lean_Parser_ParserState_mkErrorsAt(x_303, x_314, x_290); -x_291 = x_315; -goto block_302; -} -block_302: +block_330: { lean_object* x_292; x_292 = lean_ctor_get(x_291, 3); lean_inc(x_292); if (lean_obj_tag(x_292) == 0) { -lean_object* x_293; lean_object* x_294; -lean_dec(x_290); -x_293 = l_Lean_nullKind; -x_294 = l_Lean_Parser_ParserState_mkNode(x_291, x_293, x_289); -x_238 = x_294; -goto block_282; -} -else -{ -lean_object* x_295; uint8_t x_296; -lean_dec(x_292); -x_295 = lean_ctor_get(x_291, 1); +uint8_t x_293; lean_object* x_294; lean_object* x_295; +x_293 = 1; +lean_inc(x_1); +x_294 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(x_293, x_1, x_291); +x_295 = lean_ctor_get(x_294, 3); lean_inc(x_295); -x_296 = lean_nat_dec_eq(x_295, x_290); +if (lean_obj_tag(x_295) == 0) +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_311; lean_object* x_312; +x_296 = lean_ctor_get(x_294, 0); +lean_inc(x_296); +x_297 = lean_array_get_size(x_296); +lean_dec(x_296); +x_298 = lean_ctor_get(x_294, 1); +lean_inc(x_298); +lean_inc(x_1); +x_311 = l_Lean_Parser_tokenFn(x_1, x_294); +x_312 = lean_ctor_get(x_311, 3); +lean_inc(x_312); +if (lean_obj_tag(x_312) == 0) +{ +lean_object* x_313; lean_object* x_314; +x_313 = lean_ctor_get(x_311, 0); +lean_inc(x_313); +x_314 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_313); +lean_dec(x_313); +if (lean_obj_tag(x_314) == 2) +{ +lean_object* x_315; lean_object* x_316; uint8_t x_317; +x_315 = lean_ctor_get(x_314, 1); +lean_inc(x_315); +lean_dec(x_314); +x_316 = l_Lean_Parser_Term_structInst___elambda__1___closed__8; +x_317 = lean_string_dec_eq(x_315, x_316); +lean_dec(x_315); +if (x_317 == 0) +{ +lean_object* x_318; lean_object* x_319; +x_318 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; +lean_inc(x_298); +x_319 = l_Lean_Parser_ParserState_mkErrorsAt(x_311, x_318, x_298); +x_299 = x_319; +goto block_310; +} +else +{ +x_299 = x_311; +goto block_310; +} +} +else +{ +lean_object* x_320; lean_object* x_321; +lean_dec(x_314); +x_320 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; +lean_inc(x_298); +x_321 = l_Lean_Parser_ParserState_mkErrorsAt(x_311, x_320, x_298); +x_299 = x_321; +goto block_310; +} +} +else +{ +lean_object* x_322; lean_object* x_323; +lean_dec(x_312); +x_322 = l_Lean_Parser_Term_structInst___elambda__1___closed__11; +lean_inc(x_298); +x_323 = l_Lean_Parser_ParserState_mkErrorsAt(x_311, x_322, x_298); +x_299 = x_323; +goto block_310; +} +block_310: +{ +lean_object* x_300; +x_300 = lean_ctor_get(x_299, 3); +lean_inc(x_300); +if (lean_obj_tag(x_300) == 0) +{ +lean_object* x_301; lean_object* x_302; +lean_dec(x_298); +x_301 = l_Lean_nullKind; +x_302 = l_Lean_Parser_ParserState_mkNode(x_299, x_301, x_297); +x_246 = x_302; +goto block_290; +} +else +{ +lean_object* x_303; uint8_t x_304; +lean_dec(x_300); +x_303 = lean_ctor_get(x_299, 1); +lean_inc(x_303); +x_304 = lean_nat_dec_eq(x_303, x_298); +lean_dec(x_303); +if (x_304 == 0) +{ +lean_object* x_305; lean_object* x_306; +lean_dec(x_298); +x_305 = l_Lean_nullKind; +x_306 = l_Lean_Parser_ParserState_mkNode(x_299, x_305, x_297); +x_246 = x_306; +goto block_290; +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; +x_307 = l_Lean_Parser_ParserState_restore(x_299, x_297, x_298); +x_308 = l_Lean_nullKind; +x_309 = l_Lean_Parser_ParserState_mkNode(x_307, x_308, x_297); +x_246 = x_309; +goto block_290; +} +} +} +} +else +{ +lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_dec(x_295); -if (x_296 == 0) -{ -lean_object* x_297; lean_object* x_298; -lean_dec(x_290); -x_297 = l_Lean_nullKind; -x_298 = l_Lean_Parser_ParserState_mkNode(x_291, x_297, x_289); -x_238 = x_298; -goto block_282; -} -else -{ -lean_object* x_299; lean_object* x_300; lean_object* x_301; -x_299 = l_Lean_Parser_ParserState_restore(x_291, x_289, x_290); -x_300 = l_Lean_nullKind; -x_301 = l_Lean_Parser_ParserState_mkNode(x_299, x_300, x_289); -x_238 = x_301; -goto block_282; -} -} -} -} -else -{ -lean_object* x_316; lean_object* x_317; lean_object* x_318; -lean_dec(x_287); lean_dec(x_1); -x_316 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_317 = l_Lean_Parser_ParserState_mkNode(x_286, x_316, x_205); -x_318 = l_Lean_Parser_mergeOrElseErrors(x_317, x_200, x_197); -lean_dec(x_197); -return x_318; +x_324 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_325 = l_Lean_Parser_ParserState_mkNode(x_294, x_324, x_213); +x_326 = l_Lean_Parser_mergeOrElseErrors(x_325, x_204, x_201); +lean_dec(x_201); +return x_326; } } else { -lean_object* x_319; lean_object* x_320; lean_object* x_321; -lean_dec(x_284); +lean_object* x_327; lean_object* x_328; lean_object* x_329; +lean_dec(x_292); lean_dec(x_1); -x_319 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_320 = l_Lean_Parser_ParserState_mkNode(x_283, x_319, x_205); -x_321 = l_Lean_Parser_mergeOrElseErrors(x_320, x_200, x_197); -lean_dec(x_197); -return x_321; +x_327 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_328 = l_Lean_Parser_ParserState_mkNode(x_291, x_327, x_213); +x_329 = l_Lean_Parser_mergeOrElseErrors(x_328, x_204, x_201); +lean_dec(x_201); +return x_329; } } -block_387: +block_395: { -lean_object* x_324; -x_324 = lean_ctor_get(x_323, 3); -lean_inc(x_324); -if (lean_obj_tag(x_324) == 0) +lean_object* x_332; +x_332 = lean_ctor_get(x_331, 3); +lean_inc(x_332); +if (lean_obj_tag(x_332) == 0) { -lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; -x_325 = lean_ctor_get(x_323, 0); -lean_inc(x_325); -x_326 = lean_ctor_get(x_323, 1); -lean_inc(x_326); -x_327 = lean_array_get_size(x_325); -lean_dec(x_325); -x_351 = l_Lean_Parser_termParser___closed__2; -x_352 = lean_unsigned_to_nat(0u); +lean_object* x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; +x_333 = lean_ctor_get(x_331, 0); +lean_inc(x_333); +x_334 = lean_ctor_get(x_331, 1); +lean_inc(x_334); +x_335 = lean_array_get_size(x_333); +lean_dec(x_333); +x_359 = l_Lean_Parser_termParser___closed__2; +x_360 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_353 = l_Lean_Parser_categoryParser___elambda__1(x_351, x_352, x_1, x_323); -x_354 = lean_ctor_get(x_353, 3); -lean_inc(x_354); -if (lean_obj_tag(x_354) == 0) +x_361 = l_Lean_Parser_categoryParser___elambda__1(x_359, x_360, x_1, x_331); +x_362 = lean_ctor_get(x_361, 3); +lean_inc(x_362); +if (lean_obj_tag(x_362) == 0) { -lean_object* x_355; lean_object* x_356; lean_object* x_357; -x_355 = lean_ctor_get(x_353, 1); -lean_inc(x_355); +lean_object* x_363; lean_object* x_364; lean_object* x_365; +x_363 = lean_ctor_get(x_361, 1); +lean_inc(x_363); lean_inc(x_1); -x_356 = l_Lean_Parser_tokenFn(x_1, x_353); -x_357 = lean_ctor_get(x_356, 3); -lean_inc(x_357); -if (lean_obj_tag(x_357) == 0) -{ -lean_object* x_358; lean_object* x_359; -x_358 = lean_ctor_get(x_356, 0); -lean_inc(x_358); -x_359 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_358); -lean_dec(x_358); -if (lean_obj_tag(x_359) == 2) -{ -lean_object* x_360; lean_object* x_361; uint8_t x_362; -x_360 = lean_ctor_get(x_359, 1); -lean_inc(x_360); -lean_dec(x_359); -x_361 = l_Lean_Parser_Term_structInst___elambda__1___closed__7; -x_362 = lean_string_dec_eq(x_360, x_361); -lean_dec(x_360); -if (x_362 == 0) -{ -lean_object* x_363; lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; -x_363 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; -x_364 = l_Lean_Parser_ParserState_mkErrorsAt(x_356, x_363, x_355); -x_365 = lean_ctor_get(x_364, 0); +x_364 = l_Lean_Parser_tokenFn(x_1, x_361); +x_365 = lean_ctor_get(x_364, 3); lean_inc(x_365); -x_366 = lean_ctor_get(x_364, 2); -lean_inc(x_366); -x_367 = lean_ctor_get(x_364, 3); -lean_inc(x_367); -x_328 = x_364; -x_329 = x_365; -x_330 = x_366; -x_331 = x_367; -goto block_350; -} -else +if (lean_obj_tag(x_365) == 0) { -lean_object* x_368; lean_object* x_369; lean_object* x_370; -lean_dec(x_355); -x_368 = lean_ctor_get(x_356, 0); +lean_object* x_366; lean_object* x_367; +x_366 = lean_ctor_get(x_364, 0); +lean_inc(x_366); +x_367 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_366); +lean_dec(x_366); +if (lean_obj_tag(x_367) == 2) +{ +lean_object* x_368; lean_object* x_369; uint8_t x_370; +x_368 = lean_ctor_get(x_367, 1); lean_inc(x_368); -x_369 = lean_ctor_get(x_356, 2); -lean_inc(x_369); -x_370 = lean_ctor_get(x_356, 3); -lean_inc(x_370); -x_328 = x_356; -x_329 = x_368; -x_330 = x_369; -x_331 = x_370; -goto block_350; -} -} -else +lean_dec(x_367); +x_369 = l_Lean_Parser_Term_structInst___elambda__1___closed__7; +x_370 = lean_string_dec_eq(x_368, x_369); +lean_dec(x_368); +if (x_370 == 0) { lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; -lean_dec(x_359); x_371 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; -x_372 = l_Lean_Parser_ParserState_mkErrorsAt(x_356, x_371, x_355); +x_372 = l_Lean_Parser_ParserState_mkErrorsAt(x_364, x_371, x_363); x_373 = lean_ctor_get(x_372, 0); lean_inc(x_373); x_374 = lean_ctor_get(x_372, 2); lean_inc(x_374); x_375 = lean_ctor_get(x_372, 3); lean_inc(x_375); -x_328 = x_372; -x_329 = x_373; -x_330 = x_374; -x_331 = x_375; -goto block_350; -} +x_336 = x_372; +x_337 = x_373; +x_338 = x_374; +x_339 = x_375; +goto block_358; } else { -lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; -lean_dec(x_357); -x_376 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; -x_377 = l_Lean_Parser_ParserState_mkErrorsAt(x_356, x_376, x_355); -x_378 = lean_ctor_get(x_377, 0); +lean_object* x_376; lean_object* x_377; lean_object* x_378; +lean_dec(x_363); +x_376 = lean_ctor_get(x_364, 0); +lean_inc(x_376); +x_377 = lean_ctor_get(x_364, 2); +lean_inc(x_377); +x_378 = lean_ctor_get(x_364, 3); lean_inc(x_378); -x_379 = lean_ctor_get(x_377, 2); -lean_inc(x_379); -x_380 = lean_ctor_get(x_377, 3); -lean_inc(x_380); -x_328 = x_377; -x_329 = x_378; -x_330 = x_379; -x_331 = x_380; -goto block_350; +x_336 = x_364; +x_337 = x_376; +x_338 = x_377; +x_339 = x_378; +goto block_358; } } else { -lean_object* x_381; lean_object* x_382; lean_object* x_383; -lean_dec(x_354); -x_381 = lean_ctor_get(x_353, 0); +lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; +lean_dec(x_367); +x_379 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; +x_380 = l_Lean_Parser_ParserState_mkErrorsAt(x_364, x_379, x_363); +x_381 = lean_ctor_get(x_380, 0); lean_inc(x_381); -x_382 = lean_ctor_get(x_353, 2); +x_382 = lean_ctor_get(x_380, 2); lean_inc(x_382); -x_383 = lean_ctor_get(x_353, 3); +x_383 = lean_ctor_get(x_380, 3); lean_inc(x_383); -x_328 = x_353; -x_329 = x_381; -x_330 = x_382; -x_331 = x_383; -goto block_350; -} -block_350: -{ -if (lean_obj_tag(x_331) == 0) -{ -lean_object* x_332; -lean_dec(x_330); -lean_dec(x_329); -x_332 = lean_ctor_get(x_328, 3); -lean_inc(x_332); -if (lean_obj_tag(x_332) == 0) -{ -lean_object* x_333; lean_object* x_334; -lean_dec(x_326); -x_333 = l_Lean_nullKind; -x_334 = l_Lean_Parser_ParserState_mkNode(x_328, x_333, x_327); -x_283 = x_334; -goto block_322; -} -else -{ -lean_object* x_335; uint8_t x_336; -lean_dec(x_332); -x_335 = lean_ctor_get(x_328, 1); -lean_inc(x_335); -x_336 = lean_nat_dec_eq(x_335, x_326); -lean_dec(x_335); -if (x_336 == 0) -{ -lean_object* x_337; lean_object* x_338; -lean_dec(x_326); -x_337 = l_Lean_nullKind; -x_338 = l_Lean_Parser_ParserState_mkNode(x_328, x_337, x_327); -x_283 = x_338; -goto block_322; -} -else -{ -lean_object* x_339; lean_object* x_340; lean_object* x_341; -x_339 = l_Lean_Parser_ParserState_restore(x_328, x_327, x_326); -x_340 = l_Lean_nullKind; -x_341 = l_Lean_Parser_ParserState_mkNode(x_339, x_340, x_327); -x_283 = x_341; -goto block_322; -} +x_336 = x_380; +x_337 = x_381; +x_338 = x_382; +x_339 = x_383; +goto block_358; } } else { -lean_object* x_342; lean_object* x_343; uint8_t x_344; -lean_dec(x_328); -x_342 = l_Array_shrink___main___rarg(x_329, x_327); -lean_inc(x_326); -x_343 = lean_alloc_ctor(0, 4, 0); -lean_ctor_set(x_343, 0, x_342); -lean_ctor_set(x_343, 1, x_326); -lean_ctor_set(x_343, 2, x_330); -lean_ctor_set(x_343, 3, x_331); -x_344 = lean_nat_dec_eq(x_326, x_326); +lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; lean_object* x_388; +lean_dec(x_365); +x_384 = l_Lean_Parser_Term_structInst___elambda__1___closed__14; +x_385 = l_Lean_Parser_ParserState_mkErrorsAt(x_364, x_384, x_363); +x_386 = lean_ctor_get(x_385, 0); +lean_inc(x_386); +x_387 = lean_ctor_get(x_385, 2); +lean_inc(x_387); +x_388 = lean_ctor_get(x_385, 3); +lean_inc(x_388); +x_336 = x_385; +x_337 = x_386; +x_338 = x_387; +x_339 = x_388; +goto block_358; +} +} +else +{ +lean_object* x_389; lean_object* x_390; lean_object* x_391; +lean_dec(x_362); +x_389 = lean_ctor_get(x_361, 0); +lean_inc(x_389); +x_390 = lean_ctor_get(x_361, 2); +lean_inc(x_390); +x_391 = lean_ctor_get(x_361, 3); +lean_inc(x_391); +x_336 = x_361; +x_337 = x_389; +x_338 = x_390; +x_339 = x_391; +goto block_358; +} +block_358: +{ +if (lean_obj_tag(x_339) == 0) +{ +lean_object* x_340; +lean_dec(x_338); +lean_dec(x_337); +x_340 = lean_ctor_get(x_336, 3); +lean_inc(x_340); +if (lean_obj_tag(x_340) == 0) +{ +lean_object* x_341; lean_object* x_342; +lean_dec(x_334); +x_341 = l_Lean_nullKind; +x_342 = l_Lean_Parser_ParserState_mkNode(x_336, x_341, x_335); +x_291 = x_342; +goto block_330; +} +else +{ +lean_object* x_343; uint8_t x_344; +lean_dec(x_340); +x_343 = lean_ctor_get(x_336, 1); +lean_inc(x_343); +x_344 = lean_nat_dec_eq(x_343, x_334); +lean_dec(x_343); if (x_344 == 0) { lean_object* x_345; lean_object* x_346; -lean_dec(x_326); +lean_dec(x_334); x_345 = l_Lean_nullKind; -x_346 = l_Lean_Parser_ParserState_mkNode(x_343, x_345, x_327); -x_283 = x_346; -goto block_322; +x_346 = l_Lean_Parser_ParserState_mkNode(x_336, x_345, x_335); +x_291 = x_346; +goto block_330; } else { lean_object* x_347; lean_object* x_348; lean_object* x_349; -x_347 = l_Lean_Parser_ParserState_restore(x_343, x_327, x_326); +x_347 = l_Lean_Parser_ParserState_restore(x_336, x_335, x_334); x_348 = l_Lean_nullKind; -x_349 = l_Lean_Parser_ParserState_mkNode(x_347, x_348, x_327); -x_283 = x_349; -goto block_322; +x_349 = l_Lean_Parser_ParserState_mkNode(x_347, x_348, x_335); +x_291 = x_349; +goto block_330; +} +} +} +else +{ +lean_object* x_350; lean_object* x_351; uint8_t x_352; +lean_dec(x_336); +x_350 = l_Array_shrink___main___rarg(x_337, x_335); +lean_inc(x_334); +x_351 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_351, 0, x_350); +lean_ctor_set(x_351, 1, x_334); +lean_ctor_set(x_351, 2, x_338); +lean_ctor_set(x_351, 3, x_339); +x_352 = lean_nat_dec_eq(x_334, x_334); +if (x_352 == 0) +{ +lean_object* x_353; lean_object* x_354; +lean_dec(x_334); +x_353 = l_Lean_nullKind; +x_354 = l_Lean_Parser_ParserState_mkNode(x_351, x_353, x_335); +x_291 = x_354; +goto block_330; +} +else +{ +lean_object* x_355; lean_object* x_356; lean_object* x_357; +x_355 = l_Lean_Parser_ParserState_restore(x_351, x_335, x_334); +x_356 = l_Lean_nullKind; +x_357 = l_Lean_Parser_ParserState_mkNode(x_355, x_356, x_335); +x_291 = x_357; +goto block_330; } } } } else { -lean_object* x_384; lean_object* x_385; lean_object* x_386; -lean_dec(x_324); +lean_object* x_392; lean_object* x_393; lean_object* x_394; +lean_dec(x_332); lean_dec(x_1); -x_384 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; -x_385 = l_Lean_Parser_ParserState_mkNode(x_323, x_384, x_205); -x_386 = l_Lean_Parser_mergeOrElseErrors(x_385, x_200, x_197); -lean_dec(x_197); -return x_386; +x_392 = l_Lean_Parser_Term_structInst___elambda__1___closed__2; +x_393 = l_Lean_Parser_ParserState_mkNode(x_331, x_392, x_213); +x_394 = l_Lean_Parser_mergeOrElseErrors(x_393, x_204, x_201); +lean_dec(x_201); +return x_394; } } } +else +{ +lean_object* x_410; +lean_dec(x_211); +lean_dec(x_1); +x_410 = l_Lean_Parser_mergeOrElseErrors(x_210, x_204, x_201); +lean_dec(x_201); +return x_410; +} +} } } } @@ -18737,28 +19498,26 @@ return x_386; lean_object* _init_l_Lean_Parser_Term_structInst___closed__1() { _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_structInst___elambda__1___closed__5; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_structInst___closed__2() { _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_structInst___elambda__1___closed__7; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_structInst___closed__2; @@ -18790,11 +19549,10 @@ return x_4; lean_object* _init_l_Lean_Parser_Term_structInst___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_structInst___elambda__1___closed__8; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_structInst___closed__7() { @@ -18810,7 +19568,7 @@ lean_object* _init_l_Lean_Parser_Term_structInst___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_typeAscription___closed__1; @@ -18890,16 +19648,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_structInst___closed__16() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_structInst___closed__15; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_structInst___closed__17() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_structInst___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_structInst___closed__15; +x_3 = l_Lean_Parser_Term_structInst___closed__16; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_structInst___closed__17() { +lean_object* _init_l_Lean_Parser_Term_structInst___closed__18() { _start: { lean_object* x_1; @@ -18907,12 +19675,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_structInst___elambda__1), 2, return x_1; } } -lean_object* _init_l_Lean_Parser_Term_structInst___closed__18() { +lean_object* _init_l_Lean_Parser_Term_structInst___closed__19() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_structInst___closed__16; -x_2 = l_Lean_Parser_Term_structInst___closed__17; +x_1 = l_Lean_Parser_Term_structInst___closed__17; +x_2 = l_Lean_Parser_Term_structInst___closed__18; x_3 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_3, 0, x_1); lean_ctor_set(x_3, 1, x_2); @@ -18923,7 +19691,7 @@ lean_object* _init_l_Lean_Parser_Term_structInst() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_structInst___closed__18; +x_1 = l_Lean_Parser_Term_structInst___closed__19; return x_1; } } @@ -19477,604 +20245,637 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_41; lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_68 = lean_ctor_get(x_2, 1); -lean_inc(x_68); -lean_inc(x_1); -x_69 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_71 = lean_ctor_get(x_69, 0); -lean_inc(x_71); -x_72 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_71); -lean_dec(x_71); -if (lean_obj_tag(x_72) == 2) -{ -lean_object* x_73; lean_object* x_74; uint8_t x_75; -x_73 = lean_ctor_get(x_72, 1); -lean_inc(x_73); -lean_dec(x_72); -x_74 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; -x_75 = lean_string_dec_eq(x_73, x_74); -lean_dec(x_73); -if (x_75 == 0) -{ -lean_object* x_76; lean_object* x_77; -x_76 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_76, x_68); -x_41 = x_77; -goto block_67; -} -else -{ -lean_dec(x_68); -x_41 = x_69; -goto block_67; -} -} -else -{ -lean_object* x_78; lean_object* x_79; -lean_dec(x_72); -x_78 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_78, x_68); -x_41 = x_79; -goto block_67; -} -} -else -{ -lean_object* x_80; lean_object* x_81; -lean_dec(x_70); -x_80 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_81 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_80, x_68); -x_41 = x_81; -goto block_67; -} -block_40: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(0u); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_45; lean_object* x_72; lean_object* x_73; lean_object* x_74; +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_72 = lean_ctor_get(x_8, 1); +lean_inc(x_72); lean_inc(x_1); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); +x_73 = l_Lean_Parser_tokenFn(x_1, x_8); +x_74 = lean_ctor_get(x_73, 3); +lean_inc(x_74); +if (lean_obj_tag(x_74) == 0) +{ +lean_object* x_75; lean_object* x_76; +x_75 = lean_ctor_get(x_73, 0); +lean_inc(x_75); +x_76 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_75); +lean_dec(x_75); +if (lean_obj_tag(x_76) == 2) +{ +lean_object* x_77; lean_object* x_78; uint8_t x_79; +x_77 = lean_ctor_get(x_76, 1); +lean_inc(x_77); +lean_dec(x_76); +x_78 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; +x_79 = lean_string_dec_eq(x_77, x_78); +lean_dec(x_77); +if (x_79 == 0) +{ +lean_object* x_80; lean_object* x_81; +x_80 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_81 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_80, x_72); +x_45 = x_81; +goto block_71; +} +else +{ +lean_dec(x_72); +x_45 = x_73; +goto block_71; +} +} +else +{ +lean_object* x_82; lean_object* x_83; +lean_dec(x_76); +x_82 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_83 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_82, x_72); +x_45 = x_83; +goto block_71; +} +} +else +{ +lean_object* x_84; lean_object* x_85; +lean_dec(x_74); +x_84 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_84, x_72); +x_45 = x_85; +goto block_71; +} +block_44: +{ +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; -x_14 = lean_ctor_get(x_12, 1); -lean_inc(x_14); -x_15 = l_Lean_Parser_tokenFn(x_1, 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_object* x_18; -x_17 = lean_ctor_get(x_15, 0); +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = lean_ctor_get(x_16, 3); 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) +if (lean_obj_tag(x_17) == 0) { -lean_object* x_19; lean_object* x_20; uint8_t x_21; -x_19 = lean_ctor_get(x_18, 1); -lean_inc(x_19); -lean_dec(x_18); -x_20 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; -x_21 = lean_string_dec_eq(x_19, x_20); -lean_dec(x_19); -if (x_21 == 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_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; -x_22 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); -x_24 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); -return x_25; +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_19, 0); +lean_inc(x_21); +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); +lean_dec(x_22); +x_24 = l_Lean_Parser_Term_explicitUniv___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; +x_26 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); +x_28 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); +return x_29; } else { -lean_object* x_26; lean_object* x_27; -lean_dec(x_14); -x_26 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_27 = l_Lean_Parser_ParserState_mkNode(x_15, x_26, 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_30; lean_object* x_31; lean_dec(x_18); -x_28 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_28, x_14); x_30 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_7); +x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_11); return x_31; } } else { lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; -lean_dec(x_16); +lean_dec(x_22); x_32 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_32, x_14); +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_32, x_18); x_34 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_7); +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_11); return x_35; } } else { -lean_object* x_36; lean_object* x_37; -lean_dec(x_13); -lean_dec(x_1); -x_36 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_37 = l_Lean_Parser_ParserState_mkNode(x_12, x_36, x_7); -return x_37; +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +lean_dec(x_20); +x_36 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_36, x_18); +x_38 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_11); +return x_39; } } else { -lean_object* x_38; lean_object* x_39; -lean_dec(x_9); +lean_object* x_40; lean_object* x_41; +lean_dec(x_17); lean_dec(x_1); -x_38 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_39 = l_Lean_Parser_ParserState_mkNode(x_8, x_38, x_7); -return x_39; +x_40 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_41 = l_Lean_Parser_ParserState_mkNode(x_16, x_40, x_11); +return x_41; } } -block_67: +else { -lean_object* x_42; -x_42 = lean_ctor_get(x_41, 3); -lean_inc(x_42); -if (lean_obj_tag(x_42) == 0) +lean_object* x_42; lean_object* x_43; +lean_dec(x_13); +lean_dec(x_1); +x_42 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_43 = l_Lean_Parser_ParserState_mkNode(x_12, x_42, x_11); +return x_43; +} +} +block_71: { -lean_object* x_43; lean_object* x_44; -lean_inc(x_1); -x_43 = l_Lean_Parser_ident___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_inc(x_1); -x_45 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_43); +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; -x_47 = lean_ctor_get(x_45, 1); -lean_inc(x_47); +lean_object* x_47; lean_object* x_48; lean_inc(x_1); -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) +x_47 = l_Lean_Parser_ident___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_50; lean_object* x_51; -x_50 = lean_ctor_get(x_48, 0); +lean_object* x_49; lean_object* x_50; +lean_inc(x_1); +x_49 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_47); +x_50 = lean_ctor_get(x_49, 3); lean_inc(x_50); -x_51 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_50); -lean_dec(x_50); -if (lean_obj_tag(x_51) == 2) +if (lean_obj_tag(x_50) == 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_subtype___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_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); +if (lean_obj_tag(x_53) == 0) { -lean_object* x_55; lean_object* x_56; -x_55 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; -x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_55, x_47); -x_8 = x_56; -goto block_40; -} -else +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_dec(x_47); -x_8 = x_48; -goto block_40; -} -} -else -{ -lean_object* x_57; lean_object* x_58; -lean_dec(x_51); -x_57 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; -x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_57, x_47); -x_8 = x_58; -goto block_40; -} -} -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_subtype___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_dec(x_49); x_59 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; -x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_59, x_47); -x_8 = x_60; -goto block_40; +x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_59, x_51); +x_12 = x_60; +goto block_44; +} +else +{ +lean_dec(x_51); +x_12 = x_52; +goto block_44; } } else { lean_object* x_61; lean_object* x_62; -lean_dec(x_46); -lean_dec(x_1); -x_61 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_62 = l_Lean_Parser_ParserState_mkNode(x_45, x_61, x_7); -return x_62; +lean_dec(x_55); +x_61 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; +x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_61, x_51); +x_12 = x_62; +goto block_44; } } else { lean_object* x_63; lean_object* x_64; -lean_dec(x_44); -lean_dec(x_1); -x_63 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_64 = l_Lean_Parser_ParserState_mkNode(x_43, x_63, x_7); -return x_64; +lean_dec(x_53); +x_63 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; +x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_63, x_51); +x_12 = x_64; +goto block_44; } } else { lean_object* x_65; lean_object* x_66; -lean_dec(x_42); +lean_dec(x_50); lean_dec(x_1); x_65 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_66 = l_Lean_Parser_ParserState_mkNode(x_41, x_65, x_7); +x_66 = l_Lean_Parser_ParserState_mkNode(x_49, x_65, x_11); return x_66; } } +else +{ +lean_object* x_67; lean_object* x_68; +lean_dec(x_48); +lean_dec(x_1); +x_67 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_68 = l_Lean_Parser_ParserState_mkNode(x_47, x_67, x_11); +return x_68; +} } else { -lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; -x_82 = lean_ctor_get(x_2, 0); -lean_inc(x_82); -x_83 = lean_array_get_size(x_82); -lean_dec(x_82); -x_84 = lean_ctor_get(x_2, 1); -lean_inc(x_84); -lean_inc(x_1); -x_85 = lean_apply_2(x_4, x_1, x_2); -x_86 = lean_ctor_get(x_85, 3); +lean_object* x_69; lean_object* x_70; +lean_dec(x_46); +lean_dec(x_1); +x_69 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_70 = l_Lean_Parser_ParserState_mkNode(x_45, x_69, x_11); +return x_70; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_86 = lean_ctor_get(x_2, 0); lean_inc(x_86); -if (lean_obj_tag(x_86) == 0) -{ -lean_dec(x_84); -lean_dec(x_83); -lean_dec(x_1); -return x_85; -} -else -{ -lean_object* x_87; lean_object* x_88; uint8_t x_89; -x_87 = lean_ctor_get(x_86, 0); -lean_inc(x_87); +x_87 = lean_array_get_size(x_86); lean_dec(x_86); -x_88 = lean_ctor_get(x_85, 1); +x_88 = lean_ctor_get(x_2, 1); lean_inc(x_88); -x_89 = lean_nat_dec_eq(x_88, x_84); -lean_dec(x_88); -if (x_89 == 0) +lean_inc(x_1); +x_89 = lean_apply_2(x_4, x_1, x_2); +x_90 = lean_ctor_get(x_89, 3); +lean_inc(x_90); +if (lean_obj_tag(x_90) == 0) { +lean_dec(x_88); lean_dec(x_87); -lean_dec(x_84); -lean_dec(x_83); lean_dec(x_1); -return x_85; +return x_89; } else { -lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_132; lean_object* x_162; lean_object* x_163; -lean_inc(x_84); -x_90 = l_Lean_Parser_ParserState_restore(x_85, x_83, x_84); -lean_dec(x_83); +lean_object* x_91; lean_object* x_92; uint8_t x_93; x_91 = lean_ctor_get(x_90, 0); lean_inc(x_91); -x_92 = lean_array_get_size(x_91); +lean_dec(x_90); +x_92 = lean_ctor_get(x_89, 1); +lean_inc(x_92); +x_93 = lean_nat_dec_eq(x_92, x_88); +lean_dec(x_92); +if (x_93 == 0) +{ lean_dec(x_91); -lean_inc(x_1); -x_162 = l_Lean_Parser_tokenFn(x_1, x_90); -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; -x_164 = lean_ctor_get(x_162, 0); -lean_inc(x_164); -x_165 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_164); -lean_dec(x_164); -if (lean_obj_tag(x_165) == 2) -{ -lean_object* x_166; lean_object* x_167; uint8_t x_168; -x_166 = lean_ctor_get(x_165, 1); -lean_inc(x_166); -lean_dec(x_165); -x_167 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; -x_168 = lean_string_dec_eq(x_166, x_167); -lean_dec(x_166); -if (x_168 == 0) -{ -lean_object* x_169; lean_object* x_170; -x_169 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_84); -x_170 = l_Lean_Parser_ParserState_mkErrorsAt(x_162, x_169, x_84); -x_132 = x_170; -goto block_161; +lean_dec(x_88); +lean_dec(x_87); +lean_dec(x_1); +return x_89; } else { -x_132 = x_162; -goto block_161; -} -} -else -{ -lean_object* x_171; lean_object* x_172; -lean_dec(x_165); -x_171 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_84); -x_172 = l_Lean_Parser_ParserState_mkErrorsAt(x_162, x_171, x_84); -x_132 = x_172; -goto block_161; -} -} -else -{ -lean_object* x_173; lean_object* x_174; -lean_dec(x_163); -x_173 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_84); -x_174 = l_Lean_Parser_ParserState_mkErrorsAt(x_162, x_173, x_84); -x_132 = x_174; -goto block_161; -} -block_131: -{ -lean_object* x_94; -x_94 = lean_ctor_get(x_93, 3); -lean_inc(x_94); -if (lean_obj_tag(x_94) == 0) -{ -lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; -x_95 = l_Lean_Parser_termParser___closed__2; -x_96 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_97 = l_Lean_Parser_categoryParser___elambda__1(x_95, x_96, x_1, x_93); +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +lean_inc(x_88); +x_94 = l_Lean_Parser_ParserState_restore(x_89, x_87, x_88); +lean_dec(x_87); +x_95 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_96 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_97 = l_Lean_Parser_checkRbpLtFn(x_95, x_96, x_1, x_94); 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; -x_99 = lean_ctor_get(x_97, 1); +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_140; lean_object* x_170; lean_object* x_171; lean_object* x_172; +x_99 = lean_ctor_get(x_97, 0); lean_inc(x_99); -x_100 = l_Lean_Parser_tokenFn(x_1, x_97); -x_101 = lean_ctor_get(x_100, 3); -lean_inc(x_101); -if (lean_obj_tag(x_101) == 0) -{ -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_104; lean_object* x_105; uint8_t x_106; -x_104 = lean_ctor_get(x_103, 1); -lean_inc(x_104); -lean_dec(x_103); -x_105 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; -x_106 = lean_string_dec_eq(x_104, x_105); -lean_dec(x_104); -if (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 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_108 = l_Lean_Parser_ParserState_mkErrorsAt(x_100, x_107, x_99); -x_109 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_110 = l_Lean_Parser_ParserState_mkNode(x_108, x_109, x_92); -x_111 = l_Lean_Parser_mergeOrElseErrors(x_110, x_87, x_84); -lean_dec(x_84); -return x_111; -} -else -{ -lean_object* x_112; lean_object* x_113; lean_object* x_114; +x_100 = lean_array_get_size(x_99); lean_dec(x_99); -x_112 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_113 = l_Lean_Parser_ParserState_mkNode(x_100, x_112, x_92); -x_114 = l_Lean_Parser_mergeOrElseErrors(x_113, x_87, x_84); -lean_dec(x_84); -return x_114; +x_170 = lean_ctor_get(x_97, 1); +lean_inc(x_170); +lean_inc(x_1); +x_171 = l_Lean_Parser_tokenFn(x_1, x_97); +x_172 = lean_ctor_get(x_171, 3); +lean_inc(x_172); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; +x_173 = lean_ctor_get(x_171, 0); +lean_inc(x_173); +x_174 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_173); +lean_dec(x_173); +if (lean_obj_tag(x_174) == 2) +{ +lean_object* x_175; lean_object* x_176; uint8_t x_177; +x_175 = lean_ctor_get(x_174, 1); +lean_inc(x_175); +lean_dec(x_174); +x_176 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; +x_177 = lean_string_dec_eq(x_175, x_176); +lean_dec(x_175); +if (x_177 == 0) +{ +lean_object* x_178; lean_object* x_179; +x_178 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_179 = l_Lean_Parser_ParserState_mkErrorsAt(x_171, x_178, x_170); +x_140 = x_179; +goto block_169; +} +else +{ +lean_dec(x_170); +x_140 = x_171; +goto block_169; } } else { +lean_object* x_180; lean_object* x_181; +lean_dec(x_174); +x_180 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_181 = l_Lean_Parser_ParserState_mkErrorsAt(x_171, x_180, x_170); +x_140 = x_181; +goto block_169; +} +} +else +{ +lean_object* x_182; lean_object* x_183; +lean_dec(x_172); +x_182 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_183 = l_Lean_Parser_ParserState_mkErrorsAt(x_171, x_182, x_170); +x_140 = x_183; +goto block_169; +} +block_139: +{ +lean_object* x_102; +x_102 = lean_ctor_get(x_101, 3); +lean_inc(x_102); +if (lean_obj_tag(x_102) == 0) +{ +lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_103 = l_Lean_Parser_termParser___closed__2; +x_104 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_105 = l_Lean_Parser_categoryParser___elambda__1(x_103, x_104, x_1, x_101); +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); +x_108 = l_Lean_Parser_tokenFn(x_1, 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_checkStackTopFn___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_explicitUniv___elambda__1___closed__7; +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_103); x_115 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_116 = l_Lean_Parser_ParserState_mkErrorsAt(x_100, x_115, x_99); +x_116 = l_Lean_Parser_ParserState_mkErrorsAt(x_108, x_115, x_107); x_117 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_118 = l_Lean_Parser_ParserState_mkNode(x_116, x_117, x_92); -x_119 = l_Lean_Parser_mergeOrElseErrors(x_118, x_87, x_84); -lean_dec(x_84); +x_118 = l_Lean_Parser_ParserState_mkNode(x_116, x_117, x_100); +x_119 = l_Lean_Parser_mergeOrElseErrors(x_118, x_91, x_88); +lean_dec(x_88); 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_dec(x_101); -x_120 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_121 = l_Lean_Parser_ParserState_mkErrorsAt(x_100, x_120, x_99); -x_122 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_123 = l_Lean_Parser_ParserState_mkNode(x_121, x_122, x_92); -x_124 = l_Lean_Parser_mergeOrElseErrors(x_123, x_87, x_84); -lean_dec(x_84); -return x_124; +lean_object* x_120; lean_object* x_121; lean_object* x_122; +lean_dec(x_107); +x_120 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_121 = l_Lean_Parser_ParserState_mkNode(x_108, x_120, x_100); +x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_91, x_88); +lean_dec(x_88); +return x_122; } } else { -lean_object* x_125; lean_object* x_126; lean_object* x_127; -lean_dec(x_98); -lean_dec(x_1); +lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; +lean_dec(x_111); +x_123 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_108, x_123, x_107); x_125 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_126 = l_Lean_Parser_ParserState_mkNode(x_97, x_125, x_92); -x_127 = l_Lean_Parser_mergeOrElseErrors(x_126, x_87, x_84); -lean_dec(x_84); +x_126 = l_Lean_Parser_ParserState_mkNode(x_124, x_125, x_100); +x_127 = l_Lean_Parser_mergeOrElseErrors(x_126, x_91, x_88); +lean_dec(x_88); return x_127; } } else { -lean_object* x_128; lean_object* x_129; lean_object* x_130; -lean_dec(x_94); +lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; +lean_dec(x_109); +x_128 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_129 = l_Lean_Parser_ParserState_mkErrorsAt(x_108, x_128, x_107); +x_130 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_131 = l_Lean_Parser_ParserState_mkNode(x_129, x_130, x_100); +x_132 = l_Lean_Parser_mergeOrElseErrors(x_131, x_91, x_88); +lean_dec(x_88); +return x_132; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; +lean_dec(x_106); lean_dec(x_1); -x_128 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_129 = l_Lean_Parser_ParserState_mkNode(x_93, x_128, x_92); -x_130 = l_Lean_Parser_mergeOrElseErrors(x_129, x_87, x_84); -lean_dec(x_84); -return x_130; +x_133 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_134 = l_Lean_Parser_ParserState_mkNode(x_105, x_133, x_100); +x_135 = l_Lean_Parser_mergeOrElseErrors(x_134, x_91, x_88); +lean_dec(x_88); +return x_135; } } -block_161: +else { -lean_object* x_133; -x_133 = lean_ctor_get(x_132, 3); -lean_inc(x_133); -if (lean_obj_tag(x_133) == 0) +lean_object* x_136; lean_object* x_137; lean_object* x_138; +lean_dec(x_102); +lean_dec(x_1); +x_136 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_137 = l_Lean_Parser_ParserState_mkNode(x_101, x_136, x_100); +x_138 = l_Lean_Parser_mergeOrElseErrors(x_137, x_91, x_88); +lean_dec(x_88); +return x_138; +} +} +block_169: { -lean_object* x_134; lean_object* x_135; -lean_inc(x_1); -x_134 = l_Lean_Parser_ident___elambda__1(x_1, x_132); -x_135 = lean_ctor_get(x_134, 3); -lean_inc(x_135); -if (lean_obj_tag(x_135) == 0) -{ -lean_object* x_136; lean_object* x_137; -lean_inc(x_1); -x_136 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_134); -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; -x_138 = lean_ctor_get(x_136, 1); -lean_inc(x_138); -lean_inc(x_1); -x_139 = l_Lean_Parser_tokenFn(x_1, x_136); -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; -x_141 = lean_ctor_get(x_139, 0); +lean_object* x_141; +x_141 = lean_ctor_get(x_140, 3); lean_inc(x_141); -x_142 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_141); -lean_dec(x_141); -if (lean_obj_tag(x_142) == 2) +if (lean_obj_tag(x_141) == 0) { -lean_object* x_143; lean_object* x_144; uint8_t x_145; -x_143 = lean_ctor_get(x_142, 1); +lean_object* x_142; lean_object* x_143; +lean_inc(x_1); +x_142 = l_Lean_Parser_ident___elambda__1(x_1, x_140); +x_143 = lean_ctor_get(x_142, 3); lean_inc(x_143); -lean_dec(x_142); -x_144 = l_Lean_Parser_Term_subtype___elambda__1___closed__6; -x_145 = lean_string_dec_eq(x_143, x_144); +if (lean_obj_tag(x_143) == 0) +{ +lean_object* x_144; lean_object* x_145; +lean_inc(x_1); +x_144 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_142); +x_145 = lean_ctor_get(x_144, 3); +lean_inc(x_145); +if (lean_obj_tag(x_145) == 0) +{ +lean_object* x_146; lean_object* x_147; lean_object* x_148; +x_146 = lean_ctor_get(x_144, 1); +lean_inc(x_146); +lean_inc(x_1); +x_147 = l_Lean_Parser_tokenFn(x_1, x_144); +x_148 = lean_ctor_get(x_147, 3); +lean_inc(x_148); +if (lean_obj_tag(x_148) == 0) +{ +lean_object* x_149; lean_object* x_150; +x_149 = lean_ctor_get(x_147, 0); +lean_inc(x_149); +x_150 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_149); +lean_dec(x_149); +if (lean_obj_tag(x_150) == 2) +{ +lean_object* x_151; lean_object* x_152; uint8_t x_153; +x_151 = lean_ctor_get(x_150, 1); +lean_inc(x_151); +lean_dec(x_150); +x_152 = l_Lean_Parser_Term_subtype___elambda__1___closed__6; +x_153 = lean_string_dec_eq(x_151, x_152); +lean_dec(x_151); +if (x_153 == 0) +{ +lean_object* x_154; lean_object* x_155; +x_154 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; +x_155 = l_Lean_Parser_ParserState_mkErrorsAt(x_147, x_154, x_146); +x_101 = x_155; +goto block_139; +} +else +{ +lean_dec(x_146); +x_101 = x_147; +goto block_139; +} +} +else +{ +lean_object* x_156; lean_object* x_157; +lean_dec(x_150); +x_156 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; +x_157 = l_Lean_Parser_ParserState_mkErrorsAt(x_147, x_156, x_146); +x_101 = x_157; +goto block_139; +} +} +else +{ +lean_object* x_158; lean_object* x_159; +lean_dec(x_148); +x_158 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; +x_159 = l_Lean_Parser_ParserState_mkErrorsAt(x_147, x_158, x_146); +x_101 = x_159; +goto block_139; +} +} +else +{ +lean_object* x_160; lean_object* x_161; lean_object* x_162; +lean_dec(x_145); +lean_dec(x_1); +x_160 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_161 = l_Lean_Parser_ParserState_mkNode(x_144, x_160, x_100); +x_162 = l_Lean_Parser_mergeOrElseErrors(x_161, x_91, x_88); +lean_dec(x_88); +return x_162; +} +} +else +{ +lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_dec(x_143); -if (x_145 == 0) -{ -lean_object* x_146; lean_object* x_147; -x_146 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; -x_147 = l_Lean_Parser_ParserState_mkErrorsAt(x_139, x_146, x_138); -x_93 = x_147; -goto block_131; -} -else -{ -lean_dec(x_138); -x_93 = x_139; -goto block_131; -} -} -else -{ -lean_object* x_148; lean_object* x_149; -lean_dec(x_142); -x_148 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; -x_149 = l_Lean_Parser_ParserState_mkErrorsAt(x_139, x_148, x_138); -x_93 = x_149; -goto block_131; -} -} -else -{ -lean_object* x_150; lean_object* x_151; -lean_dec(x_140); -x_150 = l_Lean_Parser_Term_subtype___elambda__1___closed__9; -x_151 = l_Lean_Parser_ParserState_mkErrorsAt(x_139, x_150, x_138); -x_93 = x_151; -goto block_131; -} -} -else -{ -lean_object* x_152; lean_object* x_153; lean_object* x_154; -lean_dec(x_137); lean_dec(x_1); -x_152 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_153 = l_Lean_Parser_ParserState_mkNode(x_136, x_152, x_92); -x_154 = l_Lean_Parser_mergeOrElseErrors(x_153, x_87, x_84); -lean_dec(x_84); -return x_154; +x_163 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_164 = l_Lean_Parser_ParserState_mkNode(x_142, x_163, x_100); +x_165 = l_Lean_Parser_mergeOrElseErrors(x_164, x_91, x_88); +lean_dec(x_88); +return x_165; } } else { -lean_object* x_155; lean_object* x_156; lean_object* x_157; -lean_dec(x_135); +lean_object* x_166; lean_object* x_167; lean_object* x_168; +lean_dec(x_141); lean_dec(x_1); -x_155 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_156 = l_Lean_Parser_ParserState_mkNode(x_134, x_155, x_92); -x_157 = l_Lean_Parser_mergeOrElseErrors(x_156, x_87, x_84); -lean_dec(x_84); -return x_157; +x_166 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; +x_167 = l_Lean_Parser_ParserState_mkNode(x_140, x_166, x_100); +x_168 = l_Lean_Parser_mergeOrElseErrors(x_167, x_91, x_88); +lean_dec(x_88); +return x_168; +} } } else { -lean_object* x_158; lean_object* x_159; lean_object* x_160; -lean_dec(x_133); +lean_object* x_184; +lean_dec(x_98); lean_dec(x_1); -x_158 = l_Lean_Parser_Term_subtype___elambda__1___closed__2; -x_159 = l_Lean_Parser_ParserState_mkNode(x_132, x_158, x_92); -x_160 = l_Lean_Parser_mergeOrElseErrors(x_159, x_87, x_84); -lean_dec(x_84); -return x_160; -} +x_184 = l_Lean_Parser_mergeOrElseErrors(x_97, x_91, x_88); +lean_dec(x_88); +return x_184; } } } @@ -20084,18 +20885,17 @@ return x_160; lean_object* _init_l_Lean_Parser_Term_subtype___closed__1() { _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_subtype___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_subtype___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_explicitUniv___closed__4; @@ -20160,16 +20960,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_subtype___closed__8() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_subtype___closed__7; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_subtype___closed__9() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_subtype___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_subtype___closed__7; +x_3 = l_Lean_Parser_Term_subtype___closed__8; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_subtype___closed__9() { +lean_object* _init_l_Lean_Parser_Term_subtype___closed__10() { _start: { lean_object* x_1; @@ -20177,12 +20987,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_subtype___elambda__1), 2, 0) return x_1; } } -lean_object* _init_l_Lean_Parser_Term_subtype___closed__10() { +lean_object* _init_l_Lean_Parser_Term_subtype___closed__11() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_subtype___closed__8; -x_2 = l_Lean_Parser_Term_subtype___closed__9; +x_1 = l_Lean_Parser_Term_subtype___closed__9; +x_2 = l_Lean_Parser_Term_subtype___closed__10; x_3 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_3, 0, x_1); lean_ctor_set(x_3, 1, x_2); @@ -20193,7 +21003,7 @@ lean_object* _init_l_Lean_Parser_Term_subtype() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_subtype___closed__10; +x_1 = l_Lean_Parser_Term_subtype___closed__11; return x_1; } } @@ -20528,379 +21338,412 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_40; lean_object* x_41; lean_object* x_42; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_40 = lean_ctor_get(x_2, 1); -lean_inc(x_40); -lean_inc(x_1); -x_41 = l_Lean_Parser_tokenFn(x_1, x_2); -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_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__5; -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_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40); -x_8 = x_49; -goto block_39; -} -else -{ -lean_dec(x_40); -x_8 = x_41; -goto block_39; -} -} -else -{ -lean_object* x_50; lean_object* x_51; -lean_dec(x_44); -x_50 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; -x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40); -x_8 = x_51; -goto block_39; -} -} -else -{ -lean_object* x_52; lean_object* x_53; -lean_dec(x_42); -x_52 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; -x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40); -x_8 = x_53; -goto block_39; -} -block_39: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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) { -uint8_t x_10; lean_object* x_11; lean_object* x_12; -x_10 = 1; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_44; 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_44 = lean_ctor_get(x_8, 1); +lean_inc(x_44); lean_inc(x_1); -x_11 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_10, x_1, x_8); -x_12 = lean_ctor_get(x_11, 3); -lean_inc(x_12); -if (lean_obj_tag(x_12) == 0) +x_45 = l_Lean_Parser_tokenFn(x_1, x_8); +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; -x_13 = lean_ctor_get(x_11, 1); +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_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_structInstArrayRef___elambda__1___closed__5; +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_structInstArrayRef___elambda__1___closed__12; +x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_44); +x_12 = x_53; +goto block_43; +} +else +{ +lean_dec(x_44); +x_12 = x_45; +goto block_43; +} +} +else +{ +lean_object* x_54; lean_object* x_55; +lean_dec(x_48); +x_54 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; +x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_44); +x_12 = x_55; +goto block_43; +} +} +else +{ +lean_object* x_56; lean_object* x_57; +lean_dec(x_46); +x_56 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; +x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_44); +x_12 = x_57; +goto block_43; +} +block_43: +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_12, 3); 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) +if (lean_obj_tag(x_13) == 0) { -lean_object* x_16; lean_object* x_17; -x_16 = lean_ctor_get(x_14, 0); +uint8_t x_14; lean_object* x_15; lean_object* x_16; +x_14 = 1; +lean_inc(x_1); +x_15 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_14, x_1, x_12); +x_16 = lean_ctor_get(x_15, 3); 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) +if (lean_obj_tag(x_16) == 0) { -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_Term_structInstArrayRef___elambda__1___closed__6; -x_20 = lean_string_dec_eq(x_18, x_19); -lean_dec(x_18); -if (x_20 == 0) +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_15, 1); +lean_inc(x_17); +x_18 = l_Lean_Parser_tokenFn(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; -x_21 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_22 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_21, x_13); -x_23 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_7); -return x_24; +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_18, 0); +lean_inc(x_20); +x_21 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_20); +lean_dec(x_20); +if (lean_obj_tag(x_21) == 2) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; +x_22 = lean_ctor_get(x_21, 1); +lean_inc(x_22); +lean_dec(x_21); +x_23 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__6; +x_24 = lean_string_dec_eq(x_22, x_23); +lean_dec(x_22); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_25 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; +x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_25, x_17); +x_27 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; +x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_11); +return x_28; } else { -lean_object* x_25; lean_object* x_26; -lean_dec(x_13); -x_25 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_26 = l_Lean_Parser_ParserState_mkNode(x_14, x_25, x_7); -return x_26; -} -} -else -{ -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_object* x_29; lean_object* x_30; lean_dec(x_17); -x_27 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_27, x_13); x_29 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_7); +x_30 = l_Lean_Parser_ParserState_mkNode(x_18, x_29, x_11); return x_30; } } else { lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_15); +lean_dec(x_21); x_31 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_31, x_13); +x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_31, x_17); x_33 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_7); +x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_11); return x_34; } } else { -lean_object* x_35; lean_object* x_36; -lean_dec(x_12); -lean_dec(x_1); -x_35 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_11, x_35, x_7); -return x_36; -} -} -else -{ -lean_object* x_37; lean_object* x_38; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_19); +x_35 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; +x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_35, x_17); x_37 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkNode(x_8, x_37, x_7); +x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_11); return x_38; } } +else +{ +lean_object* x_39; lean_object* x_40; +lean_dec(x_16); +lean_dec(x_1); +x_39 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; +x_40 = l_Lean_Parser_ParserState_mkNode(x_15, x_39, x_11); +return x_40; +} } else { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_2, 0); -lean_inc(x_54); -x_55 = lean_array_get_size(x_54); -lean_dec(x_54); -x_56 = lean_ctor_get(x_2, 1); -lean_inc(x_56); -lean_inc(x_1); -x_57 = lean_apply_2(x_4, x_1, x_2); -x_58 = lean_ctor_get(x_57, 3); +lean_object* x_41; lean_object* x_42; +lean_dec(x_13); +lean_dec(x_1); +x_41 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkNode(x_12, x_41, x_11); +return x_42; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_58); -if (lean_obj_tag(x_58) == 0) -{ -lean_dec(x_56); -lean_dec(x_55); -lean_dec(x_1); -return x_57; -} -else -{ -lean_object* x_59; lean_object* x_60; uint8_t x_61; -x_59 = lean_ctor_get(x_58, 0); -lean_inc(x_59); +x_59 = lean_array_get_size(x_58); lean_dec(x_58); -x_60 = lean_ctor_get(x_57, 1); +x_60 = lean_ctor_get(x_2, 1); lean_inc(x_60); -x_61 = lean_nat_dec_eq(x_60, x_56); -lean_dec(x_60); -if (x_61 == 0) +lean_inc(x_1); +x_61 = lean_apply_2(x_4, x_1, x_2); +x_62 = lean_ctor_get(x_61, 3); +lean_inc(x_62); +if (lean_obj_tag(x_62) == 0) { +lean_dec(x_60); lean_dec(x_59); -lean_dec(x_56); -lean_dec(x_55); lean_dec(x_1); -return x_57; +return x_61; } else { -lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_103; lean_object* x_104; -lean_inc(x_56); -x_62 = l_Lean_Parser_ParserState_restore(x_57, x_55, x_56); -lean_dec(x_55); +lean_object* x_63; lean_object* x_64; uint8_t x_65; x_63 = lean_ctor_get(x_62, 0); lean_inc(x_63); -x_64 = lean_array_get_size(x_63); +lean_dec(x_62); +x_64 = lean_ctor_get(x_61, 1); +lean_inc(x_64); +x_65 = lean_nat_dec_eq(x_64, x_60); +lean_dec(x_64); +if (x_65 == 0) +{ lean_dec(x_63); +lean_dec(x_60); +lean_dec(x_59); +lean_dec(x_1); +return x_61; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_inc(x_60); +x_66 = l_Lean_Parser_ParserState_restore(x_61, x_59, x_60); +lean_dec(x_59); +x_67 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_68 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_69 = l_Lean_Parser_checkRbpLtFn(x_67, 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_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_71 = lean_ctor_get(x_69, 0); +lean_inc(x_71); +x_72 = lean_array_get_size(x_71); +lean_dec(x_71); +x_111 = lean_ctor_get(x_69, 1); +lean_inc(x_111); lean_inc(x_1); -x_103 = l_Lean_Parser_tokenFn(x_1, x_62); -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; -x_105 = lean_ctor_get(x_103, 0); -lean_inc(x_105); -x_106 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__5; -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_Term_structInstArrayRef___elambda__1___closed__12; -lean_inc(x_56); -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_110, x_56); -x_65 = x_111; -goto block_102; -} -else -{ -x_65 = x_103; -goto block_102; -} -} -else -{ -lean_object* x_112; lean_object* x_113; -lean_dec(x_106); -x_112 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; -lean_inc(x_56); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_112, x_56); -x_65 = x_113; -goto block_102; -} -} -else +x_112 = l_Lean_Parser_tokenFn(x_1, x_69); +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_dec(x_104); -x_114 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; -lean_inc(x_56); -x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_114, x_56); -x_65 = x_115; -goto block_102; +x_114 = lean_ctor_get(x_112, 0); +lean_inc(x_114); +x_115 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_114); +lean_dec(x_114); +if (lean_obj_tag(x_115) == 2) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +lean_dec(x_115); +x_117 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__5; +x_118 = lean_string_dec_eq(x_116, x_117); +lean_dec(x_116); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; +x_119 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; +x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_119, x_111); +x_73 = x_120; +goto block_110; } -block_102: +else { -lean_object* x_66; -x_66 = lean_ctor_get(x_65, 3); -lean_inc(x_66); -if (lean_obj_tag(x_66) == 0) +lean_dec(x_111); +x_73 = x_112; +goto block_110; +} +} +else { -uint8_t x_67; lean_object* x_68; lean_object* x_69; -x_67 = 1; +lean_object* x_121; lean_object* x_122; +lean_dec(x_115); +x_121 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_121, x_111); +x_73 = x_122; +goto block_110; +} +} +else +{ +lean_object* x_123; lean_object* x_124; +lean_dec(x_113); +x_123 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__12; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_123, x_111); +x_73 = x_124; +goto block_110; +} +block_110: +{ +lean_object* x_74; +x_74 = lean_ctor_get(x_73, 3); +lean_inc(x_74); +if (lean_obj_tag(x_74) == 0) +{ +uint8_t x_75; lean_object* x_76; lean_object* x_77; +x_75 = 1; lean_inc(x_1); -x_68 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_67, x_1, x_65); -x_69 = lean_ctor_get(x_68, 3); -lean_inc(x_69); -if (lean_obj_tag(x_69) == 0) +x_76 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_75, x_1, x_73); +x_77 = lean_ctor_get(x_76, 3); +lean_inc(x_77); +if (lean_obj_tag(x_77) == 0) { -lean_object* x_70; lean_object* x_71; lean_object* x_72; -x_70 = lean_ctor_get(x_68, 1); -lean_inc(x_70); -x_71 = l_Lean_Parser_tokenFn(x_1, x_68); -x_72 = lean_ctor_get(x_71, 3); -lean_inc(x_72); -if (lean_obj_tag(x_72) == 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); +x_79 = l_Lean_Parser_tokenFn(x_1, x_76); +x_80 = lean_ctor_get(x_79, 3); +lean_inc(x_80); +if (lean_obj_tag(x_80) == 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_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_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_structInstArrayRef___elambda__1___closed__6; -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_structInstArrayRef___elambda__1___closed__9; -x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_78, x_70); -x_80 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_81 = l_Lean_Parser_ParserState_mkNode(x_79, x_80, x_64); -x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_59, x_56); -lean_dec(x_56); -return x_82; -} -else -{ -lean_object* x_83; lean_object* x_84; lean_object* x_85; -lean_dec(x_70); -x_83 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_84 = l_Lean_Parser_ParserState_mkNode(x_71, x_83, x_64); -x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_59, x_56); -lean_dec(x_56); -return x_85; -} -} -else +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_structInstArrayRef___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; lean_object* x_88; lean_object* x_89; lean_object* x_90; -lean_dec(x_74); x_86 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_86, x_70); +x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_78); x_88 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_64); -x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_59, x_56); -lean_dec(x_56); +x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_72); +x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_63, x_60); +lean_dec(x_60); 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_72); -x_91 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_92 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_91, x_70); -x_93 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_94 = l_Lean_Parser_ParserState_mkNode(x_92, x_93, x_64); -x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_59, x_56); -lean_dec(x_56); -return x_95; +lean_object* x_91; lean_object* x_92; lean_object* x_93; +lean_dec(x_78); +x_91 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; +x_92 = l_Lean_Parser_ParserState_mkNode(x_79, x_91, x_72); +x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_63, x_60); +lean_dec(x_60); +return x_93; } } else { -lean_object* x_96; lean_object* x_97; lean_object* x_98; -lean_dec(x_69); -lean_dec(x_1); +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_Term_structInstArrayRef___elambda__1___closed__9; +x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_94, x_78); x_96 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_97 = l_Lean_Parser_ParserState_mkNode(x_68, x_96, x_64); -x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_59, x_56); -lean_dec(x_56); +x_97 = l_Lean_Parser_ParserState_mkNode(x_95, x_96, x_72); +x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_63, x_60); +lean_dec(x_60); return x_98; } } else { -lean_object* x_99; lean_object* x_100; lean_object* x_101; -lean_dec(x_66); -lean_dec(x_1); -x_99 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; -x_100 = l_Lean_Parser_ParserState_mkNode(x_65, x_99, x_64); -x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_59, x_56); -lean_dec(x_56); -return x_101; +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_Term_structInstArrayRef___elambda__1___closed__9; +x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_99, x_78); +x_101 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; +x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_72); +x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_63, x_60); +lean_dec(x_60); +return x_103; } } +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +lean_dec(x_77); +lean_dec(x_1); +x_104 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; +x_105 = l_Lean_Parser_ParserState_mkNode(x_76, x_104, x_72); +x_106 = l_Lean_Parser_mergeOrElseErrors(x_105, x_63, x_60); +lean_dec(x_60); +return x_106; +} +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; +lean_dec(x_74); +lean_dec(x_1); +x_107 = l_Lean_Parser_Term_listLit___elambda__1___closed__2; +x_108 = l_Lean_Parser_ParserState_mkNode(x_73, x_107, x_72); +x_109 = l_Lean_Parser_mergeOrElseErrors(x_108, x_63, x_60); +lean_dec(x_60); +return x_109; +} +} +} +else +{ +lean_object* x_125; +lean_dec(x_70); +lean_dec(x_1); +x_125 = l_Lean_Parser_mergeOrElseErrors(x_69, x_63, x_60); +lean_dec(x_60); +return x_125; +} } } } @@ -20909,18 +21752,17 @@ return x_101; lean_object* _init_l_Lean_Parser_Term_listLit___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; +lean_object* x_1; lean_object* x_2; x_1 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_listLit___elambda__1___spec__2___closed__1; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_listLit___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_listLit___closed__1; @@ -20961,16 +21803,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_listLit___closed__6() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_listLit___closed__5; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_listLit___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_listLit___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_listLit___closed__5; +x_3 = l_Lean_Parser_Term_listLit___closed__6; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_listLit___closed__7() { +lean_object* _init_l_Lean_Parser_Term_listLit___closed__8() { _start: { lean_object* x_1; @@ -20978,12 +21830,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_listLit___elambda__1), 2, 0) return x_1; } } -lean_object* _init_l_Lean_Parser_Term_listLit___closed__8() { +lean_object* _init_l_Lean_Parser_Term_listLit___closed__9() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_listLit___closed__6; -x_2 = l_Lean_Parser_Term_listLit___closed__7; +x_1 = l_Lean_Parser_Term_listLit___closed__7; +x_2 = l_Lean_Parser_Term_listLit___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); @@ -20994,7 +21846,7 @@ lean_object* _init_l_Lean_Parser_Term_listLit() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_listLit___closed__8; +x_1 = l_Lean_Parser_Term_listLit___closed__9; return x_1; } } @@ -21126,379 +21978,412 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_40; lean_object* x_41; lean_object* x_42; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_40 = lean_ctor_get(x_2, 1); -lean_inc(x_40); -lean_inc(x_1); -x_41 = l_Lean_Parser_tokenFn(x_1, x_2); -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_Lean_Parser_Term_arrayLit___elambda__1___closed__5; -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_Lean_Parser_Term_arrayLit___elambda__1___closed__8; -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40); -x_8 = x_49; -goto block_39; -} -else -{ -lean_dec(x_40); -x_8 = x_41; -goto block_39; -} -} -else -{ -lean_object* x_50; lean_object* x_51; -lean_dec(x_44); -x_50 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8; -x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40); -x_8 = x_51; -goto block_39; -} -} -else -{ -lean_object* x_52; lean_object* x_53; -lean_dec(x_42); -x_52 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8; -x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40); -x_8 = x_53; -goto block_39; -} -block_39: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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) { -uint8_t x_10; lean_object* x_11; lean_object* x_12; -x_10 = 1; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_44; 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_44 = lean_ctor_get(x_8, 1); +lean_inc(x_44); lean_inc(x_1); -x_11 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_10, x_1, x_8); -x_12 = lean_ctor_get(x_11, 3); -lean_inc(x_12); -if (lean_obj_tag(x_12) == 0) +x_45 = l_Lean_Parser_tokenFn(x_1, x_8); +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; -x_13 = lean_ctor_get(x_11, 1); +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_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_arrayLit___elambda__1___closed__5; +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_arrayLit___elambda__1___closed__8; +x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_44); +x_12 = x_53; +goto block_43; +} +else +{ +lean_dec(x_44); +x_12 = x_45; +goto block_43; +} +} +else +{ +lean_object* x_54; lean_object* x_55; +lean_dec(x_48); +x_54 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8; +x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_44); +x_12 = x_55; +goto block_43; +} +} +else +{ +lean_object* x_56; lean_object* x_57; +lean_dec(x_46); +x_56 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8; +x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_44); +x_12 = x_57; +goto block_43; +} +block_43: +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_12, 3); 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) +if (lean_obj_tag(x_13) == 0) { -lean_object* x_16; lean_object* x_17; -x_16 = lean_ctor_get(x_14, 0); +uint8_t x_14; lean_object* x_15; lean_object* x_16; +x_14 = 1; +lean_inc(x_1); +x_15 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_14, x_1, x_12); +x_16 = lean_ctor_get(x_15, 3); 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) +if (lean_obj_tag(x_16) == 0) { -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_Term_structInstArrayRef___elambda__1___closed__6; -x_20 = lean_string_dec_eq(x_18, x_19); -lean_dec(x_18); -if (x_20 == 0) +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_15, 1); +lean_inc(x_17); +x_18 = l_Lean_Parser_tokenFn(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; -x_21 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_22 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_21, x_13); -x_23 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_7); -return x_24; +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_18, 0); +lean_inc(x_20); +x_21 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_20); +lean_dec(x_20); +if (lean_obj_tag(x_21) == 2) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; +x_22 = lean_ctor_get(x_21, 1); +lean_inc(x_22); +lean_dec(x_21); +x_23 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__6; +x_24 = lean_string_dec_eq(x_22, x_23); +lean_dec(x_22); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_25 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; +x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_25, x_17); +x_27 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; +x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_11); +return x_28; } else { -lean_object* x_25; lean_object* x_26; -lean_dec(x_13); -x_25 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_26 = l_Lean_Parser_ParserState_mkNode(x_14, x_25, x_7); -return x_26; -} -} -else -{ -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_object* x_29; lean_object* x_30; lean_dec(x_17); -x_27 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_27, x_13); x_29 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_7); +x_30 = l_Lean_Parser_ParserState_mkNode(x_18, x_29, x_11); return x_30; } } else { lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_15); +lean_dec(x_21); x_31 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_31, x_13); +x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_31, x_17); x_33 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_7); +x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_11); return x_34; } } else { -lean_object* x_35; lean_object* x_36; -lean_dec(x_12); -lean_dec(x_1); -x_35 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_11, x_35, x_7); -return x_36; -} -} -else -{ -lean_object* x_37; lean_object* x_38; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_19); +x_35 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; +x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_35, x_17); x_37 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkNode(x_8, x_37, x_7); +x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_11); return x_38; } } +else +{ +lean_object* x_39; lean_object* x_40; +lean_dec(x_16); +lean_dec(x_1); +x_39 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; +x_40 = l_Lean_Parser_ParserState_mkNode(x_15, x_39, x_11); +return x_40; +} } else { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_2, 0); -lean_inc(x_54); -x_55 = lean_array_get_size(x_54); -lean_dec(x_54); -x_56 = lean_ctor_get(x_2, 1); -lean_inc(x_56); -lean_inc(x_1); -x_57 = lean_apply_2(x_4, x_1, x_2); -x_58 = lean_ctor_get(x_57, 3); +lean_object* x_41; lean_object* x_42; +lean_dec(x_13); +lean_dec(x_1); +x_41 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkNode(x_12, x_41, x_11); +return x_42; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_58); -if (lean_obj_tag(x_58) == 0) -{ -lean_dec(x_56); -lean_dec(x_55); -lean_dec(x_1); -return x_57; -} -else -{ -lean_object* x_59; lean_object* x_60; uint8_t x_61; -x_59 = lean_ctor_get(x_58, 0); -lean_inc(x_59); +x_59 = lean_array_get_size(x_58); lean_dec(x_58); -x_60 = lean_ctor_get(x_57, 1); +x_60 = lean_ctor_get(x_2, 1); lean_inc(x_60); -x_61 = lean_nat_dec_eq(x_60, x_56); -lean_dec(x_60); -if (x_61 == 0) +lean_inc(x_1); +x_61 = lean_apply_2(x_4, x_1, x_2); +x_62 = lean_ctor_get(x_61, 3); +lean_inc(x_62); +if (lean_obj_tag(x_62) == 0) { +lean_dec(x_60); lean_dec(x_59); -lean_dec(x_56); -lean_dec(x_55); lean_dec(x_1); -return x_57; +return x_61; } else { -lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_103; lean_object* x_104; -lean_inc(x_56); -x_62 = l_Lean_Parser_ParserState_restore(x_57, x_55, x_56); -lean_dec(x_55); +lean_object* x_63; lean_object* x_64; uint8_t x_65; x_63 = lean_ctor_get(x_62, 0); lean_inc(x_63); -x_64 = lean_array_get_size(x_63); +lean_dec(x_62); +x_64 = lean_ctor_get(x_61, 1); +lean_inc(x_64); +x_65 = lean_nat_dec_eq(x_64, x_60); +lean_dec(x_64); +if (x_65 == 0) +{ lean_dec(x_63); +lean_dec(x_60); +lean_dec(x_59); +lean_dec(x_1); +return x_61; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_inc(x_60); +x_66 = l_Lean_Parser_ParserState_restore(x_61, x_59, x_60); +lean_dec(x_59); +x_67 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_68 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_69 = l_Lean_Parser_checkRbpLtFn(x_67, 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_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_71 = lean_ctor_get(x_69, 0); +lean_inc(x_71); +x_72 = lean_array_get_size(x_71); +lean_dec(x_71); +x_111 = lean_ctor_get(x_69, 1); +lean_inc(x_111); lean_inc(x_1); -x_103 = l_Lean_Parser_tokenFn(x_1, x_62); -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; -x_105 = lean_ctor_get(x_103, 0); -lean_inc(x_105); -x_106 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_Lean_Parser_Term_arrayLit___elambda__1___closed__5; -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_Term_arrayLit___elambda__1___closed__8; -lean_inc(x_56); -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_110, x_56); -x_65 = x_111; -goto block_102; -} -else -{ -x_65 = x_103; -goto block_102; -} -} -else -{ -lean_object* x_112; lean_object* x_113; -lean_dec(x_106); -x_112 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8; -lean_inc(x_56); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_112, x_56); -x_65 = x_113; -goto block_102; -} -} -else +x_112 = l_Lean_Parser_tokenFn(x_1, x_69); +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_dec(x_104); -x_114 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8; -lean_inc(x_56); -x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_114, x_56); -x_65 = x_115; -goto block_102; +x_114 = lean_ctor_get(x_112, 0); +lean_inc(x_114); +x_115 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_114); +lean_dec(x_114); +if (lean_obj_tag(x_115) == 2) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +lean_dec(x_115); +x_117 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__5; +x_118 = lean_string_dec_eq(x_116, x_117); +lean_dec(x_116); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; +x_119 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8; +x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_119, x_111); +x_73 = x_120; +goto block_110; } -block_102: +else { -lean_object* x_66; -x_66 = lean_ctor_get(x_65, 3); -lean_inc(x_66); -if (lean_obj_tag(x_66) == 0) +lean_dec(x_111); +x_73 = x_112; +goto block_110; +} +} +else { -uint8_t x_67; lean_object* x_68; lean_object* x_69; -x_67 = 1; +lean_object* x_121; lean_object* x_122; +lean_dec(x_115); +x_121 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_121, x_111); +x_73 = x_122; +goto block_110; +} +} +else +{ +lean_object* x_123; lean_object* x_124; +lean_dec(x_113); +x_123 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__8; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_123, x_111); +x_73 = x_124; +goto block_110; +} +block_110: +{ +lean_object* x_74; +x_74 = lean_ctor_get(x_73, 3); +lean_inc(x_74); +if (lean_obj_tag(x_74) == 0) +{ +uint8_t x_75; lean_object* x_76; lean_object* x_77; +x_75 = 1; lean_inc(x_1); -x_68 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_67, x_1, x_65); -x_69 = lean_ctor_get(x_68, 3); -lean_inc(x_69); -if (lean_obj_tag(x_69) == 0) +x_76 = l_Lean_Parser_sepByFn___at_Lean_Parser_Term_listLit___elambda__1___spec__1(x_75, x_1, x_73); +x_77 = lean_ctor_get(x_76, 3); +lean_inc(x_77); +if (lean_obj_tag(x_77) == 0) { -lean_object* x_70; lean_object* x_71; lean_object* x_72; -x_70 = lean_ctor_get(x_68, 1); -lean_inc(x_70); -x_71 = l_Lean_Parser_tokenFn(x_1, x_68); -x_72 = lean_ctor_get(x_71, 3); -lean_inc(x_72); -if (lean_obj_tag(x_72) == 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); +x_79 = l_Lean_Parser_tokenFn(x_1, x_76); +x_80 = lean_ctor_get(x_79, 3); +lean_inc(x_80); +if (lean_obj_tag(x_80) == 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_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_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_structInstArrayRef___elambda__1___closed__6; -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_structInstArrayRef___elambda__1___closed__9; -x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_78, x_70); -x_80 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_81 = l_Lean_Parser_ParserState_mkNode(x_79, x_80, x_64); -x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_59, x_56); -lean_dec(x_56); -return x_82; -} -else -{ -lean_object* x_83; lean_object* x_84; lean_object* x_85; -lean_dec(x_70); -x_83 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_84 = l_Lean_Parser_ParserState_mkNode(x_71, x_83, x_64); -x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_59, x_56); -lean_dec(x_56); -return x_85; -} -} -else +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_structInstArrayRef___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; lean_object* x_88; lean_object* x_89; lean_object* x_90; -lean_dec(x_74); x_86 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_86, x_70); +x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_78); x_88 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_64); -x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_59, x_56); -lean_dec(x_56); +x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_72); +x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_63, x_60); +lean_dec(x_60); 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_72); -x_91 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_92 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_91, x_70); -x_93 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_94 = l_Lean_Parser_ParserState_mkNode(x_92, x_93, x_64); -x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_59, x_56); -lean_dec(x_56); -return x_95; +lean_object* x_91; lean_object* x_92; lean_object* x_93; +lean_dec(x_78); +x_91 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; +x_92 = l_Lean_Parser_ParserState_mkNode(x_79, x_91, x_72); +x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_63, x_60); +lean_dec(x_60); +return x_93; } } else { -lean_object* x_96; lean_object* x_97; lean_object* x_98; -lean_dec(x_69); -lean_dec(x_1); +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_Term_structInstArrayRef___elambda__1___closed__9; +x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_94, x_78); x_96 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_97 = l_Lean_Parser_ParserState_mkNode(x_68, x_96, x_64); -x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_59, x_56); -lean_dec(x_56); +x_97 = l_Lean_Parser_ParserState_mkNode(x_95, x_96, x_72); +x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_63, x_60); +lean_dec(x_60); return x_98; } } else { -lean_object* x_99; lean_object* x_100; lean_object* x_101; -lean_dec(x_66); -lean_dec(x_1); -x_99 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; -x_100 = l_Lean_Parser_ParserState_mkNode(x_65, x_99, x_64); -x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_59, x_56); -lean_dec(x_56); -return x_101; +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_Term_structInstArrayRef___elambda__1___closed__9; +x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_99, x_78); +x_101 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; +x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_72); +x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_63, x_60); +lean_dec(x_60); +return x_103; } } +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +lean_dec(x_77); +lean_dec(x_1); +x_104 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; +x_105 = l_Lean_Parser_ParserState_mkNode(x_76, x_104, x_72); +x_106 = l_Lean_Parser_mergeOrElseErrors(x_105, x_63, x_60); +lean_dec(x_60); +return x_106; +} +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; +lean_dec(x_74); +lean_dec(x_1); +x_107 = l_Lean_Parser_Term_arrayLit___elambda__1___closed__2; +x_108 = l_Lean_Parser_ParserState_mkNode(x_73, x_107, x_72); +x_109 = l_Lean_Parser_mergeOrElseErrors(x_108, x_63, x_60); +lean_dec(x_60); +return x_109; +} +} +} +else +{ +lean_object* x_125; +lean_dec(x_70); +lean_dec(x_1); +x_125 = l_Lean_Parser_mergeOrElseErrors(x_69, x_63, x_60); +lean_dec(x_60); +return x_125; +} } } } @@ -21507,11 +22392,10 @@ return x_101; lean_object* _init_l_Lean_Parser_Term_arrayLit___closed__1() { _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_arrayLit___elambda__1___closed__5; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_arrayLit___closed__2() { @@ -21537,16 +22421,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_arrayLit___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_arrayLit___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_arrayLit___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_arrayLit___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_arrayLit___closed__3; +x_3 = l_Lean_Parser_Term_arrayLit___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_arrayLit___closed__5() { +lean_object* _init_l_Lean_Parser_Term_arrayLit___closed__6() { _start: { lean_object* x_1; @@ -21554,12 +22448,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_arrayLit___elambda__1), 2, 0 return x_1; } } -lean_object* _init_l_Lean_Parser_Term_arrayLit___closed__6() { +lean_object* _init_l_Lean_Parser_Term_arrayLit___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_arrayLit___closed__4; -x_2 = l_Lean_Parser_Term_arrayLit___closed__5; +x_1 = l_Lean_Parser_Term_arrayLit___closed__5; +x_2 = l_Lean_Parser_Term_arrayLit___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); @@ -21570,7 +22464,7 @@ lean_object* _init_l_Lean_Parser_Term_arrayLit() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_arrayLit___closed__6; +x_1 = l_Lean_Parser_Term_arrayLit___closed__7; return x_1; } } @@ -21637,227 +22531,260 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_18 = lean_ctor_get(x_2, 1); -lean_inc(x_18); -lean_inc(x_1); -x_19 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_21 = lean_ctor_get(x_19, 0); -lean_inc(x_21); -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); -lean_dec(x_22); -x_24 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__6; -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; -x_26 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); -x_8 = x_27; -goto block_17; -} -else -{ -lean_dec(x_18); -x_8 = x_19; -goto block_17; -} -} -else -{ -lean_object* x_28; lean_object* x_29; -lean_dec(x_22); -x_28 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_28, x_18); -x_8 = x_29; -goto block_17; -} -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_dec(x_20); -x_30 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); -x_8 = x_31; -goto block_17; -} -block_17: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = l_Lean_Parser_appPrec; -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); -x_13 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7); -return x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_22; lean_object* x_23; lean_object* x_24; +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_22 = lean_ctor_get(x_8, 1); +lean_inc(x_22); +lean_inc(x_1); +x_23 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_25 = lean_ctor_get(x_23, 0); +lean_inc(x_25); +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); +lean_dec(x_26); +x_28 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__6; +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; +x_30 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); +x_12 = x_31; +goto block_21; +} +else +{ +lean_dec(x_22); +x_12 = x_23; +goto block_21; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_26); +x_32 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22); +x_12 = x_33; +goto block_21; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_24); +x_34 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22); +x_12 = x_35; +goto block_21; +} +block_21: +{ +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_18; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = l_Lean_Parser_appPrec; +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_11); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_12, x_19, x_11); +return x_20; +} +} } else { -lean_object* x_15; lean_object* x_16; lean_dec(x_9); lean_dec(x_1); -x_15 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_8, x_15, x_7); -return x_16; -} +return x_8; } } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_32 = lean_ctor_get(x_2, 0); -lean_inc(x_32); -x_33 = lean_array_get_size(x_32); -lean_dec(x_32); -x_34 = lean_ctor_get(x_2, 1); -lean_inc(x_34); -lean_inc(x_1); -x_35 = lean_apply_2(x_4, x_1, x_2); -x_36 = lean_ctor_get(x_35, 3); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_2, 0); lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) -{ -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_1); -return x_35; -} -else -{ -lean_object* x_37; lean_object* x_38; uint8_t x_39; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); +x_37 = lean_array_get_size(x_36); lean_dec(x_36); -x_38 = lean_ctor_get(x_35, 1); +x_38 = lean_ctor_get(x_2, 1); lean_inc(x_38); -x_39 = lean_nat_dec_eq(x_38, x_34); -lean_dec(x_38); -if (x_39 == 0) +lean_inc(x_1); +x_39 = lean_apply_2(x_4, x_1, x_2); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { +lean_dec(x_38); lean_dec(x_37); -lean_dec(x_34); -lean_dec(x_33); lean_dec(x_1); -return x_35; +return x_39; } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_55; lean_object* x_56; -lean_inc(x_34); -x_40 = l_Lean_Parser_ParserState_restore(x_35, x_33, x_34); -lean_dec(x_33); +lean_object* x_41; lean_object* x_42; uint8_t x_43; x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -x_42 = lean_array_get_size(x_41); +lean_dec(x_40); +x_42 = lean_ctor_get(x_39, 1); +lean_inc(x_42); +x_43 = lean_nat_dec_eq(x_42, x_38); +lean_dec(x_42); +if (x_43 == 0) +{ lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_37); +lean_dec(x_1); +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_inc(x_38); +x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); +lean_dec(x_37); +x_45 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_46 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_47 = l_Lean_Parser_checkRbpLtFn(x_45, x_46, x_1, x_44); +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_63; lean_object* x_64; lean_object* x_65; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +x_63 = lean_ctor_get(x_47, 1); +lean_inc(x_63); lean_inc(x_1); -x_55 = l_Lean_Parser_tokenFn(x_1, x_40); -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_namedPattern___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_namedPattern___elambda__1___closed__10; -lean_inc(x_34); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_34); -x_43 = x_63; -goto block_54; -} -else -{ -x_43 = x_55; -goto block_54; -} -} -else -{ -lean_object* x_64; lean_object* x_65; -lean_dec(x_58); -x_64 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; -lean_inc(x_34); -x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_34); -x_43 = x_65; -goto block_54; -} -} -else +x_64 = l_Lean_Parser_tokenFn(x_1, x_47); +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_dec(x_56); -x_66 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; -lean_inc(x_34); -x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_34); -x_43 = x_67; -goto block_54; -} -block_54: +x_66 = lean_ctor_get(x_64, 0); +lean_inc(x_66); +x_67 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_66); +lean_dec(x_66); +if (lean_obj_tag(x_67) == 2) { -lean_object* x_44; -x_44 = lean_ctor_get(x_43, 3); -lean_inc(x_44); -if (lean_obj_tag(x_44) == 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_namedPattern___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_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 = l_Lean_Parser_appPrec; -x_47 = l_Lean_Parser_categoryParser___elambda__1(x_45, x_46, x_1, x_43); -x_48 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; -x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_42); -x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_37, x_34); -lean_dec(x_34); -return x_50; +lean_object* x_71; lean_object* x_72; +x_71 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_63); +x_51 = x_72; +goto block_62; } 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_Term_explicit___elambda__1___closed__2; -x_52 = l_Lean_Parser_ParserState_mkNode(x_43, x_51, x_42); -x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_37, x_34); -lean_dec(x_34); -return x_53; +lean_dec(x_63); +x_51 = x_64; +goto block_62; } } +else +{ +lean_object* x_73; lean_object* x_74; +lean_dec(x_67); +x_73 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; +x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_63); +x_51 = x_74; +goto block_62; +} +} +else +{ +lean_object* x_75; lean_object* x_76; +lean_dec(x_65); +x_75 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__10; +x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_63); +x_51 = x_76; +goto block_62; +} +block_62: +{ +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; lean_object* x_57; lean_object* x_58; +x_53 = l_Lean_Parser_termParser___closed__2; +x_54 = l_Lean_Parser_appPrec; +x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_51); +x_56 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; +x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_50); +x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_41, x_38); +lean_dec(x_38); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_dec(x_52); +lean_dec(x_1); +x_59 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_51, x_59, x_50); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_41, x_38); +lean_dec(x_38); +return x_61; +} +} +} +else +{ +lean_object* x_77; +lean_dec(x_48); +lean_dec(x_1); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_47, x_41, x_38); +lean_dec(x_38); +return x_77; +} } } } @@ -21876,16 +22803,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_explicit___closed__2() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_explicit___closed__1; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_explicit___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_explicit___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_explicit___closed__1; +x_3 = l_Lean_Parser_Term_explicit___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_explicit___closed__3() { +lean_object* _init_l_Lean_Parser_Term_explicit___closed__4() { _start: { lean_object* x_1; @@ -21893,12 +22830,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_explicit___elambda__1), 2, 0 return x_1; } } -lean_object* _init_l_Lean_Parser_Term_explicit___closed__4() { +lean_object* _init_l_Lean_Parser_Term_explicit___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_explicit___closed__2; -x_2 = l_Lean_Parser_Term_explicit___closed__3; +x_1 = l_Lean_Parser_Term_explicit___closed__3; +x_2 = l_Lean_Parser_Term_explicit___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); @@ -21909,7 +22846,7 @@ lean_object* _init_l_Lean_Parser_Term_explicit() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_explicit___closed__4; +x_1 = l_Lean_Parser_Term_explicit___closed__5; return x_1; } } @@ -22025,381 +22962,414 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_41 = lean_ctor_get(x_2, 1); -lean_inc(x_41); -lean_inc(x_1); -x_42 = l_Lean_Parser_tokenFn(x_1, x_2); -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_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); -lean_dec(x_45); -x_47 = l_Lean_Parser_Term_inaccessible___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_49; lean_object* x_50; -x_49 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; -x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_49, x_41); -x_8 = x_50; -goto block_40; -} -else -{ -lean_dec(x_41); -x_8 = x_42; -goto block_40; -} -} -else -{ -lean_object* x_51; lean_object* x_52; -lean_dec(x_45); -x_51 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; -x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_51, x_41); -x_8 = x_52; -goto block_40; -} -} -else -{ -lean_object* x_53; lean_object* x_54; -lean_dec(x_43); -x_53 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; -x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_53, x_41); -x_8 = x_54; -goto block_40; -} -block_40: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(0u); +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_45; lean_object* x_46; lean_object* x_47; +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_45 = lean_ctor_get(x_8, 1); +lean_inc(x_45); lean_inc(x_1); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); +x_46 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +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); +lean_dec(x_49); +x_51 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__6; +x_52 = lean_string_dec_eq(x_50, x_51); +lean_dec(x_50); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; +x_53 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; +x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_46, x_53, x_45); +x_12 = x_54; +goto block_44; +} +else +{ +lean_dec(x_45); +x_12 = x_46; +goto block_44; +} +} +else +{ +lean_object* x_55; lean_object* x_56; +lean_dec(x_49); +x_55 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; +x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_46, x_55, x_45); +x_12 = x_56; +goto block_44; +} +} +else +{ +lean_object* x_57; lean_object* x_58; +lean_dec(x_47); +x_57 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; +x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_46, x_57, x_45); +x_12 = x_58; +goto block_44; +} +block_44: +{ +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; -x_14 = lean_ctor_get(x_12, 1); -lean_inc(x_14); -x_15 = l_Lean_Parser_tokenFn(x_1, 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_object* x_18; -x_17 = lean_ctor_get(x_15, 0); +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = lean_ctor_get(x_16, 3); 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) +if (lean_obj_tag(x_17) == 0) { -lean_object* x_19; lean_object* x_20; uint8_t x_21; -x_19 = lean_ctor_get(x_18, 1); -lean_inc(x_19); -lean_dec(x_18); -x_20 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -x_21 = lean_string_dec_eq(x_19, x_20); -lean_dec(x_19); -if (x_21 == 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_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; -x_22 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); -x_24 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_7); -return x_25; +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_19, 0); +lean_inc(x_21); +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); +lean_dec(x_22); +x_24 = l_Lean_Parser_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; +x_26 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); +x_28 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_11); +return x_29; } else { -lean_object* x_26; lean_object* x_27; -lean_dec(x_14); -x_26 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_27 = l_Lean_Parser_ParserState_mkNode(x_15, x_26, 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_30; lean_object* x_31; lean_dec(x_18); -x_28 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_28, x_14); x_30 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_7); +x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_11); return x_31; } } else { lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; -lean_dec(x_16); +lean_dec(x_22); x_32 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_32, x_14); +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_32, x_18); x_34 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_7); +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_11); return x_35; } } else { -lean_object* x_36; lean_object* x_37; -lean_dec(x_13); -lean_dec(x_1); -x_36 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_37 = l_Lean_Parser_ParserState_mkNode(x_12, x_36, x_7); -return x_37; -} -} -else -{ -lean_object* x_38; lean_object* x_39; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +lean_dec(x_20); +x_36 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_36, x_18); x_38 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_39 = l_Lean_Parser_ParserState_mkNode(x_8, x_38, x_7); +x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_11); return x_39; } } +else +{ +lean_object* x_40; lean_object* x_41; +lean_dec(x_17); +lean_dec(x_1); +x_40 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_41 = l_Lean_Parser_ParserState_mkNode(x_16, x_40, x_11); +return x_41; +} } else { -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_2, 0); -lean_inc(x_55); -x_56 = lean_array_get_size(x_55); -lean_dec(x_55); -x_57 = lean_ctor_get(x_2, 1); -lean_inc(x_57); -lean_inc(x_1); -x_58 = lean_apply_2(x_4, x_1, x_2); -x_59 = lean_ctor_get(x_58, 3); +lean_object* x_42; lean_object* x_43; +lean_dec(x_13); +lean_dec(x_1); +x_42 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_43 = l_Lean_Parser_ParserState_mkNode(x_12, x_42, x_11); +return x_43; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_59); -if (lean_obj_tag(x_59) == 0) -{ -lean_dec(x_57); -lean_dec(x_56); -lean_dec(x_1); -return x_58; -} -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); +x_60 = lean_array_get_size(x_59); lean_dec(x_59); -x_61 = lean_ctor_get(x_58, 1); +x_61 = lean_ctor_get(x_2, 1); lean_inc(x_61); -x_62 = lean_nat_dec_eq(x_61, x_57); -lean_dec(x_61); -if (x_62 == 0) +lean_inc(x_1); +x_62 = lean_apply_2(x_4, x_1, x_2); +x_63 = lean_ctor_get(x_62, 3); +lean_inc(x_63); +if (lean_obj_tag(x_63) == 0) { +lean_dec(x_61); lean_dec(x_60); -lean_dec(x_57); -lean_dec(x_56); lean_dec(x_1); -return x_58; +return x_62; } else { -lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_105; lean_object* x_106; -lean_inc(x_57); -x_63 = l_Lean_Parser_ParserState_restore(x_58, x_56, x_57); -lean_dec(x_56); +lean_object* x_64; lean_object* x_65; uint8_t x_66; x_64 = lean_ctor_get(x_63, 0); lean_inc(x_64); -x_65 = lean_array_get_size(x_64); +lean_dec(x_63); +x_65 = lean_ctor_get(x_62, 1); +lean_inc(x_65); +x_66 = lean_nat_dec_eq(x_65, x_61); +lean_dec(x_65); +if (x_66 == 0) +{ lean_dec(x_64); -lean_inc(x_1); -x_105 = l_Lean_Parser_tokenFn(x_1, x_63); -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; -x_107 = lean_ctor_get(x_105, 0); -lean_inc(x_107); -x_108 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_107); -lean_dec(x_107); -if (lean_obj_tag(x_108) == 2) -{ -lean_object* x_109; lean_object* x_110; uint8_t x_111; -x_109 = lean_ctor_get(x_108, 1); -lean_inc(x_109); -lean_dec(x_108); -x_110 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__6; -x_111 = lean_string_dec_eq(x_109, x_110); -lean_dec(x_109); -if (x_111 == 0) -{ -lean_object* x_112; lean_object* x_113; -x_112 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; -lean_inc(x_57); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_105, x_112, x_57); -x_66 = x_113; -goto block_104; +lean_dec(x_61); +lean_dec(x_60); +lean_dec(x_1); +return x_62; } else { -x_66 = x_105; -goto block_104; -} -} -else -{ -lean_object* x_114; lean_object* x_115; -lean_dec(x_108); -x_114 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; -lean_inc(x_57); -x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_105, x_114, x_57); -x_66 = x_115; -goto block_104; -} -} -else -{ -lean_object* x_116; lean_object* x_117; -lean_dec(x_106); -x_116 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; -lean_inc(x_57); -x_117 = l_Lean_Parser_ParserState_mkErrorsAt(x_105, x_116, x_57); -x_66 = x_117; -goto block_104; -} -block_104: -{ -lean_object* x_67; -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; lean_object* x_70; lean_object* x_71; -x_68 = l_Lean_Parser_termParser___closed__2; -x_69 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_70 = l_Lean_Parser_categoryParser___elambda__1(x_68, x_69, x_1, x_66); +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_inc(x_61); +x_67 = l_Lean_Parser_ParserState_restore(x_62, x_60, x_61); +lean_dec(x_60); +x_68 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_69 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_70 = l_Lean_Parser_checkRbpLtFn(x_68, x_69, x_1, 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; -x_72 = lean_ctor_get(x_70, 1); +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_72 = lean_ctor_get(x_70, 0); lean_inc(x_72); -x_73 = l_Lean_Parser_tokenFn(x_1, x_70); -x_74 = lean_ctor_get(x_73, 3); -lean_inc(x_74); -if (lean_obj_tag(x_74) == 0) -{ -lean_object* x_75; lean_object* x_76; -x_75 = lean_ctor_get(x_73, 0); -lean_inc(x_75); -x_76 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_75); -lean_dec(x_75); -if (lean_obj_tag(x_76) == 2) -{ -lean_object* x_77; lean_object* x_78; uint8_t x_79; -x_77 = lean_ctor_get(x_76, 1); -lean_inc(x_77); -lean_dec(x_76); -x_78 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -x_79 = lean_string_dec_eq(x_77, x_78); -lean_dec(x_77); -if (x_79 == 0) -{ -lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; -x_80 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_81 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_80, x_72); -x_82 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_83 = l_Lean_Parser_ParserState_mkNode(x_81, x_82, x_65); -x_84 = l_Lean_Parser_mergeOrElseErrors(x_83, x_60, x_57); -lean_dec(x_57); -return x_84; -} -else -{ -lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_73 = lean_array_get_size(x_72); lean_dec(x_72); -x_85 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_86 = l_Lean_Parser_ParserState_mkNode(x_73, x_85, x_65); -x_87 = l_Lean_Parser_mergeOrElseErrors(x_86, x_60, x_57); -lean_dec(x_57); -return x_87; +x_113 = lean_ctor_get(x_70, 1); +lean_inc(x_113); +lean_inc(x_1); +x_114 = l_Lean_Parser_tokenFn(x_1, x_70); +x_115 = lean_ctor_get(x_114, 3); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; +x_116 = lean_ctor_get(x_114, 0); +lean_inc(x_116); +x_117 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_116); +lean_dec(x_116); +if (lean_obj_tag(x_117) == 2) +{ +lean_object* x_118; lean_object* x_119; uint8_t x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +x_119 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__6; +x_120 = lean_string_dec_eq(x_118, x_119); +lean_dec(x_118); +if (x_120 == 0) +{ +lean_object* x_121; lean_object* x_122; +x_121 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_114, x_121, x_113); +x_74 = x_122; +goto block_112; +} +else +{ +lean_dec(x_113); +x_74 = x_114; +goto block_112; } } else { +lean_object* x_123; lean_object* x_124; +lean_dec(x_117); +x_123 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_114, x_123, x_113); +x_74 = x_124; +goto block_112; +} +} +else +{ +lean_object* x_125; lean_object* x_126; +lean_dec(x_115); +x_125 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__9; +x_126 = l_Lean_Parser_ParserState_mkErrorsAt(x_114, x_125, x_113); +x_74 = x_126; +goto block_112; +} +block_112: +{ +lean_object* x_75; +x_75 = lean_ctor_get(x_74, 3); +lean_inc(x_75); +if (lean_obj_tag(x_75) == 0) +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_76 = l_Lean_Parser_termParser___closed__2; +x_77 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_78 = l_Lean_Parser_categoryParser___elambda__1(x_76, x_77, x_1, x_74); +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; lean_object* x_82; +x_80 = lean_ctor_get(x_78, 1); +lean_inc(x_80); +x_81 = l_Lean_Parser_tokenFn(x_1, x_78); +x_82 = lean_ctor_get(x_81, 3); +lean_inc(x_82); +if (lean_obj_tag(x_82) == 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); +lean_dec(x_84); +x_86 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; +x_87 = lean_string_dec_eq(x_85, x_86); +lean_dec(x_85); +if (x_87 == 0) +{ lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; -lean_dec(x_76); x_88 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_88, x_72); +x_89 = l_Lean_Parser_ParserState_mkErrorsAt(x_81, x_88, x_80); x_90 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_91 = l_Lean_Parser_ParserState_mkNode(x_89, x_90, x_65); -x_92 = l_Lean_Parser_mergeOrElseErrors(x_91, x_60, x_57); -lean_dec(x_57); +x_91 = l_Lean_Parser_ParserState_mkNode(x_89, x_90, x_73); +x_92 = l_Lean_Parser_mergeOrElseErrors(x_91, x_64, x_61); +lean_dec(x_61); 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_74); -x_93 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_94 = l_Lean_Parser_ParserState_mkErrorsAt(x_73, x_93, x_72); -x_95 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_65); -x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_60, x_57); -lean_dec(x_57); -return x_97; +lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_80); +x_93 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_94 = l_Lean_Parser_ParserState_mkNode(x_81, x_93, x_73); +x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_64, x_61); +lean_dec(x_61); +return x_95; } } else { -lean_object* x_98; lean_object* x_99; lean_object* x_100; -lean_dec(x_71); -lean_dec(x_1); +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; +lean_dec(x_84); +x_96 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_97 = l_Lean_Parser_ParserState_mkErrorsAt(x_81, x_96, x_80); x_98 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_99 = l_Lean_Parser_ParserState_mkNode(x_70, x_98, x_65); -x_100 = l_Lean_Parser_mergeOrElseErrors(x_99, x_60, x_57); -lean_dec(x_57); +x_99 = l_Lean_Parser_ParserState_mkNode(x_97, x_98, x_73); +x_100 = l_Lean_Parser_mergeOrElseErrors(x_99, x_64, x_61); +lean_dec(x_61); return x_100; } } else { -lean_object* x_101; lean_object* x_102; lean_object* x_103; -lean_dec(x_67); -lean_dec(x_1); -x_101 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_102 = l_Lean_Parser_ParserState_mkNode(x_66, x_101, x_65); -x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_60, x_57); -lean_dec(x_57); -return x_103; +lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; +lean_dec(x_82); +x_101 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_102 = l_Lean_Parser_ParserState_mkErrorsAt(x_81, x_101, x_80); +x_103 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_104 = l_Lean_Parser_ParserState_mkNode(x_102, x_103, x_73); +x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_64, x_61); +lean_dec(x_61); +return x_105; } } +else +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_79); +lean_dec(x_1); +x_106 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_107 = l_Lean_Parser_ParserState_mkNode(x_78, x_106, x_73); +x_108 = l_Lean_Parser_mergeOrElseErrors(x_107, x_64, x_61); +lean_dec(x_61); +return x_108; +} +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +lean_dec(x_75); +lean_dec(x_1); +x_109 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_110 = l_Lean_Parser_ParserState_mkNode(x_74, x_109, x_73); +x_111 = l_Lean_Parser_mergeOrElseErrors(x_110, x_64, x_61); +lean_dec(x_61); +return x_111; +} +} +} +else +{ +lean_object* x_127; +lean_dec(x_71); +lean_dec(x_1); +x_127 = l_Lean_Parser_mergeOrElseErrors(x_70, x_64, x_61); +lean_dec(x_61); +return x_127; +} } } } @@ -22408,11 +23378,10 @@ return x_103; lean_object* _init_l_Lean_Parser_Term_inaccessible___closed__1() { _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_inaccessible___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_inaccessible___closed__2() { @@ -22420,7 +23389,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Term_inaccessible___closed__1; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__5; +x_2 = l_Lean_Parser_antiquotNestedExpr___closed__4; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } @@ -22438,16 +23407,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_inaccessible___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_inaccessible___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_inaccessible___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_inaccessible___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_inaccessible___closed__3; +x_3 = l_Lean_Parser_Term_inaccessible___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_inaccessible___closed__5() { +lean_object* _init_l_Lean_Parser_Term_inaccessible___closed__6() { _start: { lean_object* x_1; @@ -22455,12 +23434,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_inaccessible___elambda__1), return x_1; } } -lean_object* _init_l_Lean_Parser_Term_inaccessible___closed__6() { +lean_object* _init_l_Lean_Parser_Term_inaccessible___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_inaccessible___closed__4; -x_2 = l_Lean_Parser_Term_inaccessible___closed__5; +x_1 = l_Lean_Parser_Term_inaccessible___closed__5; +x_2 = l_Lean_Parser_Term_inaccessible___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); @@ -22471,7 +23450,7 @@ lean_object* _init_l_Lean_Parser_Term_inaccessible() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_inaccessible___closed__6; +x_1 = l_Lean_Parser_Term_inaccessible___closed__7; return x_1; } } @@ -23528,11 +24507,10 @@ goto block_98; 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_1; lean_object* x_2; x_1 = l_Lean_Parser_Term_binderTactic___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_binderTactic___closed__2() { @@ -24128,7 +25106,7 @@ _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_Lean_Parser_antiquotNestedExpr___closed__4; +x_2 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } @@ -24169,7 +25147,7 @@ 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_antiquotNestedExpr___closed__2; +x_14 = l_Lean_Parser_antiquotNestedExpr___closed__1; x_15 = l_Lean_Parser_andthenInfo(x_14, x_11); x_16 = l_Lean_Parser_Term_explicitBinder___closed__1; x_17 = lean_alloc_closure((void*)(l_Lean_Parser_andthenFn), 4, 2); @@ -25080,25 +26058,24 @@ lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__6() { _start: { lean_object* x_1; -x_1 = lean_mk_string("expected parentheses around dependent arrow"); +x_1 = lean_mk_string(" → "); return x_1; } } lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__7() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = lean_unsigned_to_nat(25u); -x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__6; -x_3 = l_Lean_Parser_checkRbpLe(x_1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Parser_Term_depArrow___elambda__1___closed__6; +x_2 = l_String_trim(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__8() { _start: { lean_object* x_1; -x_1 = lean_mk_string(" → "); +x_1 = lean_mk_string(" -> "); return x_1; } } @@ -25115,25 +26092,26 @@ lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__10() { _start: { lean_object* x_1; -x_1 = lean_mk_string(" -> "); +x_1 = lean_mk_string("expected parentheses around dependent arrow"); return x_1; } } lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__11() { _start: { -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_Term_depArrow___elambda__1___closed__10; -x_2 = l_String_trim(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_Term_depArrow___elambda__1___closed__7; +x_3 = lean_string_append(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__12() { _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_depArrow___elambda__1___closed__9; +x_1 = l_Lean_Parser_Term_depArrow___elambda__1___closed__11; +x_2 = l_Lean_Parser_unicodeSymbolFn___closed__1; x_3 = lean_string_append(x_1, x_2); return x_3; } @@ -25143,7 +26121,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Term_depArrow___elambda__1___closed__12; -x_2 = l_Lean_Parser_unicodeSymbolFn___closed__1; +x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9; x_3 = lean_string_append(x_1, x_2); return x_3; } @@ -25153,7 +26131,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Term_depArrow___elambda__1___closed__13; -x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__11; +x_2 = l_Char_HasRepr___closed__1; x_3 = lean_string_append(x_1, x_2); return x_3; } @@ -25162,18 +26140,8 @@ lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__15() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_depArrow___elambda__1___closed__14; -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_depArrow___elambda__1___closed__16() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__15; +x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__14; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); @@ -25183,209 +26151,239 @@ return x_3; lean_object* l_Lean_Parser_Term_depArrow___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; uint8_t x_9; -x_3 = l_Lean_Parser_Term_depArrow___elambda__1___closed__7; +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; +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__5; +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 = l_Lean_Parser_Term_depArrow___elambda__1___closed__4; -x_8 = lean_ctor_get(x_7, 1); -lean_inc(x_8); lean_inc(x_2); lean_inc(x_1); -x_9 = l_Lean_Parser_tryAnti(x_1, x_2); -if (x_9 == 0) +x_7 = l_Lean_Parser_tryAnti(x_1, x_2); +if (x_7 == 0) { -lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; -lean_dec(x_8); -x_10 = lean_ctor_get(x_2, 0); -lean_inc(x_10); -x_11 = lean_array_get_size(x_10); -lean_dec(x_10); -lean_inc(x_1); -x_12 = lean_apply_2(x_6, x_1, x_2); -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; +lean_dec(x_6); +x_8 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_9 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_10 = l_Lean_Parser_checkRbpLtFn(x_8, x_9, x_1, x_2); +x_11 = lean_ctor_get(x_10, 3); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) { -lean_object* x_14; lean_object* x_15; +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_ctor_get(x_10, 0); +lean_inc(x_12); +x_13 = lean_array_get_size(x_12); +lean_dec(x_12); lean_inc(x_1); -x_14 = lean_apply_2(x_4, x_1, x_12); +x_14 = lean_apply_2(x_4, x_1, 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; -x_16 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9; -x_17 = l_Lean_Parser_Term_depArrow___elambda__1___closed__11; -x_18 = l_Lean_Parser_Term_depArrow___elambda__1___closed__16; +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_16 = lean_unsigned_to_nat(26u); +x_17 = l_Lean_Parser_Term_depArrow___elambda__1___closed__10; +x_18 = l_Lean_Parser_checkRbpLtFn(x_16, x_17, x_1, x_14); +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 = l_Lean_Parser_Term_depArrow___elambda__1___closed__7; +x_21 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9; +x_22 = l_Lean_Parser_Term_depArrow___elambda__1___closed__15; lean_inc(x_1); -x_19 = l_Lean_Parser_unicodeSymbolFnAux(x_16, x_17, x_18, x_1, x_14); -x_20 = lean_ctor_get(x_19, 3); -lean_inc(x_20); -if (lean_obj_tag(x_20) == 0) +x_23 = l_Lean_Parser_unicodeSymbolFnAux(x_20, x_21, x_22, 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_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; -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_19); -x_24 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_11); -return x_25; -} -else -{ -lean_object* x_26; lean_object* x_27; -lean_dec(x_20); -lean_dec(x_1); -x_26 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; -x_27 = l_Lean_Parser_ParserState_mkNode(x_19, x_26, x_11); -return x_27; -} -} -else -{ -lean_object* x_28; lean_object* x_29; -lean_dec(x_15); -lean_dec(x_1); +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +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_Term_depArrow___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_14, x_28, x_11); +x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_13); return x_29; } -} else { lean_object* x_30; lean_object* x_31; -lean_dec(x_13); -lean_dec(x_4); +lean_dec(x_24); lean_dec(x_1); x_30 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; -x_31 = l_Lean_Parser_ParserState_mkNode(x_12, x_30, x_11); +x_31 = l_Lean_Parser_ParserState_mkNode(x_23, x_30, x_13); return x_31; } } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_32 = lean_ctor_get(x_2, 0); -lean_inc(x_32); -x_33 = lean_array_get_size(x_32); -lean_dec(x_32); -x_34 = lean_ctor_get(x_2, 1); -lean_inc(x_34); -lean_inc(x_1); -x_35 = lean_apply_2(x_8, x_1, x_2); -x_36 = lean_ctor_get(x_35, 3); +lean_object* x_32; lean_object* x_33; +lean_dec(x_19); +lean_dec(x_1); +x_32 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; +x_33 = l_Lean_Parser_ParserState_mkNode(x_18, x_32, x_13); +return x_33; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_15); +lean_dec(x_1); +x_34 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; +x_35 = l_Lean_Parser_ParserState_mkNode(x_14, x_34, x_13); +return x_35; +} +} +else +{ +lean_dec(x_11); +lean_dec(x_4); +lean_dec(x_1); +return x_10; +} +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_2, 0); lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) -{ -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_6); -lean_dec(x_4); -lean_dec(x_1); -return x_35; -} -else -{ -lean_object* x_37; lean_object* x_38; uint8_t x_39; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); +x_37 = lean_array_get_size(x_36); lean_dec(x_36); -x_38 = lean_ctor_get(x_35, 1); +x_38 = lean_ctor_get(x_2, 1); lean_inc(x_38); -x_39 = lean_nat_dec_eq(x_38, x_34); -lean_dec(x_38); -if (x_39 == 0) +lean_inc(x_1); +x_39 = lean_apply_2(x_6, x_1, x_2); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { +lean_dec(x_38); lean_dec(x_37); -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_6); lean_dec(x_4); lean_dec(x_1); -return x_35; +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_inc(x_34); -x_40 = l_Lean_Parser_ParserState_restore(x_35, x_33, x_34); -lean_dec(x_33); +lean_object* x_41; lean_object* x_42; uint8_t x_43; x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -x_42 = lean_array_get_size(x_41); +lean_dec(x_40); +x_42 = lean_ctor_get(x_39, 1); +lean_inc(x_42); +x_43 = lean_nat_dec_eq(x_42, x_38); +lean_dec(x_42); +if (x_43 == 0) +{ lean_dec(x_41); -lean_inc(x_1); -x_43 = lean_apply_2(x_6, 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_45; lean_object* x_46; -lean_inc(x_1); -x_45 = lean_apply_2(x_4, x_1, x_43); -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 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9; -x_48 = l_Lean_Parser_Term_depArrow___elambda__1___closed__11; -x_49 = l_Lean_Parser_Term_depArrow___elambda__1___closed__16; -lean_inc(x_1); -x_50 = l_Lean_Parser_unicodeSymbolFnAux(x_47, x_48, x_49, 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_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_termParser___closed__2; -x_53 = lean_unsigned_to_nat(0u); -x_54 = l_Lean_Parser_categoryParser___elambda__1(x_52, x_53, x_1, x_50); -x_55 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; -x_56 = l_Lean_Parser_ParserState_mkNode(x_54, x_55, x_42); -x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_37, x_34); -lean_dec(x_34); -return x_57; -} -else -{ -lean_object* x_58; lean_object* x_59; lean_object* x_60; -lean_dec(x_51); -lean_dec(x_1); -x_58 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; -x_59 = l_Lean_Parser_ParserState_mkNode(x_50, x_58, x_42); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_37, x_34); -lean_dec(x_34); -return x_60; -} -} -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_Term_depArrow___elambda__1___closed__2; -x_62 = l_Lean_Parser_ParserState_mkNode(x_45, x_61, x_42); -x_63 = l_Lean_Parser_mergeOrElseErrors(x_62, x_37, x_34); -lean_dec(x_34); -return x_63; -} -} -else -{ -lean_object* x_64; lean_object* x_65; lean_object* x_66; -lean_dec(x_44); +lean_dec(x_38); +lean_dec(x_37); lean_dec(x_4); lean_dec(x_1); -x_64 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; -x_65 = l_Lean_Parser_ParserState_mkNode(x_43, x_64, x_42); -x_66 = l_Lean_Parser_mergeOrElseErrors(x_65, x_37, x_34); -lean_dec(x_34); -return x_66; +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_inc(x_38); +x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); +lean_dec(x_37); +x_45 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_46 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_47 = l_Lean_Parser_checkRbpLtFn(x_45, x_46, x_1, x_44); +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 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +lean_inc(x_1); +x_51 = lean_apply_2(x_4, x_1, x_47); +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_unsigned_to_nat(26u); +x_54 = l_Lean_Parser_Term_depArrow___elambda__1___closed__10; +x_55 = l_Lean_Parser_checkRbpLtFn(x_53, x_54, x_1, x_51); +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_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = l_Lean_Parser_Term_depArrow___elambda__1___closed__7; +x_58 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9; +x_59 = l_Lean_Parser_Term_depArrow___elambda__1___closed__15; +lean_inc(x_1); +x_60 = l_Lean_Parser_unicodeSymbolFnAux(x_57, x_58, x_59, x_1, x_55); +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; lean_object* x_66; lean_object* x_67; +x_62 = l_Lean_Parser_termParser___closed__2; +x_63 = lean_unsigned_to_nat(0u); +x_64 = l_Lean_Parser_categoryParser___elambda__1(x_62, x_63, x_1, x_60); +x_65 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; +x_66 = l_Lean_Parser_ParserState_mkNode(x_64, x_65, x_50); +x_67 = l_Lean_Parser_mergeOrElseErrors(x_66, x_41, x_38); +lean_dec(x_38); +return x_67; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_dec(x_61); +lean_dec(x_1); +x_68 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; +x_69 = l_Lean_Parser_ParserState_mkNode(x_60, x_68, x_50); +x_70 = l_Lean_Parser_mergeOrElseErrors(x_69, x_41, x_38); +lean_dec(x_38); +return x_70; +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; +lean_dec(x_56); +lean_dec(x_1); +x_71 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; +x_72 = l_Lean_Parser_ParserState_mkNode(x_55, x_71, x_50); +x_73 = l_Lean_Parser_mergeOrElseErrors(x_72, x_41, x_38); +lean_dec(x_38); +return x_73; +} +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_52); +lean_dec(x_1); +x_74 = l_Lean_Parser_Term_depArrow___elambda__1___closed__2; +x_75 = l_Lean_Parser_ParserState_mkNode(x_51, x_74, x_50); +x_76 = l_Lean_Parser_mergeOrElseErrors(x_75, x_41, x_38); +lean_dec(x_38); +return x_76; +} +} +else +{ +lean_object* x_77; +lean_dec(x_48); +lean_dec(x_4); +lean_dec(x_1); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_47, x_41, x_38); +lean_dec(x_38); +return x_77; } } } @@ -25395,19 +26393,18 @@ return x_66; lean_object* _init_l_Lean_Parser_Term_depArrow___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = lean_box(0); +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Term_depArrow___elambda__1___closed__7; x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9; -x_3 = l_Lean_Parser_Term_depArrow___elambda__1___closed__11; -x_4 = l_Lean_Parser_unicodeSymbolInfo(x_2, x_3, x_1); -return x_4; +x_3 = l_Lean_Parser_unicodeSymbolInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_depArrow___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_depArrow___closed__1; @@ -25418,13 +26415,11 @@ return x_4; 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_depArrow___elambda__1___closed__7; -x_2 = lean_ctor_get(x_1, 0); -lean_inc(x_2); -x_3 = l_Lean_Parser_Term_depArrow___closed__2; -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_epsilonInfo; +x_2 = l_Lean_Parser_Term_depArrow___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_depArrow___closed__4() { @@ -25452,16 +26447,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_depArrow___closed__6() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_depArrow___closed__5; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_depArrow___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_depArrow___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_depArrow___closed__5; +x_3 = l_Lean_Parser_Term_depArrow___closed__6; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_depArrow___closed__7() { +lean_object* _init_l_Lean_Parser_Term_depArrow___closed__8() { _start: { lean_object* x_1; @@ -25469,12 +26474,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_depArrow___elambda__1), 2, 0 return x_1; } } -lean_object* _init_l_Lean_Parser_Term_depArrow___closed__8() { +lean_object* _init_l_Lean_Parser_Term_depArrow___closed__9() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_depArrow___closed__6; -x_2 = l_Lean_Parser_Term_depArrow___closed__7; +x_1 = l_Lean_Parser_Term_depArrow___closed__7; +x_2 = l_Lean_Parser_Term_depArrow___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); @@ -25485,7 +26490,7 @@ lean_object* _init_l_Lean_Parser_Term_depArrow() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_depArrow___closed__8; +x_1 = l_Lean_Parser_Term_depArrow___closed__9; return x_1; } } @@ -26016,18 +27021,6 @@ lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l_Lean_Parser_Term_forall___elambda__1___closed__13() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = lean_box(0); -x_2 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___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_Term_forall___elambda__1(lean_object* x_1, lean_object* x_2) { _start: { @@ -26043,619 +27036,474 @@ lean_inc(x_1); x_7 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_7 == 0) { -lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_dec(x_6); -x_8 = lean_ctor_get(x_2, 0); -lean_inc(x_8); -x_9 = lean_array_get_size(x_8); -lean_dec(x_8); -x_40 = l_Lean_Parser_Term_forall___elambda__1___closed__6; -x_41 = l_Lean_Parser_Term_forall___elambda__1___closed__7; -x_42 = l_Lean_Parser_Term_forall___elambda__1___closed__12; -lean_inc(x_1); -x_43 = l_Lean_Parser_unicodeSymbolFnAux(x_40, x_41, x_42, x_1, x_2); -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; -x_45 = lean_ctor_get(x_43, 0); -lean_inc(x_45); -x_46 = lean_array_get_size(x_45); -lean_dec(x_45); -x_47 = lean_ctor_get(x_43, 1); -lean_inc(x_47); -lean_inc(x_1); -x_48 = l_Lean_Parser_Term_simpleBinder___elambda__1(x_1, x_43); -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_dec(x_47); -lean_dec(x_4); -lean_inc(x_1); -x_50 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_1, x_48); -x_51 = l_Lean_nullKind; -x_52 = l_Lean_Parser_ParserState_mkNode(x_50, x_51, x_46); -x_10 = x_52; -goto block_39; -} -else -{ -lean_object* x_53; lean_object* x_54; uint8_t x_55; -x_53 = lean_ctor_get(x_49, 0); -lean_inc(x_53); -lean_dec(x_49); -x_54 = lean_ctor_get(x_48, 1); -lean_inc(x_54); -x_55 = lean_nat_dec_eq(x_54, x_47); -lean_dec(x_54); -if (x_55 == 0) -{ -lean_object* x_56; lean_object* x_57; -lean_dec(x_53); -lean_dec(x_47); -lean_dec(x_4); -x_56 = l_Lean_nullKind; -x_57 = l_Lean_Parser_ParserState_mkNode(x_48, x_56, x_46); -x_10 = x_57; -goto block_39; -} -else -{ -lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; -lean_inc(x_47); -x_58 = l_Lean_Parser_ParserState_restore(x_48, x_46, x_47); -lean_inc(x_1); -x_59 = lean_apply_2(x_4, x_1, x_58); -x_60 = l_Lean_Parser_mergeOrElseErrors(x_59, x_53, x_47); -lean_dec(x_47); -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_inc(x_1); -x_62 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_1, x_60); -x_63 = l_Lean_nullKind; -x_64 = l_Lean_Parser_ParserState_mkNode(x_62, x_63, x_46); -x_10 = x_64; -goto block_39; -} -else -{ -lean_object* x_65; lean_object* x_66; -lean_dec(x_61); -x_65 = l_Lean_nullKind; -x_66 = l_Lean_Parser_ParserState_mkNode(x_60, x_65, x_46); -x_10 = x_66; -goto block_39; -} -} -} -} -else -{ -lean_object* x_67; lean_object* x_68; -lean_dec(x_44); -lean_dec(x_4); -lean_dec(x_1); -x_67 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_68 = l_Lean_Parser_ParserState_mkNode(x_43, x_67, x_9); -return x_68; -} -block_39: -{ -lean_object* x_11; +x_8 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_9 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_10 = l_Lean_Parser_checkRbpLtFn(x_8, x_9, x_1, x_2); 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_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_12 = lean_ctor_get(x_10, 0); lean_inc(x_12); -lean_inc(x_1); -x_13 = l_Lean_Parser_tokenFn(x_1, 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_checkStackTopFn___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_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1; -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; -lean_dec(x_1); -x_20 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; -x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); -x_22 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, 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; +x_13 = lean_array_get_size(x_12); lean_dec(x_12); -x_24 = l_Lean_Parser_termParser___closed__2; -x_25 = lean_unsigned_to_nat(0u); -x_26 = l_Lean_Parser_categoryParser___elambda__1(x_24, x_25, x_1, x_13); -x_27 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_9); -return x_28; +x_44 = l_Lean_Parser_Term_forall___elambda__1___closed__6; +x_45 = l_Lean_Parser_Term_forall___elambda__1___closed__7; +x_46 = l_Lean_Parser_Term_forall___elambda__1___closed__12; +lean_inc(x_1); +x_47 = l_Lean_Parser_unicodeSymbolFnAux(x_44, x_45, x_46, x_1, x_10); +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; lean_object* x_53; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +x_51 = lean_ctor_get(x_47, 1); +lean_inc(x_51); +lean_inc(x_1); +x_52 = l_Lean_Parser_Term_simpleBinder___elambda__1(x_1, x_47); +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_dec(x_51); +lean_dec(x_4); +lean_inc(x_1); +x_54 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___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_50); +x_14 = x_56; +goto block_43; +} +else +{ +lean_object* x_57; lean_object* x_58; uint8_t x_59; +x_57 = lean_ctor_get(x_53, 0); +lean_inc(x_57); +lean_dec(x_53); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +x_59 = lean_nat_dec_eq(x_58, x_51); +lean_dec(x_58); +if (x_59 == 0) +{ +lean_object* x_60; lean_object* x_61; +lean_dec(x_57); +lean_dec(x_51); +lean_dec(x_4); +x_60 = l_Lean_nullKind; +x_61 = l_Lean_Parser_ParserState_mkNode(x_52, x_60, x_50); +x_14 = x_61; +goto block_43; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +lean_inc(x_51); +x_62 = l_Lean_Parser_ParserState_restore(x_52, x_50, x_51); +lean_inc(x_1); +x_63 = lean_apply_2(x_4, x_1, x_62); +x_64 = l_Lean_Parser_mergeOrElseErrors(x_63, x_57, x_51); +lean_dec(x_51); +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_inc(x_1); +x_66 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_1, x_64); +x_67 = l_Lean_nullKind; +x_68 = l_Lean_Parser_ParserState_mkNode(x_66, x_67, x_50); +x_14 = x_68; +goto block_43; +} +else +{ +lean_object* x_69; lean_object* x_70; +lean_dec(x_65); +x_69 = l_Lean_nullKind; +x_70 = l_Lean_Parser_ParserState_mkNode(x_64, x_69, x_50); +x_14 = x_70; +goto block_43; +} +} } } else { -lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; -lean_dec(x_16); +lean_object* x_71; lean_object* x_72; +lean_dec(x_48); +lean_dec(x_4); lean_dec(x_1); -x_29 = l___private_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_13, x_29, x_12); +x_71 = l_Lean_Parser_Term_forall___elambda__1___closed__2; +x_72 = l_Lean_Parser_ParserState_mkNode(x_47, x_71, x_13); +return x_72; +} +block_43: +{ +lean_object* x_15; +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; +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +lean_inc(x_1); +x_17 = l_Lean_Parser_tokenFn(x_1, x_14); +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_checkStackTopFn___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___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1; +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_dec(x_1); +x_24 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; +x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); +x_26 = l_Lean_Parser_Term_forall___elambda__1___closed__2; +x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_13); +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_16); +x_28 = l_Lean_Parser_termParser___closed__2; +x_29 = lean_unsigned_to_nat(0u); +x_30 = l_Lean_Parser_categoryParser___elambda__1(x_28, x_29, x_1, x_17); x_31 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_9); +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_13); return x_32; } } else { lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -lean_dec(x_14); +lean_dec(x_20); lean_dec(x_1); x_33 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; -x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_33, x_12); +x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_33, x_16); x_35 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_9); +x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_13); return x_36; } } else { -lean_object* x_37; lean_object* x_38; +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +lean_dec(x_18); +lean_dec(x_1); +x_37 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; +x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_16); +x_39 = l_Lean_Parser_Term_forall___elambda__1___closed__2; +x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_13); +return x_40; +} +} +else +{ +lean_object* x_41; lean_object* x_42; +lean_dec(x_15); +lean_dec(x_1); +x_41 = l_Lean_Parser_Term_forall___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkNode(x_14, x_41, x_13); +return x_42; +} +} +} +else +{ lean_dec(x_11); +lean_dec(x_4); lean_dec(x_1); -x_37 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkNode(x_10, x_37, x_9); -return x_38; -} +return x_10; } } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; -x_69 = lean_ctor_get(x_2, 0); -lean_inc(x_69); -x_70 = lean_array_get_size(x_69); -lean_dec(x_69); -x_71 = lean_ctor_get(x_2, 1); -lean_inc(x_71); -lean_inc(x_1); -x_72 = lean_apply_2(x_6, x_1, x_2); -x_73 = lean_ctor_get(x_72, 3); +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_73 = lean_ctor_get(x_2, 0); lean_inc(x_73); -if (lean_obj_tag(x_73) == 0) -{ -lean_dec(x_71); -lean_dec(x_70); -lean_dec(x_4); -lean_dec(x_1); -return x_72; -} -else -{ -lean_object* x_74; lean_object* x_75; uint8_t x_76; -x_74 = lean_ctor_get(x_73, 0); -lean_inc(x_74); +x_74 = lean_array_get_size(x_73); lean_dec(x_73); -x_75 = lean_ctor_get(x_72, 1); +x_75 = lean_ctor_get(x_2, 1); lean_inc(x_75); -x_76 = lean_nat_dec_eq(x_75, x_71); -lean_dec(x_75); -if (x_76 == 0) +lean_inc(x_1); +x_76 = lean_apply_2(x_6, x_1, x_2); +x_77 = lean_ctor_get(x_76, 3); +lean_inc(x_77); +if (lean_obj_tag(x_77) == 0) { +lean_dec(x_75); lean_dec(x_74); -lean_dec(x_71); -lean_dec(x_70); lean_dec(x_4); lean_dec(x_1); -return x_72; +return x_76; } else { -lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; -lean_inc(x_71); -x_77 = l_Lean_Parser_ParserState_restore(x_72, x_70, x_71); -lean_dec(x_70); +lean_object* x_78; lean_object* x_79; uint8_t x_80; x_78 = lean_ctor_get(x_77, 0); lean_inc(x_78); -x_79 = lean_array_get_size(x_78); +lean_dec(x_77); +x_79 = lean_ctor_get(x_76, 1); +lean_inc(x_79); +x_80 = lean_nat_dec_eq(x_79, x_75); +lean_dec(x_79); +if (x_80 == 0) +{ lean_dec(x_78); -x_115 = l_Lean_Parser_Term_forall___elambda__1___closed__6; -x_116 = l_Lean_Parser_Term_forall___elambda__1___closed__7; -x_117 = l_Lean_Parser_Term_forall___elambda__1___closed__12; -lean_inc(x_1); -x_118 = l_Lean_Parser_unicodeSymbolFnAux(x_115, x_116, x_117, x_1, x_77); -x_119 = lean_ctor_get(x_118, 3); -lean_inc(x_119); -if (lean_obj_tag(x_119) == 0) +lean_dec(x_75); +lean_dec(x_74); +lean_dec(x_4); +lean_dec(x_1); +return x_76; +} +else { -lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; -x_120 = lean_ctor_get(x_118, 0); -lean_inc(x_120); -x_121 = lean_array_get_size(x_120); -lean_dec(x_120); -x_122 = lean_ctor_get(x_118, 1); -lean_inc(x_122); -lean_inc(x_1); -x_123 = l_Lean_Parser_Term_simpleBinder___elambda__1(x_1, x_118); -x_124 = lean_ctor_get(x_123, 3); -lean_inc(x_124); -if (lean_obj_tag(x_124) == 0) +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +lean_inc(x_75); +x_81 = l_Lean_Parser_ParserState_restore(x_76, x_74, x_75); +lean_dec(x_74); +x_82 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_83 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_84 = l_Lean_Parser_checkRbpLtFn(x_82, x_83, x_1, x_81); +x_85 = lean_ctor_get(x_84, 3); +lean_inc(x_85); +if (lean_obj_tag(x_85) == 0) { -lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; -lean_dec(x_122); +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; +x_86 = lean_ctor_get(x_84, 0); +lean_inc(x_86); +x_87 = lean_array_get_size(x_86); +lean_dec(x_86); +x_123 = l_Lean_Parser_Term_forall___elambda__1___closed__6; +x_124 = l_Lean_Parser_Term_forall___elambda__1___closed__7; +x_125 = l_Lean_Parser_Term_forall___elambda__1___closed__12; +lean_inc(x_1); +x_126 = l_Lean_Parser_unicodeSymbolFnAux(x_123, x_124, x_125, x_1, x_84); +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; lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_128 = lean_ctor_get(x_126, 0); +lean_inc(x_128); +x_129 = lean_array_get_size(x_128); +lean_dec(x_128); +x_130 = lean_ctor_get(x_126, 1); +lean_inc(x_130); +lean_inc(x_1); +x_131 = l_Lean_Parser_Term_simpleBinder___elambda__1(x_1, x_126); +x_132 = lean_ctor_get(x_131, 3); +lean_inc(x_132); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; +lean_dec(x_130); lean_dec(x_4); lean_inc(x_1); -x_125 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_1, x_123); -x_126 = l_Lean_nullKind; -x_127 = l_Lean_Parser_ParserState_mkNode(x_125, x_126, x_121); -x_128 = lean_ctor_get(x_127, 3); -lean_inc(x_128); -if (lean_obj_tag(x_128) == 0) +x_133 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_1, x_131); +x_134 = l_Lean_nullKind; +x_135 = l_Lean_Parser_ParserState_mkNode(x_133, x_134, x_129); +x_88 = x_135; +goto block_122; +} +else { -lean_object* x_129; lean_object* x_130; lean_object* x_131; -x_129 = lean_ctor_get(x_127, 1); -lean_inc(x_129); -lean_inc(x_1); -x_130 = l_Lean_Parser_tokenFn(x_1, x_127); -x_131 = lean_ctor_get(x_130, 3); -lean_inc(x_131); -if (lean_obj_tag(x_131) == 0) -{ -lean_object* x_132; lean_object* x_133; -x_132 = lean_ctor_get(x_130, 0); -lean_inc(x_132); -x_133 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_132); +lean_object* x_136; lean_object* x_137; uint8_t x_138; +x_136 = lean_ctor_get(x_132, 0); +lean_inc(x_136); lean_dec(x_132); -if (lean_obj_tag(x_133) == 2) +x_137 = lean_ctor_get(x_131, 1); +lean_inc(x_137); +x_138 = lean_nat_dec_eq(x_137, x_130); +lean_dec(x_137); +if (x_138 == 0) { -lean_object* x_134; lean_object* x_135; uint8_t x_136; -x_134 = lean_ctor_get(x_133, 1); -lean_inc(x_134); -lean_dec(x_133); -x_135 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1; -x_136 = lean_string_dec_eq(x_134, x_135); -lean_dec(x_134); -if (x_136 == 0) -{ -lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; -lean_dec(x_1); -x_137 = l_Lean_Parser_Term_forall___elambda__1___closed__13; -x_138 = l_Lean_Parser_ParserState_mkErrorsAt(x_130, x_137, x_129); -x_139 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_140 = l_Lean_Parser_ParserState_mkNode(x_138, x_139, x_79); -x_141 = l_Lean_Parser_mergeOrElseErrors(x_140, x_74, x_71); -lean_dec(x_71); -return x_141; +lean_object* x_139; lean_object* x_140; +lean_dec(x_136); +lean_dec(x_130); +lean_dec(x_4); +x_139 = l_Lean_nullKind; +x_140 = l_Lean_Parser_ParserState_mkNode(x_131, x_139, x_129); +x_88 = x_140; +goto block_122; } else { -lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; -lean_dec(x_129); -x_142 = l_Lean_Parser_termParser___closed__2; -x_143 = lean_unsigned_to_nat(0u); -x_144 = l_Lean_Parser_categoryParser___elambda__1(x_142, x_143, x_1, x_130); -x_145 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_146 = l_Lean_Parser_ParserState_mkNode(x_144, x_145, x_79); -x_147 = l_Lean_Parser_mergeOrElseErrors(x_146, x_74, x_71); -lean_dec(x_71); -return x_147; +lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; +lean_inc(x_130); +x_141 = l_Lean_Parser_ParserState_restore(x_131, x_129, x_130); +lean_inc(x_1); +x_142 = lean_apply_2(x_4, x_1, x_141); +x_143 = l_Lean_Parser_mergeOrElseErrors(x_142, x_136, x_130); +lean_dec(x_130); +x_144 = lean_ctor_get(x_143, 3); +lean_inc(x_144); +if (lean_obj_tag(x_144) == 0) +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +lean_inc(x_1); +x_145 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_1, x_143); +x_146 = l_Lean_nullKind; +x_147 = l_Lean_Parser_ParserState_mkNode(x_145, x_146, x_129); +x_88 = x_147; +goto block_122; +} +else +{ +lean_object* x_148; lean_object* x_149; +lean_dec(x_144); +x_148 = l_Lean_nullKind; +x_149 = l_Lean_Parser_ParserState_mkNode(x_143, x_148, x_129); +x_88 = x_149; +goto block_122; +} +} } } else { -lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; -lean_dec(x_133); +lean_object* x_150; lean_object* x_151; lean_object* x_152; +lean_dec(x_127); +lean_dec(x_4); lean_dec(x_1); -x_148 = l_Lean_Parser_Term_forall___elambda__1___closed__13; -x_149 = l_Lean_Parser_ParserState_mkErrorsAt(x_130, x_148, x_129); x_150 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_151 = l_Lean_Parser_ParserState_mkNode(x_149, x_150, x_79); -x_152 = l_Lean_Parser_mergeOrElseErrors(x_151, x_74, x_71); -lean_dec(x_71); +x_151 = l_Lean_Parser_ParserState_mkNode(x_126, x_150, x_87); +x_152 = l_Lean_Parser_mergeOrElseErrors(x_151, x_78, x_75); +lean_dec(x_75); return x_152; } -} -else +block_122: { -lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; -lean_dec(x_131); -lean_dec(x_1); -x_153 = l_Lean_Parser_Term_forall___elambda__1___closed__13; -x_154 = l_Lean_Parser_ParserState_mkErrorsAt(x_130, x_153, x_129); -x_155 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_156 = l_Lean_Parser_ParserState_mkNode(x_154, x_155, x_79); -x_157 = l_Lean_Parser_mergeOrElseErrors(x_156, x_74, x_71); -lean_dec(x_71); -return x_157; -} -} -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_158; lean_object* x_159; lean_object* x_160; -lean_dec(x_128); -lean_dec(x_1); -x_158 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_159 = l_Lean_Parser_ParserState_mkNode(x_127, x_158, x_79); -x_160 = l_Lean_Parser_mergeOrElseErrors(x_159, x_74, x_71); -lean_dec(x_71); -return x_160; -} -} -else -{ -lean_object* x_161; lean_object* x_162; uint8_t x_163; -x_161 = lean_ctor_get(x_124, 0); -lean_inc(x_161); -lean_dec(x_124); -x_162 = lean_ctor_get(x_123, 1); -lean_inc(x_162); -x_163 = lean_nat_dec_eq(x_162, x_122); -lean_dec(x_162); -if (x_163 == 0) -{ -lean_object* x_164; lean_object* x_165; lean_object* x_166; -lean_dec(x_161); -lean_dec(x_122); -lean_dec(x_4); -x_164 = l_Lean_nullKind; -x_165 = l_Lean_Parser_ParserState_mkNode(x_123, x_164, x_121); -x_166 = lean_ctor_get(x_165, 3); -lean_inc(x_166); -if (lean_obj_tag(x_166) == 0) -{ -lean_object* x_167; lean_object* x_168; lean_object* x_169; -x_167 = lean_ctor_get(x_165, 1); -lean_inc(x_167); +lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_88, 1); +lean_inc(x_90); lean_inc(x_1); -x_168 = l_Lean_Parser_tokenFn(x_1, x_165); -x_169 = lean_ctor_get(x_168, 3); -lean_inc(x_169); -if (lean_obj_tag(x_169) == 0) +x_91 = l_Lean_Parser_tokenFn(x_1, x_88); +x_92 = lean_ctor_get(x_91, 3); +lean_inc(x_92); +if (lean_obj_tag(x_92) == 0) { -lean_object* x_170; lean_object* x_171; -x_170 = lean_ctor_get(x_168, 0); -lean_inc(x_170); -x_171 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_170); -lean_dec(x_170); -if (lean_obj_tag(x_171) == 2) +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_172; lean_object* x_173; uint8_t x_174; -x_172 = lean_ctor_get(x_171, 1); -lean_inc(x_172); -lean_dec(x_171); -x_173 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1; -x_174 = lean_string_dec_eq(x_172, x_173); -lean_dec(x_172); -if (x_174 == 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___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1; +x_97 = lean_string_dec_eq(x_95, x_96); +lean_dec(x_95); +if (x_97 == 0) { -lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_dec(x_1); -x_175 = l_Lean_Parser_Term_forall___elambda__1___closed__13; -x_176 = l_Lean_Parser_ParserState_mkErrorsAt(x_168, x_175, x_167); -x_177 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_178 = l_Lean_Parser_ParserState_mkNode(x_176, x_177, x_79); -x_179 = l_Lean_Parser_mergeOrElseErrors(x_178, x_74, x_71); -lean_dec(x_71); -return x_179; +x_98 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; +x_99 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_98, x_90); +x_100 = l_Lean_Parser_Term_forall___elambda__1___closed__2; +x_101 = l_Lean_Parser_ParserState_mkNode(x_99, x_100, x_87); +x_102 = l_Lean_Parser_mergeOrElseErrors(x_101, x_78, x_75); +lean_dec(x_75); +return x_102; } else { -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_167); -x_180 = l_Lean_Parser_termParser___closed__2; -x_181 = lean_unsigned_to_nat(0u); -x_182 = l_Lean_Parser_categoryParser___elambda__1(x_180, x_181, x_1, x_168); -x_183 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_184 = l_Lean_Parser_ParserState_mkNode(x_182, x_183, x_79); -x_185 = l_Lean_Parser_mergeOrElseErrors(x_184, x_74, x_71); -lean_dec(x_71); -return x_185; +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_90); +x_103 = l_Lean_Parser_termParser___closed__2; +x_104 = lean_unsigned_to_nat(0u); +x_105 = l_Lean_Parser_categoryParser___elambda__1(x_103, x_104, x_1, x_91); +x_106 = l_Lean_Parser_Term_forall___elambda__1___closed__2; +x_107 = l_Lean_Parser_ParserState_mkNode(x_105, x_106, x_87); +x_108 = l_Lean_Parser_mergeOrElseErrors(x_107, x_78, x_75); +lean_dec(x_75); +return x_108; } } else { -lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; -lean_dec(x_171); -lean_dec(x_1); -x_186 = l_Lean_Parser_Term_forall___elambda__1___closed__13; -x_187 = l_Lean_Parser_ParserState_mkErrorsAt(x_168, x_186, x_167); -x_188 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_189 = l_Lean_Parser_ParserState_mkNode(x_187, x_188, x_79); -x_190 = l_Lean_Parser_mergeOrElseErrors(x_189, x_74, x_71); -lean_dec(x_71); -return x_190; -} -} -else -{ -lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; -lean_dec(x_169); -lean_dec(x_1); -x_191 = l_Lean_Parser_Term_forall___elambda__1___closed__13; -x_192 = l_Lean_Parser_ParserState_mkErrorsAt(x_168, x_191, x_167); -x_193 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_194 = l_Lean_Parser_ParserState_mkNode(x_192, x_193, x_79); -x_195 = l_Lean_Parser_mergeOrElseErrors(x_194, x_74, x_71); -lean_dec(x_71); -return x_195; -} -} -else -{ -lean_object* x_196; lean_object* x_197; lean_object* x_198; -lean_dec(x_166); -lean_dec(x_1); -x_196 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_197 = l_Lean_Parser_ParserState_mkNode(x_165, x_196, x_79); -x_198 = l_Lean_Parser_mergeOrElseErrors(x_197, x_74, x_71); -lean_dec(x_71); -return x_198; -} -} -else -{ -lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; -lean_inc(x_122); -x_199 = l_Lean_Parser_ParserState_restore(x_123, x_121, x_122); -lean_inc(x_1); -x_200 = lean_apply_2(x_4, x_1, x_199); -x_201 = l_Lean_Parser_mergeOrElseErrors(x_200, x_161, x_122); -lean_dec(x_122); -x_202 = lean_ctor_get(x_201, 3); -lean_inc(x_202); -if (lean_obj_tag(x_202) == 0) -{ -lean_object* x_203; lean_object* x_204; lean_object* x_205; -lean_inc(x_1); -x_203 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_forall___elambda__1___spec__1(x_1, x_201); -x_204 = l_Lean_nullKind; -x_205 = l_Lean_Parser_ParserState_mkNode(x_203, x_204, x_121); -x_80 = x_205; -goto block_114; -} -else -{ -lean_object* x_206; lean_object* x_207; -lean_dec(x_202); -x_206 = l_Lean_nullKind; -x_207 = l_Lean_Parser_ParserState_mkNode(x_201, x_206, x_121); -x_80 = x_207; -goto block_114; -} -} -} -} -else -{ -lean_object* x_208; lean_object* x_209; lean_object* x_210; -lean_dec(x_119); -lean_dec(x_4); -lean_dec(x_1); -x_208 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_209 = l_Lean_Parser_ParserState_mkNode(x_118, x_208, x_79); -x_210 = l_Lean_Parser_mergeOrElseErrors(x_209, x_74, x_71); -lean_dec(x_71); -return x_210; -} -block_114: -{ -lean_object* x_81; -x_81 = lean_ctor_get(x_80, 3); -lean_inc(x_81); -if (lean_obj_tag(x_81) == 0) -{ -lean_object* x_82; lean_object* x_83; lean_object* x_84; -x_82 = lean_ctor_get(x_80, 1); -lean_inc(x_82); -lean_inc(x_1); -x_83 = l_Lean_Parser_tokenFn(x_1, x_80); -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___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__1; -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; lean_object* x_92; lean_object* x_93; lean_object* x_94; -lean_dec(x_1); -x_90 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; -x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_90, x_82); -x_92 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_93 = l_Lean_Parser_ParserState_mkNode(x_91, x_92, x_79); -x_94 = l_Lean_Parser_mergeOrElseErrors(x_93, x_74, x_71); -lean_dec(x_71); -return x_94; -} -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_dec(x_82); -x_95 = l_Lean_Parser_termParser___closed__2; -x_96 = lean_unsigned_to_nat(0u); -x_97 = l_Lean_Parser_categoryParser___elambda__1(x_95, x_96, x_1, x_83); -x_98 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_99 = l_Lean_Parser_ParserState_mkNode(x_97, x_98, x_79); -x_100 = l_Lean_Parser_mergeOrElseErrors(x_99, x_74, x_71); -lean_dec(x_71); -return x_100; -} -} -else -{ -lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; -lean_dec(x_86); -lean_dec(x_1); -x_101 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; -x_102 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_101, x_82); -x_103 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_104 = l_Lean_Parser_ParserState_mkNode(x_102, x_103, x_79); -x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_74, x_71); -lean_dec(x_71); -return x_105; -} -} -else -{ -lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; -lean_dec(x_84); -lean_dec(x_1); -x_106 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; -x_107 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_106, x_82); -x_108 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_109 = l_Lean_Parser_ParserState_mkNode(x_107, x_108, x_79); -x_110 = l_Lean_Parser_mergeOrElseErrors(x_109, x_74, x_71); -lean_dec(x_71); -return x_110; -} -} -else -{ -lean_object* x_111; lean_object* x_112; lean_object* x_113; -lean_dec(x_81); +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; +lean_dec(x_94); lean_dec(x_1); +x_109 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; +x_110 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_109, x_90); x_111 = l_Lean_Parser_Term_forall___elambda__1___closed__2; -x_112 = l_Lean_Parser_ParserState_mkNode(x_80, x_111, x_79); -x_113 = l_Lean_Parser_mergeOrElseErrors(x_112, x_74, x_71); -lean_dec(x_71); +x_112 = l_Lean_Parser_ParserState_mkNode(x_110, x_111, x_87); +x_113 = l_Lean_Parser_mergeOrElseErrors(x_112, x_78, x_75); +lean_dec(x_75); return x_113; } } +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; +lean_dec(x_92); +lean_dec(x_1); +x_114 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_explicitUniv___elambda__1___spec__2___closed__4; +x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_91, x_114, x_90); +x_116 = l_Lean_Parser_Term_forall___elambda__1___closed__2; +x_117 = l_Lean_Parser_ParserState_mkNode(x_115, x_116, x_87); +x_118 = l_Lean_Parser_mergeOrElseErrors(x_117, x_78, x_75); +lean_dec(x_75); +return x_118; +} +} +else +{ +lean_object* x_119; lean_object* x_120; lean_object* x_121; +lean_dec(x_89); +lean_dec(x_1); +x_119 = l_Lean_Parser_Term_forall___elambda__1___closed__2; +x_120 = l_Lean_Parser_ParserState_mkNode(x_88, x_119, x_87); +x_121 = l_Lean_Parser_mergeOrElseErrors(x_120, x_78, x_75); +lean_dec(x_75); +return x_121; +} +} +} +else +{ +lean_object* x_153; +lean_dec(x_85); +lean_dec(x_4); +lean_dec(x_1); +x_153 = l_Lean_Parser_mergeOrElseErrors(x_84, x_78, x_75); +lean_dec(x_75); +return x_153; +} } } } @@ -26664,12 +27512,11 @@ return x_113; lean_object* _init_l_Lean_Parser_Term_forall___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Term_forall___elambda__1___closed__6; x_2 = l_Lean_Parser_Term_forall___elambda__1___closed__7; -x_3 = l_Lean_Parser_Term_if___closed__1; -x_4 = l_Lean_Parser_unicodeSymbolInfo(x_1, x_2, x_3); -return x_4; +x_3 = l_Lean_Parser_unicodeSymbolInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_forall___closed__2() { @@ -26690,7 +27537,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_explicitUniv___closed__2; @@ -26731,16 +27578,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_forall___closed__7() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_forall___closed__6; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_forall___closed__8() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_forall___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_forall___closed__6; +x_3 = l_Lean_Parser_Term_forall___closed__7; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_forall___closed__8() { +lean_object* _init_l_Lean_Parser_Term_forall___closed__9() { _start: { lean_object* x_1; @@ -26748,12 +27605,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_forall___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_forall___closed__9() { +lean_object* _init_l_Lean_Parser_Term_forall___closed__10() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_forall___closed__7; -x_2 = l_Lean_Parser_Term_forall___closed__8; +x_1 = l_Lean_Parser_Term_forall___closed__8; +x_2 = l_Lean_Parser_Term_forall___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); @@ -26764,7 +27621,7 @@ lean_object* _init_l_Lean_Parser_Term_forall() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_forall___closed__9; +x_1 = l_Lean_Parser_Term_forall___closed__10; return x_1; } } @@ -27138,312 +27995,345 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 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_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = l_Lean_Parser_Term_fun___elambda__1___closed__6; -x_9 = l_Lean_Parser_Term_fun___elambda__1___closed__7; -x_10 = l_Lean_Parser_Term_fun___elambda__1___closed__12; -lean_inc(x_1); -x_11 = l_Lean_Parser_unicodeSymbolFnAux(x_8, x_9, x_10, x_1, x_2); -x_12 = lean_ctor_get(x_11, 3); -lean_inc(x_12); -if (lean_obj_tag(x_12) == 0) +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; -x_13 = lean_ctor_get(x_11, 0); -lean_inc(x_13); -x_14 = lean_array_get_size(x_13); -lean_dec(x_13); +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_8, 0); +lean_inc(x_10); +x_11 = lean_array_get_size(x_10); +lean_dec(x_10); +x_12 = l_Lean_Parser_Term_fun___elambda__1___closed__6; +x_13 = l_Lean_Parser_Term_fun___elambda__1___closed__7; +x_14 = l_Lean_Parser_Term_fun___elambda__1___closed__12; lean_inc(x_1); -x_15 = l_Lean_Parser_Term_funBinder___elambda__1(x_1, x_11); +x_15 = l_Lean_Parser_unicodeSymbolFnAux(x_12, x_13, x_14, x_1, x_8); 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; +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +x_18 = lean_array_get_size(x_17); +lean_dec(x_17); lean_inc(x_1); -x_17 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(x_1, x_15); -x_18 = l_Lean_nullKind; -x_19 = l_Lean_Parser_ParserState_mkNode(x_17, x_18, x_14); +x_19 = l_Lean_Parser_Term_funBinder___elambda__1(x_1, 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_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_inc(x_1); -x_21 = l_Lean_Parser_darrow___elambda__1(x_1, x_19); -x_22 = lean_ctor_get(x_21, 3); -lean_inc(x_22); -if (lean_obj_tag(x_22) == 0) +x_21 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(x_1, x_19); +x_22 = l_Lean_nullKind; +x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_18); +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; lean_object* x_26; lean_object* x_27; -x_23 = l_Lean_Parser_termParser___closed__2; -x_24 = lean_unsigned_to_nat(0u); -x_25 = l_Lean_Parser_categoryParser___elambda__1(x_23, x_24, x_1, x_21); -x_26 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_7); -return x_27; -} -else +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_28; lean_object* x_29; -lean_dec(x_22); -lean_dec(x_1); -x_28 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_21, x_28, x_7); -return x_29; -} -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_dec(x_20); -lean_dec(x_1); +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_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_fun___elambda__1___closed__2; -x_31 = l_Lean_Parser_ParserState_mkNode(x_19, x_30, x_7); +x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_11); return x_31; } +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_26); +lean_dec(x_1); +x_32 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_33 = l_Lean_Parser_ParserState_mkNode(x_25, x_32, x_11); +return x_33; +} } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_16); -x_32 = l_Lean_nullKind; -x_33 = l_Lean_Parser_ParserState_mkNode(x_15, x_32, x_14); -x_34 = lean_ctor_get(x_33, 3); -lean_inc(x_34); -if (lean_obj_tag(x_34) == 0) +lean_object* x_34; lean_object* x_35; +lean_dec(x_24); +lean_dec(x_1); +x_34 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_35 = l_Lean_Parser_ParserState_mkNode(x_23, x_34, x_11); +return x_35; +} +} +else { -lean_object* x_35; lean_object* x_36; +lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_20); +x_36 = l_Lean_nullKind; +x_37 = l_Lean_Parser_ParserState_mkNode(x_19, x_36, x_18); +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; lean_inc(x_1); -x_35 = l_Lean_Parser_darrow___elambda__1(x_1, x_33); -x_36 = lean_ctor_get(x_35, 3); -lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) +x_39 = l_Lean_Parser_darrow___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_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; -x_37 = l_Lean_Parser_termParser___closed__2; -x_38 = lean_unsigned_to_nat(0u); -x_39 = l_Lean_Parser_categoryParser___elambda__1(x_37, x_38, x_1, x_35); -x_40 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_41 = l_Lean_Parser_ParserState_mkNode(x_39, x_40, x_7); -return x_41; -} -else -{ -lean_object* x_42; lean_object* x_43; -lean_dec(x_36); -lean_dec(x_1); -x_42 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_43 = l_Lean_Parser_ParserState_mkNode(x_35, x_42, x_7); -return x_43; -} -} -else -{ -lean_object* x_44; lean_object* x_45; -lean_dec(x_34); -lean_dec(x_1); +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_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_Term_fun___elambda__1___closed__2; -x_45 = l_Lean_Parser_ParserState_mkNode(x_33, x_44, x_7); +x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_11); return x_45; } -} -} else { lean_object* x_46; lean_object* x_47; -lean_dec(x_12); +lean_dec(x_40); lean_dec(x_1); x_46 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_47 = l_Lean_Parser_ParserState_mkNode(x_11, x_46, x_7); +x_47 = l_Lean_Parser_ParserState_mkNode(x_39, x_46, x_11); return x_47; } } else { -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_2, 0); -lean_inc(x_48); -x_49 = lean_array_get_size(x_48); -lean_dec(x_48); -x_50 = lean_ctor_get(x_2, 1); -lean_inc(x_50); -lean_inc(x_1); -x_51 = lean_apply_2(x_4, x_1, x_2); -x_52 = lean_ctor_get(x_51, 3); +lean_object* x_48; lean_object* x_49; +lean_dec(x_38); +lean_dec(x_1); +x_48 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_49 = l_Lean_Parser_ParserState_mkNode(x_37, x_48, x_11); +return x_49; +} +} +} +else +{ +lean_object* x_50; lean_object* x_51; +lean_dec(x_16); +lean_dec(x_1); +x_50 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_51 = l_Lean_Parser_ParserState_mkNode(x_15, x_50, x_11); +return x_51; +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_52); -if (lean_obj_tag(x_52) == 0) -{ -lean_dec(x_50); -lean_dec(x_49); -lean_dec(x_1); -return x_51; -} -else -{ -lean_object* x_53; lean_object* x_54; uint8_t x_55; -x_53 = lean_ctor_get(x_52, 0); -lean_inc(x_53); +x_53 = lean_array_get_size(x_52); lean_dec(x_52); -x_54 = lean_ctor_get(x_51, 1); +x_54 = lean_ctor_get(x_2, 1); lean_inc(x_54); -x_55 = lean_nat_dec_eq(x_54, x_50); -lean_dec(x_54); -if (x_55 == 0) +lean_inc(x_1); +x_55 = lean_apply_2(x_4, x_1, x_2); +x_56 = lean_ctor_get(x_55, 3); +lean_inc(x_56); +if (lean_obj_tag(x_56) == 0) { +lean_dec(x_54); lean_dec(x_53); -lean_dec(x_50); -lean_dec(x_49); lean_dec(x_1); -return x_51; +return x_55; } else { -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_inc(x_50); -x_56 = l_Lean_Parser_ParserState_restore(x_51, x_49, x_50); -lean_dec(x_49); +lean_object* x_57; lean_object* x_58; uint8_t x_59; x_57 = lean_ctor_get(x_56, 0); lean_inc(x_57); -x_58 = lean_array_get_size(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_54); +lean_dec(x_58); +if (x_59 == 0) +{ lean_dec(x_57); -x_59 = l_Lean_Parser_Term_fun___elambda__1___closed__6; -x_60 = l_Lean_Parser_Term_fun___elambda__1___closed__7; -x_61 = l_Lean_Parser_Term_fun___elambda__1___closed__12; -lean_inc(x_1); -x_62 = l_Lean_Parser_unicodeSymbolFnAux(x_59, x_60, x_61, x_1, x_56); -x_63 = lean_ctor_get(x_62, 3); -lean_inc(x_63); -if (lean_obj_tag(x_63) == 0) +lean_dec(x_54); +lean_dec(x_53); +lean_dec(x_1); +return x_55; +} +else { -lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; -x_64 = lean_ctor_get(x_62, 0); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_inc(x_54); +x_60 = l_Lean_Parser_ParserState_restore(x_55, x_53, x_54); +lean_dec(x_53); +x_61 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_62 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_63 = l_Lean_Parser_checkRbpLtFn(x_61, x_62, x_1, x_60); +x_64 = lean_ctor_get(x_63, 3); lean_inc(x_64); -x_65 = lean_array_get_size(x_64); -lean_dec(x_64); -lean_inc(x_1); -x_66 = l_Lean_Parser_Term_funBinder___elambda__1(x_1, x_62); -x_67 = lean_ctor_get(x_66, 3); -lean_inc(x_67); -if (lean_obj_tag(x_67) == 0) +if (lean_obj_tag(x_64) == 0) { -lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_65 = lean_ctor_get(x_63, 0); +lean_inc(x_65); +x_66 = lean_array_get_size(x_65); +lean_dec(x_65); +x_67 = l_Lean_Parser_Term_fun___elambda__1___closed__6; +x_68 = l_Lean_Parser_Term_fun___elambda__1___closed__7; +x_69 = l_Lean_Parser_Term_fun___elambda__1___closed__12; lean_inc(x_1); -x_68 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(x_1, x_66); -x_69 = l_Lean_nullKind; -x_70 = l_Lean_Parser_ParserState_mkNode(x_68, x_69, x_65); +x_70 = l_Lean_Parser_unicodeSymbolFnAux(x_67, x_68, x_69, x_1, x_63); 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_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_72 = lean_ctor_get(x_70, 0); +lean_inc(x_72); +x_73 = lean_array_get_size(x_72); +lean_dec(x_72); lean_inc(x_1); -x_72 = l_Lean_Parser_darrow___elambda__1(x_1, x_70); -x_73 = lean_ctor_get(x_72, 3); -lean_inc(x_73); -if (lean_obj_tag(x_73) == 0) +x_74 = l_Lean_Parser_Term_funBinder___elambda__1(x_1, x_70); +x_75 = lean_ctor_get(x_74, 3); +lean_inc(x_75); +if (lean_obj_tag(x_75) == 0) { -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_74 = l_Lean_Parser_termParser___closed__2; -x_75 = lean_unsigned_to_nat(0u); -x_76 = l_Lean_Parser_categoryParser___elambda__1(x_74, x_75, x_1, x_72); -x_77 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_78 = l_Lean_Parser_ParserState_mkNode(x_76, x_77, x_58); -x_79 = l_Lean_Parser_mergeOrElseErrors(x_78, x_53, x_50); -lean_dec(x_50); -return x_79; +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +lean_inc(x_1); +x_76 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_fun___elambda__1___spec__1(x_1, x_74); +x_77 = l_Lean_nullKind; +x_78 = l_Lean_Parser_ParserState_mkNode(x_76, x_77, x_73); +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; +lean_inc(x_1); +x_80 = l_Lean_Parser_darrow___elambda__1(x_1, x_78); +x_81 = lean_ctor_get(x_80, 3); +lean_inc(x_81); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_82 = l_Lean_Parser_termParser___closed__2; +x_83 = lean_unsigned_to_nat(0u); +x_84 = l_Lean_Parser_categoryParser___elambda__1(x_82, x_83, x_1, x_80); +x_85 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_86 = l_Lean_Parser_ParserState_mkNode(x_84, x_85, x_66); +x_87 = l_Lean_Parser_mergeOrElseErrors(x_86, x_57, x_54); +lean_dec(x_54); +return x_87; } else { -lean_object* x_80; lean_object* x_81; lean_object* x_82; -lean_dec(x_73); +lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_81); lean_dec(x_1); -x_80 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_81 = l_Lean_Parser_ParserState_mkNode(x_72, x_80, x_58); -x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_53, x_50); -lean_dec(x_50); -return x_82; +x_88 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_89 = l_Lean_Parser_ParserState_mkNode(x_80, x_88, x_66); +x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_57, x_54); +lean_dec(x_54); +return x_90; } } else { -lean_object* x_83; lean_object* x_84; lean_object* x_85; +lean_object* x_91; lean_object* x_92; lean_object* x_93; +lean_dec(x_79); +lean_dec(x_1); +x_91 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_92 = l_Lean_Parser_ParserState_mkNode(x_78, x_91, x_66); +x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_57, x_54); +lean_dec(x_54); +return x_93; +} +} +else +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_75); +x_94 = l_Lean_nullKind; +x_95 = l_Lean_Parser_ParserState_mkNode(x_74, x_94, x_73); +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_inc(x_1); +x_97 = l_Lean_Parser_darrow___elambda__1(x_1, x_95); +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; lean_object* x_104; +x_99 = l_Lean_Parser_termParser___closed__2; +x_100 = lean_unsigned_to_nat(0u); +x_101 = l_Lean_Parser_categoryParser___elambda__1(x_99, x_100, x_1, x_97); +x_102 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_103 = l_Lean_Parser_ParserState_mkNode(x_101, x_102, x_66); +x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_57, x_54); +lean_dec(x_54); +return x_104; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_98); +lean_dec(x_1); +x_105 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_106 = l_Lean_Parser_ParserState_mkNode(x_97, x_105, x_66); +x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_57, x_54); +lean_dec(x_54); +return x_107; +} +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; +lean_dec(x_96); +lean_dec(x_1); +x_108 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_109 = l_Lean_Parser_ParserState_mkNode(x_95, x_108, x_66); +x_110 = l_Lean_Parser_mergeOrElseErrors(x_109, x_57, x_54); +lean_dec(x_54); +return x_110; +} +} +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_dec(x_71); lean_dec(x_1); -x_83 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_84 = l_Lean_Parser_ParserState_mkNode(x_70, x_83, x_58); -x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_53, x_50); -lean_dec(x_50); -return x_85; +x_111 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_112 = l_Lean_Parser_ParserState_mkNode(x_70, x_111, x_66); +x_113 = l_Lean_Parser_mergeOrElseErrors(x_112, x_57, x_54); +lean_dec(x_54); +return x_113; } } else { -lean_object* x_86; lean_object* x_87; lean_object* x_88; -lean_dec(x_67); -x_86 = l_Lean_nullKind; -x_87 = l_Lean_Parser_ParserState_mkNode(x_66, x_86, x_65); -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_89 = l_Lean_Parser_darrow___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 = l_Lean_Parser_termParser___closed__2; -x_92 = lean_unsigned_to_nat(0u); -x_93 = l_Lean_Parser_categoryParser___elambda__1(x_91, x_92, x_1, x_89); -x_94 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_95 = l_Lean_Parser_ParserState_mkNode(x_93, x_94, x_58); -x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_53, x_50); -lean_dec(x_50); -return x_96; -} -else -{ -lean_object* x_97; lean_object* x_98; lean_object* x_99; -lean_dec(x_90); +lean_object* x_114; +lean_dec(x_64); lean_dec(x_1); -x_97 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_98 = l_Lean_Parser_ParserState_mkNode(x_89, x_97, x_58); -x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_53, x_50); -lean_dec(x_50); -return x_99; -} -} -else -{ -lean_object* x_100; lean_object* x_101; lean_object* x_102; -lean_dec(x_88); -lean_dec(x_1); -x_100 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_101 = l_Lean_Parser_ParserState_mkNode(x_87, x_100, x_58); -x_102 = l_Lean_Parser_mergeOrElseErrors(x_101, x_53, x_50); -lean_dec(x_50); -return x_102; -} -} -} -else -{ -lean_object* x_103; lean_object* x_104; lean_object* x_105; -lean_dec(x_63); -lean_dec(x_1); -x_103 = l_Lean_Parser_Term_fun___elambda__1___closed__2; -x_104 = l_Lean_Parser_ParserState_mkNode(x_62, x_103, x_58); -x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_53, x_50); -lean_dec(x_50); -return x_105; +x_114 = l_Lean_Parser_mergeOrElseErrors(x_63, x_57, x_54); +lean_dec(x_54); +return x_114; } } } @@ -27453,12 +28343,11 @@ return x_105; lean_object* _init_l_Lean_Parser_Term_fun___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Term_fun___elambda__1___closed__6; x_2 = l_Lean_Parser_Term_fun___elambda__1___closed__7; -x_3 = l_Lean_Parser_Term_if___closed__1; -x_4 = l_Lean_Parser_unicodeSymbolInfo(x_1, x_2, x_3); -return x_4; +x_3 = l_Lean_Parser_unicodeSymbolInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_fun___closed__2() { @@ -27468,7 +28357,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_antiquotNestedExpr___closed__3; +x_3 = l_Lean_Parser_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); @@ -27510,16 +28399,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_fun___closed__6() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_fun___closed__5; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_fun___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_fun___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_fun___closed__5; +x_3 = l_Lean_Parser_Term_fun___closed__6; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_fun___closed__7() { +lean_object* _init_l_Lean_Parser_Term_fun___closed__8() { _start: { lean_object* x_1; @@ -27527,12 +28426,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_fun___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_fun___closed__8() { +lean_object* _init_l_Lean_Parser_Term_fun___closed__9() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_fun___closed__6; -x_2 = l_Lean_Parser_Term_fun___closed__7; +x_1 = l_Lean_Parser_Term_fun___closed__7; +x_2 = l_Lean_Parser_Term_fun___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); @@ -27543,7 +28442,7 @@ lean_object* _init_l_Lean_Parser_Term_fun() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_fun___closed__8; +x_1 = l_Lean_Parser_Term_fun___closed__9; return x_1; } } @@ -27581,7 +28480,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_explicitUniv___closed__2; @@ -27618,7 +28517,7 @@ 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_darrow; @@ -30512,11 +31411,10 @@ return x_39; lean_object* _init_l_Lean_Parser_Term_matchAlts___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; +lean_object* x_1; lean_object* x_2; x_1 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__2; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_matchAlts___closed__2() { @@ -31030,439 +31928,474 @@ lean_inc(x_1); x_7 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_7 == 0) { -lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_47; lean_object* x_48; lean_object* x_49; +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_dec(x_6); -x_8 = lean_ctor_get(x_2, 0); -lean_inc(x_8); -x_9 = lean_array_get_size(x_8); -lean_dec(x_8); -x_47 = lean_ctor_get(x_2, 1); -lean_inc(x_47); -lean_inc(x_1); -x_48 = l_Lean_Parser_tokenFn(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; -x_50 = lean_ctor_get(x_48, 0); -lean_inc(x_50); -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_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_match___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_match___elambda__1___closed__15; -x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_55, x_47); -x_10 = x_56; -goto block_46; -} -else -{ -lean_dec(x_47); -x_10 = x_48; -goto block_46; -} -} -else -{ -lean_object* x_57; lean_object* x_58; -lean_dec(x_51); -x_57 = l_Lean_Parser_Term_match___elambda__1___closed__15; -x_58 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_57, x_47); -x_10 = x_58; -goto block_46; -} -} -else -{ -lean_object* x_59; lean_object* x_60; -lean_dec(x_49); -x_59 = l_Lean_Parser_Term_match___elambda__1___closed__15; -x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_48, x_59, x_47); -x_10 = x_60; -goto block_46; -} -block_46: -{ -lean_object* x_11; +x_8 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_9 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_10 = l_Lean_Parser_checkRbpLtFn(x_8, x_9, x_1, x_2); x_11 = lean_ctor_get(x_10, 3); lean_inc(x_11); if (lean_obj_tag(x_11) == 0) { -uint8_t x_12; lean_object* x_13; lean_object* x_14; -x_12 = 0; +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_51; lean_object* x_52; lean_object* x_53; +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_51 = lean_ctor_get(x_10, 1); +lean_inc(x_51); lean_inc(x_1); -x_13 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_12, x_12, x_1, x_10); -x_14 = lean_ctor_get(x_13, 3); -lean_inc(x_14); -if (lean_obj_tag(x_14) == 0) +x_52 = l_Lean_Parser_tokenFn(x_1, x_10); +x_53 = lean_ctor_get(x_52, 3); +lean_inc(x_53); +if (lean_obj_tag(x_53) == 0) { -lean_object* x_15; lean_object* x_16; +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); +lean_dec(x_55); +x_57 = l_Lean_Parser_Term_match___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; +x_59 = l_Lean_Parser_Term_match___elambda__1___closed__15; +x_60 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_59, x_51); +x_14 = x_60; +goto block_50; +} +else +{ +lean_dec(x_51); +x_14 = x_52; +goto block_50; +} +} +else +{ +lean_object* x_61; lean_object* x_62; +lean_dec(x_55); +x_61 = l_Lean_Parser_Term_match___elambda__1___closed__15; +x_62 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_61, x_51); +x_14 = x_62; +goto block_50; +} +} +else +{ +lean_object* x_63; lean_object* x_64; +lean_dec(x_53); +x_63 = l_Lean_Parser_Term_match___elambda__1___closed__15; +x_64 = l_Lean_Parser_ParserState_mkErrorsAt(x_52, x_63, x_51); +x_14 = x_64; +goto block_50; +} +block_50: +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 3); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; lean_object* x_17; lean_object* x_18; +x_16 = 0; lean_inc(x_1); -x_15 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_13); -x_16 = lean_ctor_get(x_15, 3); -lean_inc(x_16); -if (lean_obj_tag(x_16) == 0) +x_17 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_16, x_16, x_1, x_14); +x_18 = lean_ctor_get(x_17, 3); +lean_inc(x_18); +if (lean_obj_tag(x_18) == 0) { -lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_17 = lean_ctor_get(x_15, 1); -lean_inc(x_17); +lean_object* x_19; lean_object* x_20; lean_inc(x_1); -x_18 = l_Lean_Parser_tokenFn(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_object* x_21; -x_20 = lean_ctor_get(x_18, 0); +x_19 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_17); +x_20 = lean_ctor_get(x_19, 3); lean_inc(x_20); -x_21 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_20); -lean_dec(x_20); -if (lean_obj_tag(x_21) == 2) +if (lean_obj_tag(x_20) == 0) { -lean_object* x_22; lean_object* x_23; uint8_t x_24; -x_22 = lean_ctor_get(x_21, 1); -lean_inc(x_22); -lean_dec(x_21); -x_23 = l_Lean_Parser_Term_match___elambda__1___closed__8; -x_24 = lean_string_dec_eq(x_22, x_23); -lean_dec(x_22); -if (x_24 == 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_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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +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); +lean_dec(x_25); +x_27 = l_Lean_Parser_Term_match___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_dec(x_4); lean_dec(x_1); -x_25 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_25, x_17); -x_27 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_9); -return x_28; +x_29 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_29, x_21); +x_31 = l_Lean_Parser_Term_match___elambda__1___closed__2; +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_13); +return x_32; } else { -lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_17); -x_29 = lean_apply_2(x_4, x_1, x_18); -x_30 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_9); -return x_31; -} -} -else -{ -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_dec(x_21); -lean_dec(x_4); -lean_dec(x_1); -x_32 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_32, x_17); +x_33 = lean_apply_2(x_4, x_1, x_22); x_34 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_9); +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_13); return x_35; } } else { lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; -lean_dec(x_19); +lean_dec(x_25); lean_dec(x_4); lean_dec(x_1); x_36 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_36, x_17); +x_37 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_36, x_21); x_38 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_9); +x_39 = l_Lean_Parser_ParserState_mkNode(x_37, x_38, x_13); return x_39; } } else { -lean_object* x_40; lean_object* x_41; -lean_dec(x_16); -lean_dec(x_4); -lean_dec(x_1); -x_40 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_41 = l_Lean_Parser_ParserState_mkNode(x_15, x_40, x_9); -return x_41; -} -} -else -{ -lean_object* x_42; lean_object* x_43; -lean_dec(x_14); +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_dec(x_23); lean_dec(x_4); lean_dec(x_1); +x_40 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_41 = l_Lean_Parser_ParserState_mkErrorsAt(x_22, x_40, x_21); x_42 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_43 = l_Lean_Parser_ParserState_mkNode(x_13, x_42, x_9); +x_43 = l_Lean_Parser_ParserState_mkNode(x_41, x_42, x_13); return x_43; } } else { lean_object* x_44; lean_object* x_45; -lean_dec(x_11); +lean_dec(x_20); lean_dec(x_4); lean_dec(x_1); x_44 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_45 = l_Lean_Parser_ParserState_mkNode(x_10, x_44, x_9); +x_45 = l_Lean_Parser_ParserState_mkNode(x_19, x_44, x_13); return x_45; } } +else +{ +lean_object* x_46; lean_object* x_47; +lean_dec(x_18); +lean_dec(x_4); +lean_dec(x_1); +x_46 = l_Lean_Parser_Term_match___elambda__1___closed__2; +x_47 = l_Lean_Parser_ParserState_mkNode(x_17, x_46, x_13); +return x_47; +} } else { -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_2, 0); -lean_inc(x_61); -x_62 = lean_array_get_size(x_61); -lean_dec(x_61); -x_63 = lean_ctor_get(x_2, 1); -lean_inc(x_63); -lean_inc(x_1); -x_64 = lean_apply_2(x_6, x_1, x_2); -x_65 = lean_ctor_get(x_64, 3); +lean_object* x_48; lean_object* x_49; +lean_dec(x_15); +lean_dec(x_4); +lean_dec(x_1); +x_48 = l_Lean_Parser_Term_match___elambda__1___closed__2; +x_49 = l_Lean_Parser_ParserState_mkNode(x_14, x_48, x_13); +return x_49; +} +} +} +else +{ +lean_dec(x_11); +lean_dec(x_4); +lean_dec(x_1); +return x_10; +} +} +else +{ +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_2, 0); lean_inc(x_65); -if (lean_obj_tag(x_65) == 0) -{ -lean_dec(x_63); -lean_dec(x_62); -lean_dec(x_4); -lean_dec(x_1); -return x_64; -} -else -{ -lean_object* x_66; lean_object* x_67; uint8_t x_68; -x_66 = lean_ctor_get(x_65, 0); -lean_inc(x_66); +x_66 = lean_array_get_size(x_65); lean_dec(x_65); -x_67 = lean_ctor_get(x_64, 1); +x_67 = lean_ctor_get(x_2, 1); lean_inc(x_67); -x_68 = lean_nat_dec_eq(x_67, x_63); -lean_dec(x_67); -if (x_68 == 0) +lean_inc(x_1); +x_68 = lean_apply_2(x_6, x_1, x_2); +x_69 = lean_ctor_get(x_68, 3); +lean_inc(x_69); +if (lean_obj_tag(x_69) == 0) { +lean_dec(x_67); lean_dec(x_66); -lean_dec(x_63); -lean_dec(x_62); lean_dec(x_4); lean_dec(x_1); -return x_64; +return x_68; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_116; lean_object* x_117; -lean_inc(x_63); -x_69 = l_Lean_Parser_ParserState_restore(x_64, x_62, x_63); -lean_dec(x_62); +lean_object* x_70; lean_object* x_71; uint8_t x_72; x_70 = lean_ctor_get(x_69, 0); lean_inc(x_70); -x_71 = lean_array_get_size(x_70); +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_dec(x_70); +lean_dec(x_67); +lean_dec(x_66); +lean_dec(x_4); +lean_dec(x_1); +return x_68; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +lean_inc(x_67); +x_73 = l_Lean_Parser_ParserState_restore(x_68, x_66, x_67); +lean_dec(x_66); +x_74 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_75 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_76 = l_Lean_Parser_checkRbpLtFn(x_74, x_75, x_1, x_73); +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; lean_object* x_80; lean_object* x_124; lean_object* x_125; lean_object* x_126; +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_124 = lean_ctor_get(x_76, 1); +lean_inc(x_124); lean_inc(x_1); -x_116 = l_Lean_Parser_tokenFn(x_1, x_69); -x_117 = lean_ctor_get(x_116, 3); -lean_inc(x_117); -if (lean_obj_tag(x_117) == 0) -{ -lean_object* x_118; lean_object* x_119; -x_118 = lean_ctor_get(x_116, 0); -lean_inc(x_118); -x_119 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_118); -lean_dec(x_118); -if (lean_obj_tag(x_119) == 2) -{ -lean_object* x_120; lean_object* x_121; uint8_t x_122; -x_120 = lean_ctor_get(x_119, 1); -lean_inc(x_120); -lean_dec(x_119); -x_121 = l_Lean_Parser_Term_match___elambda__1___closed__6; -x_122 = lean_string_dec_eq(x_120, x_121); -lean_dec(x_120); -if (x_122 == 0) -{ -lean_object* x_123; lean_object* x_124; -x_123 = l_Lean_Parser_Term_match___elambda__1___closed__15; -lean_inc(x_63); -x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_116, x_123, x_63); -x_72 = x_124; -goto block_115; -} -else -{ -x_72 = x_116; -goto block_115; -} -} -else -{ -lean_object* x_125; lean_object* x_126; -lean_dec(x_119); -x_125 = l_Lean_Parser_Term_match___elambda__1___closed__15; -lean_inc(x_63); -x_126 = l_Lean_Parser_ParserState_mkErrorsAt(x_116, x_125, x_63); -x_72 = x_126; -goto block_115; -} -} -else +x_125 = l_Lean_Parser_tokenFn(x_1, x_76); +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; -lean_dec(x_117); -x_127 = l_Lean_Parser_Term_match___elambda__1___closed__15; -lean_inc(x_63); -x_128 = l_Lean_Parser_ParserState_mkErrorsAt(x_116, x_127, x_63); -x_72 = x_128; -goto block_115; +x_127 = lean_ctor_get(x_125, 0); +lean_inc(x_127); +x_128 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_127); +lean_dec(x_127); +if (lean_obj_tag(x_128) == 2) +{ +lean_object* x_129; lean_object* x_130; uint8_t x_131; +x_129 = lean_ctor_get(x_128, 1); +lean_inc(x_129); +lean_dec(x_128); +x_130 = l_Lean_Parser_Term_match___elambda__1___closed__6; +x_131 = lean_string_dec_eq(x_129, x_130); +lean_dec(x_129); +if (x_131 == 0) +{ +lean_object* x_132; lean_object* x_133; +x_132 = l_Lean_Parser_Term_match___elambda__1___closed__15; +x_133 = l_Lean_Parser_ParserState_mkErrorsAt(x_125, x_132, x_124); +x_80 = x_133; +goto block_123; } -block_115: +else { -lean_object* x_73; -x_73 = lean_ctor_get(x_72, 3); -lean_inc(x_73); -if (lean_obj_tag(x_73) == 0) +lean_dec(x_124); +x_80 = x_125; +goto block_123; +} +} +else { -uint8_t x_74; lean_object* x_75; lean_object* x_76; -x_74 = 0; -lean_inc(x_1); -x_75 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_74, x_74, 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_134; lean_object* x_135; +lean_dec(x_128); +x_134 = l_Lean_Parser_Term_match___elambda__1___closed__15; +x_135 = l_Lean_Parser_ParserState_mkErrorsAt(x_125, x_134, x_124); +x_80 = x_135; +goto block_123; +} +} +else { -lean_object* x_77; lean_object* x_78; -lean_inc(x_1); -x_77 = l_Lean_Parser_Term_optType___elambda__1(x_1, x_75); -x_78 = lean_ctor_get(x_77, 3); -lean_inc(x_78); -if (lean_obj_tag(x_78) == 0) +lean_object* x_136; lean_object* x_137; +lean_dec(x_126); +x_136 = l_Lean_Parser_Term_match___elambda__1___closed__15; +x_137 = l_Lean_Parser_ParserState_mkErrorsAt(x_125, x_136, x_124); +x_80 = x_137; +goto block_123; +} +block_123: { -lean_object* x_79; lean_object* x_80; lean_object* x_81; -x_79 = lean_ctor_get(x_77, 1); -lean_inc(x_79); -lean_inc(x_1); -x_80 = l_Lean_Parser_tokenFn(x_1, x_77); +lean_object* x_81; x_81 = lean_ctor_get(x_80, 3); 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_checkStackTopFn___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); +uint8_t x_82; lean_object* x_83; lean_object* x_84; +x_82 = 0; +lean_inc(x_1); +x_83 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_tupleTail___elambda__1___spec__1(x_82, x_82, x_1, x_80); +x_84 = lean_ctor_get(x_83, 3); lean_inc(x_84); -lean_dec(x_83); -x_85 = l_Lean_Parser_Term_match___elambda__1___closed__8; -x_86 = lean_string_dec_eq(x_84, x_85); -lean_dec(x_84); -if (x_86 == 0) +if (lean_obj_tag(x_84) == 0) { -lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +lean_object* x_85; lean_object* x_86; +lean_inc(x_1); +x_85 = l_Lean_Parser_Term_optType___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) +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_85, 1); +lean_inc(x_87); +lean_inc(x_1); +x_88 = l_Lean_Parser_tokenFn(x_1, x_85); +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_Term_match___elambda__1___closed__8; +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; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_dec(x_4); lean_dec(x_1); -x_87 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_87, x_79); -x_89 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_90 = l_Lean_Parser_ParserState_mkNode(x_88, x_89, x_71); -x_91 = l_Lean_Parser_mergeOrElseErrors(x_90, x_66, x_63); -lean_dec(x_63); -return x_91; +x_95 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_96 = l_Lean_Parser_ParserState_mkErrorsAt(x_88, x_95, x_87); +x_97 = l_Lean_Parser_Term_match___elambda__1___closed__2; +x_98 = l_Lean_Parser_ParserState_mkNode(x_96, x_97, x_79); +x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_70, x_67); +lean_dec(x_67); +return x_99; } else { -lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; -lean_dec(x_79); -x_92 = lean_apply_2(x_4, x_1, x_80); -x_93 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_94 = l_Lean_Parser_ParserState_mkNode(x_92, x_93, x_71); -x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_66, x_63); -lean_dec(x_63); -return x_95; +lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +lean_dec(x_87); +x_100 = lean_apply_2(x_4, x_1, x_88); +x_101 = l_Lean_Parser_Term_match___elambda__1___closed__2; +x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_79); +x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_70, x_67); +lean_dec(x_67); +return x_103; } } else { -lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; -lean_dec(x_83); -lean_dec(x_4); -lean_dec(x_1); -x_96 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_97 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_96, x_79); -x_98 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_99 = l_Lean_Parser_ParserState_mkNode(x_97, x_98, x_71); -x_100 = l_Lean_Parser_mergeOrElseErrors(x_99, x_66, x_63); -lean_dec(x_63); -return x_100; -} -} -else -{ -lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; -lean_dec(x_81); -lean_dec(x_4); -lean_dec(x_1); -x_101 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_102 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_101, x_79); -x_103 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_104 = l_Lean_Parser_ParserState_mkNode(x_102, x_103, x_71); -x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_66, x_63); -lean_dec(x_63); -return x_105; -} -} -else -{ -lean_object* x_106; lean_object* x_107; lean_object* x_108; -lean_dec(x_78); +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_91); lean_dec(x_4); lean_dec(x_1); +x_104 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_105 = l_Lean_Parser_ParserState_mkErrorsAt(x_88, x_104, x_87); x_106 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_107 = l_Lean_Parser_ParserState_mkNode(x_77, x_106, x_71); -x_108 = l_Lean_Parser_mergeOrElseErrors(x_107, x_66, x_63); -lean_dec(x_63); +x_107 = l_Lean_Parser_ParserState_mkNode(x_105, x_106, x_79); +x_108 = l_Lean_Parser_mergeOrElseErrors(x_107, x_70, x_67); +lean_dec(x_67); return x_108; } } else { -lean_object* x_109; lean_object* x_110; lean_object* x_111; -lean_dec(x_76); +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; +lean_dec(x_89); lean_dec(x_4); lean_dec(x_1); -x_109 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_110 = l_Lean_Parser_ParserState_mkNode(x_75, x_109, x_71); -x_111 = l_Lean_Parser_mergeOrElseErrors(x_110, x_66, x_63); -lean_dec(x_63); -return x_111; +x_109 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_110 = l_Lean_Parser_ParserState_mkErrorsAt(x_88, x_109, x_87); +x_111 = l_Lean_Parser_Term_match___elambda__1___closed__2; +x_112 = l_Lean_Parser_ParserState_mkNode(x_110, x_111, x_79); +x_113 = l_Lean_Parser_mergeOrElseErrors(x_112, x_70, x_67); +lean_dec(x_67); +return x_113; } } else { -lean_object* x_112; lean_object* x_113; lean_object* x_114; -lean_dec(x_73); +lean_object* x_114; lean_object* x_115; lean_object* x_116; +lean_dec(x_86); lean_dec(x_4); lean_dec(x_1); -x_112 = l_Lean_Parser_Term_match___elambda__1___closed__2; -x_113 = l_Lean_Parser_ParserState_mkNode(x_72, x_112, x_71); -x_114 = l_Lean_Parser_mergeOrElseErrors(x_113, x_66, x_63); -lean_dec(x_63); -return x_114; +x_114 = l_Lean_Parser_Term_match___elambda__1___closed__2; +x_115 = l_Lean_Parser_ParserState_mkNode(x_85, x_114, x_79); +x_116 = l_Lean_Parser_mergeOrElseErrors(x_115, x_70, x_67); +lean_dec(x_67); +return x_116; } } +else +{ +lean_object* x_117; lean_object* x_118; lean_object* x_119; +lean_dec(x_84); +lean_dec(x_4); +lean_dec(x_1); +x_117 = l_Lean_Parser_Term_match___elambda__1___closed__2; +x_118 = l_Lean_Parser_ParserState_mkNode(x_83, x_117, x_79); +x_119 = l_Lean_Parser_mergeOrElseErrors(x_118, x_70, x_67); +lean_dec(x_67); +return x_119; +} +} +else +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; +lean_dec(x_81); +lean_dec(x_4); +lean_dec(x_1); +x_120 = l_Lean_Parser_Term_match___elambda__1___closed__2; +x_121 = l_Lean_Parser_ParserState_mkNode(x_80, x_120, x_79); +x_122 = l_Lean_Parser_mergeOrElseErrors(x_121, x_70, x_67); +lean_dec(x_67); +return x_122; +} +} +} +else +{ +lean_object* x_138; +lean_dec(x_77); +lean_dec(x_4); +lean_dec(x_1); +x_138 = l_Lean_Parser_mergeOrElseErrors(x_76, x_70, x_67); +lean_dec(x_67); +return x_138; +} } } } @@ -31471,21 +32404,19 @@ return x_114; lean_object* _init_l_Lean_Parser_Term_match___closed__1() { _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_match___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_match___closed__2() { _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_match___elambda__1___closed__8; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_match___closed__3() { @@ -31545,16 +32476,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_match___closed__8() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_match___closed__7; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_match___closed__9() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_match___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_match___closed__7; +x_3 = l_Lean_Parser_Term_match___closed__8; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_match___closed__9() { +lean_object* _init_l_Lean_Parser_Term_match___closed__10() { _start: { lean_object* x_1; @@ -31562,12 +32503,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_match___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_match___closed__10() { +lean_object* _init_l_Lean_Parser_Term_match___closed__11() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_match___closed__8; -x_2 = l_Lean_Parser_Term_match___closed__9; +x_1 = l_Lean_Parser_Term_match___closed__9; +x_2 = l_Lean_Parser_Term_match___closed__10; x_3 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_3, 0, x_1); lean_ctor_set(x_3, 1, x_2); @@ -31578,7 +32519,7 @@ lean_object* _init_l_Lean_Parser_Term_match() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_match___closed__10; +x_1 = l_Lean_Parser_Term_match___closed__11; return x_1; } } @@ -31694,227 +32635,260 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_18 = lean_ctor_get(x_2, 1); -lean_inc(x_18); -lean_inc(x_1); -x_19 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_21 = lean_ctor_get(x_19, 0); -lean_inc(x_21); -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); -lean_dec(x_22); -x_24 = l_Lean_Parser_Term_nomatch___elambda__1___closed__6; -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; -x_26 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); -x_8 = x_27; -goto block_17; -} -else -{ -lean_dec(x_18); -x_8 = x_19; -goto block_17; -} -} -else -{ -lean_object* x_28; lean_object* x_29; -lean_dec(x_22); -x_28 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_28, x_18); -x_8 = x_29; -goto block_17; -} -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_dec(x_20); -x_30 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); -x_8 = x_31; -goto block_17; -} -block_17: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(0u); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); -x_13 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7); -return x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_22; lean_object* x_23; lean_object* x_24; +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_22 = lean_ctor_get(x_8, 1); +lean_inc(x_22); +lean_inc(x_1); +x_23 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_25 = lean_ctor_get(x_23, 0); +lean_inc(x_25); +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); +lean_dec(x_26); +x_28 = l_Lean_Parser_Term_nomatch___elambda__1___closed__6; +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; +x_30 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); +x_12 = x_31; +goto block_21; +} +else +{ +lean_dec(x_22); +x_12 = x_23; +goto block_21; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_26); +x_32 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22); +x_12 = x_33; +goto block_21; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_24); +x_34 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22); +x_12 = x_35; +goto block_21; +} +block_21: +{ +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_18; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(0u); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_11); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_12, x_19, x_11); +return x_20; +} +} } else { -lean_object* x_15; lean_object* x_16; lean_dec(x_9); lean_dec(x_1); -x_15 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_8, x_15, x_7); -return x_16; -} +return x_8; } } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_32 = lean_ctor_get(x_2, 0); -lean_inc(x_32); -x_33 = lean_array_get_size(x_32); -lean_dec(x_32); -x_34 = lean_ctor_get(x_2, 1); -lean_inc(x_34); -lean_inc(x_1); -x_35 = lean_apply_2(x_4, x_1, x_2); -x_36 = lean_ctor_get(x_35, 3); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_2, 0); lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) -{ -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_1); -return x_35; -} -else -{ -lean_object* x_37; lean_object* x_38; uint8_t x_39; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); +x_37 = lean_array_get_size(x_36); lean_dec(x_36); -x_38 = lean_ctor_get(x_35, 1); +x_38 = lean_ctor_get(x_2, 1); lean_inc(x_38); -x_39 = lean_nat_dec_eq(x_38, x_34); -lean_dec(x_38); -if (x_39 == 0) +lean_inc(x_1); +x_39 = lean_apply_2(x_4, x_1, x_2); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { +lean_dec(x_38); lean_dec(x_37); -lean_dec(x_34); -lean_dec(x_33); lean_dec(x_1); -return x_35; +return x_39; } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_55; lean_object* x_56; -lean_inc(x_34); -x_40 = l_Lean_Parser_ParserState_restore(x_35, x_33, x_34); -lean_dec(x_33); +lean_object* x_41; lean_object* x_42; uint8_t x_43; x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -x_42 = lean_array_get_size(x_41); +lean_dec(x_40); +x_42 = lean_ctor_get(x_39, 1); +lean_inc(x_42); +x_43 = lean_nat_dec_eq(x_42, x_38); +lean_dec(x_42); +if (x_43 == 0) +{ lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_37); +lean_dec(x_1); +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_inc(x_38); +x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); +lean_dec(x_37); +x_45 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_46 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_47 = l_Lean_Parser_checkRbpLtFn(x_45, x_46, x_1, x_44); +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_63; lean_object* x_64; lean_object* x_65; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +x_63 = lean_ctor_get(x_47, 1); +lean_inc(x_63); lean_inc(x_1); -x_55 = l_Lean_Parser_tokenFn(x_1, x_40); -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_nomatch___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_nomatch___elambda__1___closed__9; -lean_inc(x_34); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_34); -x_43 = x_63; -goto block_54; -} -else -{ -x_43 = x_55; -goto block_54; -} -} -else -{ -lean_object* x_64; lean_object* x_65; -lean_dec(x_58); -x_64 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; -lean_inc(x_34); -x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_34); -x_43 = x_65; -goto block_54; -} -} -else +x_64 = l_Lean_Parser_tokenFn(x_1, x_47); +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_dec(x_56); -x_66 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; -lean_inc(x_34); -x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_34); -x_43 = x_67; -goto block_54; -} -block_54: +x_66 = lean_ctor_get(x_64, 0); +lean_inc(x_66); +x_67 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_66); +lean_dec(x_66); +if (lean_obj_tag(x_67) == 2) { -lean_object* x_44; -x_44 = lean_ctor_get(x_43, 3); -lean_inc(x_44); -if (lean_obj_tag(x_44) == 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_nomatch___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_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_Term_nomatch___elambda__1___closed__2; -x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_42); -x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_37, x_34); -lean_dec(x_34); -return x_50; +lean_object* x_71; lean_object* x_72; +x_71 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_63); +x_51 = x_72; +goto block_62; } 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_Term_nomatch___elambda__1___closed__2; -x_52 = l_Lean_Parser_ParserState_mkNode(x_43, x_51, x_42); -x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_37, x_34); -lean_dec(x_34); -return x_53; +lean_dec(x_63); +x_51 = x_64; +goto block_62; } } +else +{ +lean_object* x_73; lean_object* x_74; +lean_dec(x_67); +x_73 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; +x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_63); +x_51 = x_74; +goto block_62; +} +} +else +{ +lean_object* x_75; lean_object* x_76; +lean_dec(x_65); +x_75 = l_Lean_Parser_Term_nomatch___elambda__1___closed__9; +x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_63); +x_51 = x_76; +goto block_62; +} +block_62: +{ +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; lean_object* x_57; lean_object* x_58; +x_53 = l_Lean_Parser_termParser___closed__2; +x_54 = lean_unsigned_to_nat(0u); +x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_51); +x_56 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2; +x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_50); +x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_41, x_38); +lean_dec(x_38); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_dec(x_52); +lean_dec(x_1); +x_59 = l_Lean_Parser_Term_nomatch___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_51, x_59, x_50); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_41, x_38); +lean_dec(x_38); +return x_61; +} +} +} +else +{ +lean_object* x_77; +lean_dec(x_48); +lean_dec(x_1); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_47, x_41, x_38); +lean_dec(x_38); +return x_77; +} } } } @@ -31923,18 +32897,17 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_nomatch___closed__1() { _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_nomatch___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_nomatch___closed__1; @@ -31955,16 +32928,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_nomatch___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_nomatch___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_nomatch___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_nomatch___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_nomatch___closed__3; +x_3 = l_Lean_Parser_Term_nomatch___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_nomatch___closed__5() { +lean_object* _init_l_Lean_Parser_Term_nomatch___closed__6() { _start: { lean_object* x_1; @@ -31972,12 +32955,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_nomatch___elambda__1), 2, 0) return x_1; } } -lean_object* _init_l_Lean_Parser_Term_nomatch___closed__6() { +lean_object* _init_l_Lean_Parser_Term_nomatch___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_nomatch___closed__4; -x_2 = l_Lean_Parser_Term_nomatch___closed__5; +x_1 = l_Lean_Parser_Term_nomatch___closed__5; +x_2 = l_Lean_Parser_Term_nomatch___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); @@ -31988,7 +32971,7 @@ lean_object* _init_l_Lean_Parser_Term_nomatch() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_nomatch___closed__6; +x_1 = l_Lean_Parser_Term_nomatch___closed__7; return x_1; } } @@ -32104,227 +33087,260 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_18 = lean_ctor_get(x_2, 1); -lean_inc(x_18); -lean_inc(x_1); -x_19 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_21 = lean_ctor_get(x_19, 0); -lean_inc(x_21); -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); -lean_dec(x_22); -x_24 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__6; -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; -x_26 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); -x_8 = x_27; -goto block_17; -} -else -{ -lean_dec(x_18); -x_8 = x_19; -goto block_17; -} -} -else -{ -lean_object* x_28; lean_object* x_29; -lean_dec(x_22); -x_28 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_28, x_18); -x_8 = x_29; -goto block_17; -} -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_dec(x_20); -x_30 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); -x_8 = x_31; -goto block_17; -} -block_17: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(0u); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); -x_13 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7); -return x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_22; lean_object* x_23; lean_object* x_24; +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_22 = lean_ctor_get(x_8, 1); +lean_inc(x_22); +lean_inc(x_1); +x_23 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_25 = lean_ctor_get(x_23, 0); +lean_inc(x_25); +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); +lean_dec(x_26); +x_28 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__6; +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; +x_30 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); +x_12 = x_31; +goto block_21; +} +else +{ +lean_dec(x_22); +x_12 = x_23; +goto block_21; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_26); +x_32 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22); +x_12 = x_33; +goto block_21; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_24); +x_34 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22); +x_12 = x_35; +goto block_21; +} +block_21: +{ +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_18; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(0u); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_11); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_12, x_19, x_11); +return x_20; +} +} } else { -lean_object* x_15; lean_object* x_16; lean_dec(x_9); lean_dec(x_1); -x_15 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_8, x_15, x_7); -return x_16; -} +return x_8; } } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_32 = lean_ctor_get(x_2, 0); -lean_inc(x_32); -x_33 = lean_array_get_size(x_32); -lean_dec(x_32); -x_34 = lean_ctor_get(x_2, 1); -lean_inc(x_34); -lean_inc(x_1); -x_35 = lean_apply_2(x_4, x_1, x_2); -x_36 = lean_ctor_get(x_35, 3); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_2, 0); lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) -{ -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_1); -return x_35; -} -else -{ -lean_object* x_37; lean_object* x_38; uint8_t x_39; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); +x_37 = lean_array_get_size(x_36); lean_dec(x_36); -x_38 = lean_ctor_get(x_35, 1); +x_38 = lean_ctor_get(x_2, 1); lean_inc(x_38); -x_39 = lean_nat_dec_eq(x_38, x_34); -lean_dec(x_38); -if (x_39 == 0) +lean_inc(x_1); +x_39 = lean_apply_2(x_4, x_1, x_2); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { +lean_dec(x_38); lean_dec(x_37); -lean_dec(x_34); -lean_dec(x_33); lean_dec(x_1); -return x_35; +return x_39; } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_55; lean_object* x_56; -lean_inc(x_34); -x_40 = l_Lean_Parser_ParserState_restore(x_35, x_33, x_34); -lean_dec(x_33); +lean_object* x_41; lean_object* x_42; uint8_t x_43; x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -x_42 = lean_array_get_size(x_41); +lean_dec(x_40); +x_42 = lean_ctor_get(x_39, 1); +lean_inc(x_42); +x_43 = lean_nat_dec_eq(x_42, x_38); +lean_dec(x_42); +if (x_43 == 0) +{ lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_37); +lean_dec(x_1); +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_inc(x_38); +x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); +lean_dec(x_37); +x_45 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_46 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_47 = l_Lean_Parser_checkRbpLtFn(x_45, x_46, x_1, x_44); +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_63; lean_object* x_64; lean_object* x_65; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +x_63 = lean_ctor_get(x_47, 1); +lean_inc(x_63); lean_inc(x_1); -x_55 = l_Lean_Parser_tokenFn(x_1, x_40); -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_parser_x21___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_parser_x21___elambda__1___closed__9; -lean_inc(x_34); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_34); -x_43 = x_63; -goto block_54; -} -else -{ -x_43 = x_55; -goto block_54; -} -} -else -{ -lean_object* x_64; lean_object* x_65; -lean_dec(x_58); -x_64 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; -lean_inc(x_34); -x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_34); -x_43 = x_65; -goto block_54; -} -} -else +x_64 = l_Lean_Parser_tokenFn(x_1, x_47); +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_dec(x_56); -x_66 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; -lean_inc(x_34); -x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_34); -x_43 = x_67; -goto block_54; -} -block_54: +x_66 = lean_ctor_get(x_64, 0); +lean_inc(x_66); +x_67 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_66); +lean_dec(x_66); +if (lean_obj_tag(x_67) == 2) { -lean_object* x_44; -x_44 = lean_ctor_get(x_43, 3); -lean_inc(x_44); -if (lean_obj_tag(x_44) == 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_parser_x21___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_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_Term_parser_x21___elambda__1___closed__2; -x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_42); -x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_37, x_34); -lean_dec(x_34); -return x_50; +lean_object* x_71; lean_object* x_72; +x_71 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_63); +x_51 = x_72; +goto block_62; } 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_Term_parser_x21___elambda__1___closed__2; -x_52 = l_Lean_Parser_ParserState_mkNode(x_43, x_51, x_42); -x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_37, x_34); -lean_dec(x_34); -return x_53; +lean_dec(x_63); +x_51 = x_64; +goto block_62; } } +else +{ +lean_object* x_73; lean_object* x_74; +lean_dec(x_67); +x_73 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; +x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_63); +x_51 = x_74; +goto block_62; +} +} +else +{ +lean_object* x_75; lean_object* x_76; +lean_dec(x_65); +x_75 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__9; +x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_63); +x_51 = x_76; +goto block_62; +} +block_62: +{ +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; lean_object* x_57; lean_object* x_58; +x_53 = l_Lean_Parser_termParser___closed__2; +x_54 = lean_unsigned_to_nat(0u); +x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_51); +x_56 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2; +x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_50); +x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_41, x_38); +lean_dec(x_38); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_dec(x_52); +lean_dec(x_1); +x_59 = l_Lean_Parser_Term_parser_x21___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_51, x_59, x_50); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_41, x_38); +lean_dec(x_38); +return x_61; +} +} +} +else +{ +lean_object* x_77; +lean_dec(x_48); +lean_dec(x_1); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_47, x_41, x_38); +lean_dec(x_38); +return x_77; +} } } } @@ -32333,18 +33349,17 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_parser_x21___closed__1() { _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_parser_x21___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_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; @@ -32365,16 +33380,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_parser_x21___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_parser_x21___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_parser_x21___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_parser_x21___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_parser_x21___closed__3; +x_3 = l_Lean_Parser_Term_parser_x21___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_parser_x21___closed__5() { +lean_object* _init_l_Lean_Parser_Term_parser_x21___closed__6() { _start: { lean_object* x_1; @@ -32382,12 +33407,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_parser_x21___elambda__1), 2, return x_1; } } -lean_object* _init_l_Lean_Parser_Term_parser_x21___closed__6() { +lean_object* _init_l_Lean_Parser_Term_parser_x21___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_parser_x21___closed__4; -x_2 = l_Lean_Parser_Term_parser_x21___closed__5; +x_1 = l_Lean_Parser_Term_parser_x21___closed__5; +x_2 = l_Lean_Parser_Term_parser_x21___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); @@ -32398,7 +33423,7 @@ lean_object* _init_l_Lean_Parser_Term_parser_x21() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_parser_x21___closed__6; +x_1 = l_Lean_Parser_Term_parser_x21___closed__7; return x_1; } } @@ -32514,227 +33539,260 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_18 = lean_ctor_get(x_2, 1); -lean_inc(x_18); -lean_inc(x_1); -x_19 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_21 = lean_ctor_get(x_19, 0); -lean_inc(x_21); -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); -lean_dec(x_22); -x_24 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__6; -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; -x_26 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); -x_8 = x_27; -goto block_17; -} -else -{ -lean_dec(x_18); -x_8 = x_19; -goto block_17; -} -} -else -{ -lean_object* x_28; lean_object* x_29; -lean_dec(x_22); -x_28 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_28, x_18); -x_8 = x_29; -goto block_17; -} -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_dec(x_20); -x_30 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); -x_8 = x_31; -goto block_17; -} -block_17: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(0u); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); -x_13 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7); -return x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_22; lean_object* x_23; lean_object* x_24; +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_22 = lean_ctor_get(x_8, 1); +lean_inc(x_22); +lean_inc(x_1); +x_23 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_25 = lean_ctor_get(x_23, 0); +lean_inc(x_25); +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); +lean_dec(x_26); +x_28 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__6; +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; +x_30 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); +x_12 = x_31; +goto block_21; +} +else +{ +lean_dec(x_22); +x_12 = x_23; +goto block_21; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_26); +x_32 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22); +x_12 = x_33; +goto block_21; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_24); +x_34 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22); +x_12 = x_35; +goto block_21; +} +block_21: +{ +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_18; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(0u); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_11); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_12, x_19, x_11); +return x_20; +} +} } else { -lean_object* x_15; lean_object* x_16; lean_dec(x_9); lean_dec(x_1); -x_15 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_8, x_15, x_7); -return x_16; -} +return x_8; } } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_32 = lean_ctor_get(x_2, 0); -lean_inc(x_32); -x_33 = lean_array_get_size(x_32); -lean_dec(x_32); -x_34 = lean_ctor_get(x_2, 1); -lean_inc(x_34); -lean_inc(x_1); -x_35 = lean_apply_2(x_4, x_1, x_2); -x_36 = lean_ctor_get(x_35, 3); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_2, 0); lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) -{ -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_1); -return x_35; -} -else -{ -lean_object* x_37; lean_object* x_38; uint8_t x_39; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); +x_37 = lean_array_get_size(x_36); lean_dec(x_36); -x_38 = lean_ctor_get(x_35, 1); +x_38 = lean_ctor_get(x_2, 1); lean_inc(x_38); -x_39 = lean_nat_dec_eq(x_38, x_34); -lean_dec(x_38); -if (x_39 == 0) +lean_inc(x_1); +x_39 = lean_apply_2(x_4, x_1, x_2); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { +lean_dec(x_38); lean_dec(x_37); -lean_dec(x_34); -lean_dec(x_33); lean_dec(x_1); -return x_35; +return x_39; } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_55; lean_object* x_56; -lean_inc(x_34); -x_40 = l_Lean_Parser_ParserState_restore(x_35, x_33, x_34); -lean_dec(x_33); +lean_object* x_41; lean_object* x_42; uint8_t x_43; x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -x_42 = lean_array_get_size(x_41); +lean_dec(x_40); +x_42 = lean_ctor_get(x_39, 1); +lean_inc(x_42); +x_43 = lean_nat_dec_eq(x_42, x_38); +lean_dec(x_42); +if (x_43 == 0) +{ lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_37); +lean_dec(x_1); +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_inc(x_38); +x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); +lean_dec(x_37); +x_45 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_46 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_47 = l_Lean_Parser_checkRbpLtFn(x_45, x_46, x_1, x_44); +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_63; lean_object* x_64; lean_object* x_65; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +x_63 = lean_ctor_get(x_47, 1); +lean_inc(x_63); lean_inc(x_1); -x_55 = l_Lean_Parser_tokenFn(x_1, x_40); -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_tparser_x21___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_tparser_x21___elambda__1___closed__9; -lean_inc(x_34); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_34); -x_43 = x_63; -goto block_54; -} -else -{ -x_43 = x_55; -goto block_54; -} -} -else -{ -lean_object* x_64; lean_object* x_65; -lean_dec(x_58); -x_64 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; -lean_inc(x_34); -x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_34); -x_43 = x_65; -goto block_54; -} -} -else +x_64 = l_Lean_Parser_tokenFn(x_1, x_47); +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_dec(x_56); -x_66 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; -lean_inc(x_34); -x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_34); -x_43 = x_67; -goto block_54; -} -block_54: +x_66 = lean_ctor_get(x_64, 0); +lean_inc(x_66); +x_67 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_66); +lean_dec(x_66); +if (lean_obj_tag(x_67) == 2) { -lean_object* x_44; -x_44 = lean_ctor_get(x_43, 3); -lean_inc(x_44); -if (lean_obj_tag(x_44) == 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_tparser_x21___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_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_Term_tparser_x21___elambda__1___closed__2; -x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_42); -x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_37, x_34); -lean_dec(x_34); -return x_50; +lean_object* x_71; lean_object* x_72; +x_71 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_63); +x_51 = x_72; +goto block_62; } 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_Term_tparser_x21___elambda__1___closed__2; -x_52 = l_Lean_Parser_ParserState_mkNode(x_43, x_51, x_42); -x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_37, x_34); -lean_dec(x_34); -return x_53; +lean_dec(x_63); +x_51 = x_64; +goto block_62; } } +else +{ +lean_object* x_73; lean_object* x_74; +lean_dec(x_67); +x_73 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; +x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_63); +x_51 = x_74; +goto block_62; +} +} +else +{ +lean_object* x_75; lean_object* x_76; +lean_dec(x_65); +x_75 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__9; +x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_63); +x_51 = x_76; +goto block_62; +} +block_62: +{ +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; lean_object* x_57; lean_object* x_58; +x_53 = l_Lean_Parser_termParser___closed__2; +x_54 = lean_unsigned_to_nat(0u); +x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_51); +x_56 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2; +x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_50); +x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_41, x_38); +lean_dec(x_38); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_dec(x_52); +lean_dec(x_1); +x_59 = l_Lean_Parser_Term_tparser_x21___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_51, x_59, x_50); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_41, x_38); +lean_dec(x_38); +return x_61; +} +} +} +else +{ +lean_object* x_77; +lean_dec(x_48); +lean_dec(x_1); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_47, x_41, x_38); +lean_dec(x_38); +return x_77; +} } } } @@ -32743,18 +33801,17 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_tparser_x21___closed__1() { _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_tparser_x21___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_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; @@ -32775,16 +33832,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_tparser_x21___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_tparser_x21___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_tparser_x21___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_tparser_x21___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_tparser_x21___closed__3; +x_3 = l_Lean_Parser_Term_tparser_x21___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_tparser_x21___closed__5() { +lean_object* _init_l_Lean_Parser_Term_tparser_x21___closed__6() { _start: { lean_object* x_1; @@ -32792,12 +33859,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tparser_x21___elambda__1), 2 return x_1; } } -lean_object* _init_l_Lean_Parser_Term_tparser_x21___closed__6() { +lean_object* _init_l_Lean_Parser_Term_tparser_x21___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_tparser_x21___closed__4; -x_2 = l_Lean_Parser_Term_tparser_x21___closed__5; +x_1 = l_Lean_Parser_Term_tparser_x21___closed__5; +x_2 = l_Lean_Parser_Term_tparser_x21___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); @@ -32808,7 +33875,7 @@ lean_object* _init_l_Lean_Parser_Term_tparser_x21() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_tparser_x21___closed__6; +x_1 = l_Lean_Parser_Term_tparser_x21___closed__7; return x_1; } } @@ -32924,227 +33991,260 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_18 = lean_ctor_get(x_2, 1); -lean_inc(x_18); -lean_inc(x_1); -x_19 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_21 = lean_ctor_get(x_19, 0); -lean_inc(x_21); -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); -lean_dec(x_22); -x_24 = l_Lean_Parser_Term_borrowed___elambda__1___closed__6; -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; -x_26 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); -x_8 = x_27; -goto block_17; -} -else -{ -lean_dec(x_18); -x_8 = x_19; -goto block_17; -} -} -else -{ -lean_object* x_28; lean_object* x_29; -lean_dec(x_22); -x_28 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_28, x_18); -x_8 = x_29; -goto block_17; -} -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_dec(x_20); -x_30 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); -x_8 = x_31; -goto block_17; -} -block_17: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = l_Lean_Parser_Term_leadPrec___closed__1; -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); -x_13 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7); -return x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_22; lean_object* x_23; lean_object* x_24; +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_22 = lean_ctor_get(x_8, 1); +lean_inc(x_22); +lean_inc(x_1); +x_23 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_25 = lean_ctor_get(x_23, 0); +lean_inc(x_25); +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); +lean_dec(x_26); +x_28 = l_Lean_Parser_Term_borrowed___elambda__1___closed__6; +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; +x_30 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); +x_12 = x_31; +goto block_21; +} +else +{ +lean_dec(x_22); +x_12 = x_23; +goto block_21; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_26); +x_32 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22); +x_12 = x_33; +goto block_21; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_24); +x_34 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22); +x_12 = x_35; +goto block_21; +} +block_21: +{ +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_18; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = l_Lean_Parser_Term_leadPrec___closed__1; +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_11); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_12, x_19, x_11); +return x_20; +} +} } else { -lean_object* x_15; lean_object* x_16; lean_dec(x_9); lean_dec(x_1); -x_15 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_8, x_15, x_7); -return x_16; -} +return x_8; } } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_32 = lean_ctor_get(x_2, 0); -lean_inc(x_32); -x_33 = lean_array_get_size(x_32); -lean_dec(x_32); -x_34 = lean_ctor_get(x_2, 1); -lean_inc(x_34); -lean_inc(x_1); -x_35 = lean_apply_2(x_4, x_1, x_2); -x_36 = lean_ctor_get(x_35, 3); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_2, 0); lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) -{ -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_1); -return x_35; -} -else -{ -lean_object* x_37; lean_object* x_38; uint8_t x_39; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); +x_37 = lean_array_get_size(x_36); lean_dec(x_36); -x_38 = lean_ctor_get(x_35, 1); +x_38 = lean_ctor_get(x_2, 1); lean_inc(x_38); -x_39 = lean_nat_dec_eq(x_38, x_34); -lean_dec(x_38); -if (x_39 == 0) +lean_inc(x_1); +x_39 = lean_apply_2(x_4, x_1, x_2); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { +lean_dec(x_38); lean_dec(x_37); -lean_dec(x_34); -lean_dec(x_33); lean_dec(x_1); -return x_35; +return x_39; } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_55; lean_object* x_56; -lean_inc(x_34); -x_40 = l_Lean_Parser_ParserState_restore(x_35, x_33, x_34); -lean_dec(x_33); +lean_object* x_41; lean_object* x_42; uint8_t x_43; x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -x_42 = lean_array_get_size(x_41); +lean_dec(x_40); +x_42 = lean_ctor_get(x_39, 1); +lean_inc(x_42); +x_43 = lean_nat_dec_eq(x_42, x_38); +lean_dec(x_42); +if (x_43 == 0) +{ lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_37); +lean_dec(x_1); +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_inc(x_38); +x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); +lean_dec(x_37); +x_45 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_46 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_47 = l_Lean_Parser_checkRbpLtFn(x_45, x_46, x_1, x_44); +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_63; lean_object* x_64; lean_object* x_65; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +x_63 = lean_ctor_get(x_47, 1); +lean_inc(x_63); lean_inc(x_1); -x_55 = l_Lean_Parser_tokenFn(x_1, x_40); -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_borrowed___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_borrowed___elambda__1___closed__9; -lean_inc(x_34); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_34); -x_43 = x_63; -goto block_54; -} -else -{ -x_43 = x_55; -goto block_54; -} -} -else -{ -lean_object* x_64; lean_object* x_65; -lean_dec(x_58); -x_64 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; -lean_inc(x_34); -x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_34); -x_43 = x_65; -goto block_54; -} -} -else +x_64 = l_Lean_Parser_tokenFn(x_1, x_47); +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_dec(x_56); -x_66 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; -lean_inc(x_34); -x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_34); -x_43 = x_67; -goto block_54; -} -block_54: +x_66 = lean_ctor_get(x_64, 0); +lean_inc(x_66); +x_67 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_66); +lean_dec(x_66); +if (lean_obj_tag(x_67) == 2) { -lean_object* x_44; -x_44 = lean_ctor_get(x_43, 3); -lean_inc(x_44); -if (lean_obj_tag(x_44) == 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_borrowed___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_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 = l_Lean_Parser_Term_leadPrec___closed__1; -x_47 = l_Lean_Parser_categoryParser___elambda__1(x_45, x_46, x_1, x_43); -x_48 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2; -x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_42); -x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_37, x_34); -lean_dec(x_34); -return x_50; +lean_object* x_71; lean_object* x_72; +x_71 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_63); +x_51 = x_72; +goto block_62; } 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_Term_borrowed___elambda__1___closed__2; -x_52 = l_Lean_Parser_ParserState_mkNode(x_43, x_51, x_42); -x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_37, x_34); -lean_dec(x_34); -return x_53; +lean_dec(x_63); +x_51 = x_64; +goto block_62; } } +else +{ +lean_object* x_73; lean_object* x_74; +lean_dec(x_67); +x_73 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; +x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_63); +x_51 = x_74; +goto block_62; +} +} +else +{ +lean_object* x_75; lean_object* x_76; +lean_dec(x_65); +x_75 = l_Lean_Parser_Term_borrowed___elambda__1___closed__9; +x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_63); +x_51 = x_76; +goto block_62; +} +block_62: +{ +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; lean_object* x_57; lean_object* x_58; +x_53 = l_Lean_Parser_termParser___closed__2; +x_54 = l_Lean_Parser_Term_leadPrec___closed__1; +x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_51); +x_56 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2; +x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_50); +x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_41, x_38); +lean_dec(x_38); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_dec(x_52); +lean_dec(x_1); +x_59 = l_Lean_Parser_Term_borrowed___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_51, x_59, x_50); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_41, x_38); +lean_dec(x_38); +return x_61; +} +} +} +else +{ +lean_object* x_77; +lean_dec(x_48); +lean_dec(x_1); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_47, x_41, x_38); +lean_dec(x_38); +return x_77; +} } } } @@ -33153,11 +34253,10 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_borrowed___closed__1() { _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_borrowed___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_borrowed___closed__2() { @@ -33195,16 +34294,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_borrowed___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_borrowed___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_borrowed___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_borrowed___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_borrowed___closed__4; +x_3 = l_Lean_Parser_Term_borrowed___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_borrowed___closed__6() { +lean_object* _init_l_Lean_Parser_Term_borrowed___closed__7() { _start: { lean_object* x_1; @@ -33212,12 +34321,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_borrowed___elambda__1), 2, 0 return x_1; } } -lean_object* _init_l_Lean_Parser_Term_borrowed___closed__7() { +lean_object* _init_l_Lean_Parser_Term_borrowed___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_borrowed___closed__5; -x_2 = l_Lean_Parser_Term_borrowed___closed__6; +x_1 = l_Lean_Parser_Term_borrowed___closed__6; +x_2 = l_Lean_Parser_Term_borrowed___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); @@ -33228,7 +34337,7 @@ lean_object* _init_l_Lean_Parser_Term_borrowed() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_borrowed___closed__7; +x_1 = l_Lean_Parser_Term_borrowed___closed__8; return x_1; } } @@ -33295,71 +34404,104 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_8 = l_Lean_Parser_nameLit___elambda__1(x_1, x_2); -x_9 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; -x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7); -return x_10; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +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 = l_Lean_Parser_nameLit___elambda__1(x_1, x_8); +x_13 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; +x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_11); +return x_14; } 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_2, 0); -lean_inc(x_11); -x_12 = lean_array_get_size(x_11); -lean_dec(x_11); -x_13 = lean_ctor_get(x_2, 1); -lean_inc(x_13); -lean_inc(x_1); -x_14 = lean_apply_2(x_4, x_1, x_2); -x_15 = lean_ctor_get(x_14, 3); +lean_dec(x_9); +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; +x_15 = lean_ctor_get(x_2, 0); lean_inc(x_15); -if (lean_obj_tag(x_15) == 0) -{ -lean_dec(x_13); -lean_dec(x_12); -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); +x_16 = lean_array_get_size(x_15); lean_dec(x_15); -x_17 = lean_ctor_get(x_14, 1); +x_17 = lean_ctor_get(x_2, 1); lean_inc(x_17); -x_18 = lean_nat_dec_eq(x_17, x_13); -lean_dec(x_17); -if (x_18 == 0) +lean_inc(x_1); +x_18 = lean_apply_2(x_4, x_1, x_2); +x_19 = lean_ctor_get(x_18, 3); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) { +lean_dec(x_17); lean_dec(x_16); -lean_dec(x_13); -lean_dec(x_12); lean_dec(x_1); -return x_14; +return x_18; } else { -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(x_13); -x_19 = l_Lean_Parser_ParserState_restore(x_14, x_12, x_13); -lean_dec(x_12); +lean_object* x_20; lean_object* x_21; uint8_t x_22; x_20 = lean_ctor_get(x_19, 0); lean_inc(x_20); -x_21 = lean_array_get_size(x_20); +lean_dec(x_19); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +x_22 = lean_nat_dec_eq(x_21, x_17); +lean_dec(x_21); +if (x_22 == 0) +{ lean_dec(x_20); -x_22 = l_Lean_Parser_nameLit___elambda__1(x_1, x_19); -x_23 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_21); -x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_16, x_13); -lean_dec(x_13); -return x_25; +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_1); +return x_18; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_inc(x_17); +x_23 = l_Lean_Parser_ParserState_restore(x_18, x_16, x_17); +lean_dec(x_16); +x_24 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_25 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_26 = l_Lean_Parser_checkRbpLtFn(x_24, 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_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_26, 0); +lean_inc(x_28); +x_29 = lean_array_get_size(x_28); +lean_dec(x_28); +x_30 = l_Lean_Parser_nameLit___elambda__1(x_1, x_26); +x_31 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_29); +x_33 = l_Lean_Parser_mergeOrElseErrors(x_32, x_20, x_17); +lean_dec(x_17); +return x_33; +} +else +{ +lean_object* x_34; +lean_dec(x_27); +lean_dec(x_1); +x_34 = l_Lean_Parser_mergeOrElseErrors(x_26, x_20, x_17); +lean_dec(x_17); +return x_34; +} } } } @@ -33380,16 +34522,26 @@ return x_4; lean_object* _init_l_Lean_Parser_Term_quotedName___closed__2() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_quotedName___closed__1; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_quotedName___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_quotedName___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_quotedName___closed__1; +x_3 = l_Lean_Parser_Term_quotedName___closed__2; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_quotedName___closed__3() { +lean_object* _init_l_Lean_Parser_Term_quotedName___closed__4() { _start: { lean_object* x_1; @@ -33397,12 +34549,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_quotedName___elambda__1), 2, return x_1; } } -lean_object* _init_l_Lean_Parser_Term_quotedName___closed__4() { +lean_object* _init_l_Lean_Parser_Term_quotedName___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_quotedName___closed__2; -x_2 = l_Lean_Parser_Term_quotedName___closed__3; +x_1 = l_Lean_Parser_Term_quotedName___closed__3; +x_2 = l_Lean_Parser_Term_quotedName___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); @@ -33413,7 +34565,7 @@ lean_object* _init_l_Lean_Parser_Term_quotedName() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_quotedName___closed__4; +x_1 = l_Lean_Parser_Term_quotedName___closed__5; return x_1; } } @@ -33524,403 +34676,438 @@ lean_inc(x_1); x_7 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_7 == 0) { -lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_dec(x_6); -x_8 = lean_ctor_get(x_2, 0); -lean_inc(x_8); -x_9 = lean_array_get_size(x_8); -lean_dec(x_8); -x_44 = lean_ctor_get(x_2, 1); -lean_inc(x_44); -lean_inc(x_1); -x_45 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -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_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_match__syntax___elambda__1___closed__5; -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_match__syntax___elambda__1___closed__8; -x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_44); -x_10 = x_53; -goto block_43; -} -else -{ -lean_dec(x_44); -x_10 = x_45; -goto block_43; -} -} -else -{ -lean_object* x_54; lean_object* x_55; -lean_dec(x_48); -x_54 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; -x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_44); -x_10 = x_55; -goto block_43; -} -} -else -{ -lean_object* x_56; lean_object* x_57; -lean_dec(x_46); -x_56 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; -x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_44); -x_10 = x_57; -goto block_43; -} -block_43: -{ -lean_object* x_11; +x_8 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_9 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_10 = l_Lean_Parser_checkRbpLtFn(x_8, x_9, x_1, x_2); 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; -x_12 = l_Lean_Parser_termParser___closed__2; -x_13 = lean_unsigned_to_nat(0u); +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_48; lean_object* x_49; lean_object* x_50; +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_48 = lean_ctor_get(x_10, 1); +lean_inc(x_48); lean_inc(x_1); -x_14 = l_Lean_Parser_categoryParser___elambda__1(x_12, x_13, x_1, x_10); +x_49 = l_Lean_Parser_tokenFn(x_1, x_10); +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); +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); +lean_dec(x_52); +x_54 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__5; +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_match__syntax___elambda__1___closed__8; +x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_56, x_48); +x_14 = x_57; +goto block_47; +} +else +{ +lean_dec(x_48); +x_14 = x_49; +goto block_47; +} +} +else +{ +lean_object* x_58; lean_object* x_59; +lean_dec(x_52); +x_58 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; +x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_58, x_48); +x_14 = x_59; +goto block_47; +} +} +else +{ +lean_object* x_60; lean_object* x_61; +lean_dec(x_50); +x_60 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; +x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_49, x_60, x_48); +x_14 = x_61; +goto block_47; +} +block_47: +{ +lean_object* x_15; 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; -x_16 = lean_ctor_get(x_14, 1); -lean_inc(x_16); +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_16 = l_Lean_Parser_termParser___closed__2; +x_17 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_17 = l_Lean_Parser_tokenFn(x_1, x_14); -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); +x_18 = l_Lean_Parser_categoryParser___elambda__1(x_16, x_17, x_1, x_14); +x_19 = lean_ctor_get(x_18, 3); lean_inc(x_19); -x_20 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_19); -lean_dec(x_19); -if (lean_obj_tag(x_20) == 2) +if (lean_obj_tag(x_19) == 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_Lean_Parser_Term_match___elambda__1___closed__8; -x_23 = lean_string_dec_eq(x_21, x_22); -lean_dec(x_21); -if (x_23 == 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); +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_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_object* x_23; lean_object* x_24; +x_23 = lean_ctor_get(x_21, 0); +lean_inc(x_23); +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); +lean_dec(x_24); +x_26 = l_Lean_Parser_Term_match___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_dec(x_4); lean_dec(x_1); -x_24 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); -x_26 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_9); -return x_27; +x_28 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20); +x_30 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; +x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_13); +return x_31; } else { -lean_object* x_28; lean_object* x_29; lean_object* x_30; -lean_dec(x_16); -x_28 = lean_apply_2(x_4, x_1, x_17); -x_29 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_9); -return x_30; -} -} -else -{ -lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_dec(x_20); -lean_dec(x_4); -lean_dec(x_1); -x_31 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_31, x_16); +x_32 = lean_apply_2(x_4, x_1, x_21); x_33 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_9); +x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_13); return x_34; } } else { lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; -lean_dec(x_18); +lean_dec(x_24); lean_dec(x_4); lean_dec(x_1); x_35 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_35, x_16); +x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_35, x_20); x_37 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_9); +x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_13); return x_38; } } else { -lean_object* x_39; lean_object* x_40; -lean_dec(x_15); -lean_dec(x_4); -lean_dec(x_1); -x_39 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_40 = l_Lean_Parser_ParserState_mkNode(x_14, x_39, x_9); -return x_40; -} -} -else -{ -lean_object* x_41; lean_object* x_42; -lean_dec(x_11); +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +lean_dec(x_22); lean_dec(x_4); lean_dec(x_1); +x_39 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_39, x_20); x_41 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_42 = l_Lean_Parser_ParserState_mkNode(x_10, x_41, x_9); +x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_13); return x_42; } } +else +{ +lean_object* x_43; lean_object* x_44; +lean_dec(x_19); +lean_dec(x_4); +lean_dec(x_1); +x_43 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; +x_44 = l_Lean_Parser_ParserState_mkNode(x_18, x_43, x_13); +return x_44; +} } else { -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_2, 0); -lean_inc(x_58); -x_59 = lean_array_get_size(x_58); -lean_dec(x_58); -x_60 = lean_ctor_get(x_2, 1); -lean_inc(x_60); -lean_inc(x_1); -x_61 = lean_apply_2(x_6, x_1, x_2); -x_62 = lean_ctor_get(x_61, 3); +lean_object* x_45; lean_object* x_46; +lean_dec(x_15); +lean_dec(x_4); +lean_dec(x_1); +x_45 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; +x_46 = l_Lean_Parser_ParserState_mkNode(x_14, x_45, x_13); +return x_46; +} +} +} +else +{ +lean_dec(x_11); +lean_dec(x_4); +lean_dec(x_1); +return x_10; +} +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_62 = lean_ctor_get(x_2, 0); lean_inc(x_62); -if (lean_obj_tag(x_62) == 0) -{ -lean_dec(x_60); -lean_dec(x_59); -lean_dec(x_4); -lean_dec(x_1); -return x_61; -} -else -{ -lean_object* x_63; lean_object* x_64; uint8_t x_65; -x_63 = lean_ctor_get(x_62, 0); -lean_inc(x_63); +x_63 = lean_array_get_size(x_62); lean_dec(x_62); -x_64 = lean_ctor_get(x_61, 1); +x_64 = lean_ctor_get(x_2, 1); lean_inc(x_64); -x_65 = lean_nat_dec_eq(x_64, x_60); -lean_dec(x_64); -if (x_65 == 0) +lean_inc(x_1); +x_65 = lean_apply_2(x_6, x_1, x_2); +x_66 = lean_ctor_get(x_65, 3); +lean_inc(x_66); +if (lean_obj_tag(x_66) == 0) { +lean_dec(x_64); lean_dec(x_63); -lean_dec(x_60); -lean_dec(x_59); lean_dec(x_4); lean_dec(x_1); -return x_61; +return x_65; } else { -lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_109; lean_object* x_110; -lean_inc(x_60); -x_66 = l_Lean_Parser_ParserState_restore(x_61, x_59, x_60); -lean_dec(x_59); +lean_object* x_67; lean_object* x_68; uint8_t x_69; x_67 = lean_ctor_get(x_66, 0); lean_inc(x_67); -x_68 = lean_array_get_size(x_67); +lean_dec(x_66); +x_68 = lean_ctor_get(x_65, 1); +lean_inc(x_68); +x_69 = lean_nat_dec_eq(x_68, x_64); +lean_dec(x_68); +if (x_69 == 0) +{ lean_dec(x_67); -lean_inc(x_1); -x_109 = l_Lean_Parser_tokenFn(x_1, x_66); -x_110 = lean_ctor_get(x_109, 3); -lean_inc(x_110); -if (lean_obj_tag(x_110) == 0) -{ -lean_object* x_111; lean_object* x_112; -x_111 = lean_ctor_get(x_109, 0); -lean_inc(x_111); -x_112 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_111); -lean_dec(x_111); -if (lean_obj_tag(x_112) == 2) -{ -lean_object* x_113; lean_object* x_114; uint8_t x_115; -x_113 = lean_ctor_get(x_112, 1); -lean_inc(x_113); -lean_dec(x_112); -x_114 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__5; -x_115 = lean_string_dec_eq(x_113, x_114); -lean_dec(x_113); -if (x_115 == 0) -{ -lean_object* x_116; lean_object* x_117; -x_116 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; -lean_inc(x_60); -x_117 = l_Lean_Parser_ParserState_mkErrorsAt(x_109, x_116, x_60); -x_69 = x_117; -goto block_108; +lean_dec(x_64); +lean_dec(x_63); +lean_dec(x_4); +lean_dec(x_1); +return x_65; } else { -x_69 = x_109; -goto block_108; -} -} -else -{ -lean_object* x_118; lean_object* x_119; -lean_dec(x_112); -x_118 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; -lean_inc(x_60); -x_119 = l_Lean_Parser_ParserState_mkErrorsAt(x_109, x_118, x_60); -x_69 = x_119; -goto block_108; -} -} -else -{ -lean_object* x_120; lean_object* x_121; -lean_dec(x_110); -x_120 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; -lean_inc(x_60); -x_121 = l_Lean_Parser_ParserState_mkErrorsAt(x_109, x_120, x_60); -x_69 = x_121; -goto block_108; -} -block_108: -{ -lean_object* x_70; -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; -x_71 = l_Lean_Parser_termParser___closed__2; -x_72 = lean_unsigned_to_nat(0u); -lean_inc(x_1); -x_73 = l_Lean_Parser_categoryParser___elambda__1(x_71, x_72, x_1, 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_64); +x_70 = l_Lean_Parser_ParserState_restore(x_65, x_63, x_64); +lean_dec(x_63); +x_71 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_72 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_73 = l_Lean_Parser_checkRbpLtFn(x_71, x_72, x_1, x_70); x_74 = lean_ctor_get(x_73, 3); lean_inc(x_74); if (lean_obj_tag(x_74) == 0) { -lean_object* x_75; lean_object* x_76; lean_object* x_77; -x_75 = lean_ctor_get(x_73, 1); +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_117; lean_object* x_118; lean_object* x_119; +x_75 = lean_ctor_get(x_73, 0); lean_inc(x_75); -lean_inc(x_1); -x_76 = l_Lean_Parser_tokenFn(x_1, x_73); -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; -x_78 = lean_ctor_get(x_76, 0); -lean_inc(x_78); -x_79 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_Term_match___elambda__1___closed__8; -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; lean_object* x_85; lean_object* x_86; lean_object* x_87; -lean_dec(x_4); -lean_dec(x_1); -x_83 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_84 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_83, x_75); -x_85 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_86 = l_Lean_Parser_ParserState_mkNode(x_84, x_85, x_68); -x_87 = l_Lean_Parser_mergeOrElseErrors(x_86, x_63, x_60); -lean_dec(x_60); -return x_87; -} -else -{ -lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_76 = lean_array_get_size(x_75); lean_dec(x_75); -x_88 = lean_apply_2(x_4, x_1, x_76); -x_89 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_90 = l_Lean_Parser_ParserState_mkNode(x_88, x_89, x_68); -x_91 = l_Lean_Parser_mergeOrElseErrors(x_90, x_63, x_60); -lean_dec(x_60); -return x_91; +x_117 = lean_ctor_get(x_73, 1); +lean_inc(x_117); +lean_inc(x_1); +x_118 = l_Lean_Parser_tokenFn(x_1, x_73); +x_119 = lean_ctor_get(x_118, 3); +lean_inc(x_119); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; +x_120 = lean_ctor_get(x_118, 0); +lean_inc(x_120); +x_121 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_120); +lean_dec(x_120); +if (lean_obj_tag(x_121) == 2) +{ +lean_object* x_122; lean_object* x_123; uint8_t x_124; +x_122 = lean_ctor_get(x_121, 1); +lean_inc(x_122); +lean_dec(x_121); +x_123 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__5; +x_124 = lean_string_dec_eq(x_122, x_123); +lean_dec(x_122); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; +x_125 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; +x_126 = l_Lean_Parser_ParserState_mkErrorsAt(x_118, x_125, x_117); +x_77 = x_126; +goto block_116; +} +else +{ +lean_dec(x_117); +x_77 = x_118; +goto block_116; } } else { -lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; -lean_dec(x_79); -lean_dec(x_4); -lean_dec(x_1); -x_92 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_92, x_75); -x_94 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_95 = l_Lean_Parser_ParserState_mkNode(x_93, x_94, x_68); -x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_63, x_60); -lean_dec(x_60); -return x_96; +lean_object* x_127; lean_object* x_128; +lean_dec(x_121); +x_127 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; +x_128 = l_Lean_Parser_ParserState_mkErrorsAt(x_118, x_127, x_117); +x_77 = x_128; +goto block_116; } } else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; -lean_dec(x_77); +lean_object* x_129; lean_object* x_130; +lean_dec(x_119); +x_129 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__8; +x_130 = l_Lean_Parser_ParserState_mkErrorsAt(x_118, x_129, x_117); +x_77 = x_130; +goto block_116; +} +block_116: +{ +lean_object* x_78; +x_78 = lean_ctor_get(x_77, 3); +lean_inc(x_78); +if (lean_obj_tag(x_78) == 0) +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_79 = l_Lean_Parser_termParser___closed__2; +x_80 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_81 = l_Lean_Parser_categoryParser___elambda__1(x_79, x_80, x_1, x_77); +x_82 = lean_ctor_get(x_81, 3); +lean_inc(x_82); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_83 = lean_ctor_get(x_81, 1); +lean_inc(x_83); +lean_inc(x_1); +x_84 = l_Lean_Parser_tokenFn(x_1, x_81); +x_85 = lean_ctor_get(x_84, 3); +lean_inc(x_85); +if (lean_obj_tag(x_85) == 0) +{ +lean_object* x_86; lean_object* x_87; +x_86 = lean_ctor_get(x_84, 0); +lean_inc(x_86); +x_87 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_86); +lean_dec(x_86); +if (lean_obj_tag(x_87) == 2) +{ +lean_object* x_88; lean_object* x_89; uint8_t x_90; +x_88 = lean_ctor_get(x_87, 1); +lean_inc(x_88); +lean_dec(x_87); +x_89 = l_Lean_Parser_Term_match___elambda__1___closed__8; +x_90 = lean_string_dec_eq(x_88, x_89); +lean_dec(x_88); +if (x_90 == 0) +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_dec(x_4); lean_dec(x_1); -x_97 = l_Lean_Parser_Term_match___elambda__1___closed__12; -x_98 = l_Lean_Parser_ParserState_mkErrorsAt(x_76, x_97, x_75); -x_99 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_68); -x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_63, x_60); -lean_dec(x_60); -return x_101; +x_91 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_92 = l_Lean_Parser_ParserState_mkErrorsAt(x_84, x_91, x_83); +x_93 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; +x_94 = l_Lean_Parser_ParserState_mkNode(x_92, x_93, x_76); +x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_67, x_64); +lean_dec(x_64); +return x_95; +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; +lean_dec(x_83); +x_96 = lean_apply_2(x_4, x_1, x_84); +x_97 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; +x_98 = l_Lean_Parser_ParserState_mkNode(x_96, x_97, x_76); +x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_67, x_64); +lean_dec(x_64); +return x_99; } } else { -lean_object* x_102; lean_object* x_103; lean_object* x_104; -lean_dec(x_74); +lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +lean_dec(x_87); lean_dec(x_4); lean_dec(x_1); +x_100 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_101 = l_Lean_Parser_ParserState_mkErrorsAt(x_84, x_100, x_83); x_102 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_103 = l_Lean_Parser_ParserState_mkNode(x_73, x_102, x_68); -x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_63, x_60); -lean_dec(x_60); +x_103 = l_Lean_Parser_ParserState_mkNode(x_101, x_102, x_76); +x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_67, x_64); +lean_dec(x_64); return x_104; } } else { -lean_object* x_105; lean_object* x_106; lean_object* x_107; -lean_dec(x_70); +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; +lean_dec(x_85); lean_dec(x_4); lean_dec(x_1); -x_105 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -x_106 = l_Lean_Parser_ParserState_mkNode(x_69, x_105, x_68); -x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_63, x_60); -lean_dec(x_60); -return x_107; +x_105 = l_Lean_Parser_Term_match___elambda__1___closed__12; +x_106 = l_Lean_Parser_ParserState_mkErrorsAt(x_84, x_105, x_83); +x_107 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; +x_108 = l_Lean_Parser_ParserState_mkNode(x_106, x_107, x_76); +x_109 = l_Lean_Parser_mergeOrElseErrors(x_108, x_67, x_64); +lean_dec(x_64); +return x_109; } } +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_82); +lean_dec(x_4); +lean_dec(x_1); +x_110 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; +x_111 = l_Lean_Parser_ParserState_mkNode(x_81, x_110, x_76); +x_112 = l_Lean_Parser_mergeOrElseErrors(x_111, x_67, x_64); +lean_dec(x_64); +return x_112; +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; +lean_dec(x_78); +lean_dec(x_4); +lean_dec(x_1); +x_113 = l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; +x_114 = l_Lean_Parser_ParserState_mkNode(x_77, x_113, x_76); +x_115 = l_Lean_Parser_mergeOrElseErrors(x_114, x_67, x_64); +lean_dec(x_64); +return x_115; +} +} +} +else +{ +lean_object* x_131; +lean_dec(x_74); +lean_dec(x_4); +lean_dec(x_1); +x_131 = l_Lean_Parser_mergeOrElseErrors(x_73, x_67, x_64); +lean_dec(x_64); +return x_131; +} } } } @@ -33929,18 +35116,17 @@ return x_107; lean_object* _init_l_Lean_Parser_Term_match__syntax___closed__1() { _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_match__syntax___elambda__1___closed__5; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_match___closed__3; @@ -33971,16 +35157,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_match__syntax___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_match__syntax___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_match__syntax___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_match__syntax___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_match__syntax___closed__4; +x_3 = l_Lean_Parser_Term_match__syntax___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_match__syntax___closed__6() { +lean_object* _init_l_Lean_Parser_Term_match__syntax___closed__7() { _start: { lean_object* x_1; @@ -33988,12 +35184,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_match__syntax___elambda__1), return x_1; } } -lean_object* _init_l_Lean_Parser_Term_match__syntax___closed__7() { +lean_object* _init_l_Lean_Parser_Term_match__syntax___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_match__syntax___closed__5; -x_2 = l_Lean_Parser_Term_match__syntax___closed__6; +x_1 = l_Lean_Parser_Term_match__syntax___closed__6; +x_2 = l_Lean_Parser_Term_match__syntax___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); @@ -34004,7 +35200,7 @@ lean_object* _init_l_Lean_Parser_Term_match__syntax() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_match__syntax___closed__7; +x_1 = l_Lean_Parser_Term_match__syntax___closed__8; return x_1; } } @@ -34228,7 +35424,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_letIdDecl___closed__4; @@ -34531,7 +35727,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_letPatDecl___closed__2; @@ -34543,7 +35739,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_letPatDecl___closed__3; @@ -34941,391 +36137,424 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_42 = lean_ctor_get(x_2, 1); -lean_inc(x_42); -lean_inc(x_1); -x_43 = l_Lean_Parser_tokenFn(x_1, x_2); -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_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_dec(x_46); -x_48 = l_Lean_Parser_Term_let___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 = l_Lean_Parser_Term_let___elambda__1___closed__9; -x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_50, x_42); -x_8 = x_51; -goto block_41; -} -else -{ -lean_dec(x_42); -x_8 = x_43; -goto block_41; -} -} -else -{ -lean_object* x_52; lean_object* x_53; -lean_dec(x_46); -x_52 = l_Lean_Parser_Term_let___elambda__1___closed__9; -x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_52, x_42); -x_8 = x_53; -goto block_41; -} -} -else -{ -lean_object* x_54; lean_object* x_55; -lean_dec(x_44); -x_54 = l_Lean_Parser_Term_let___elambda__1___closed__9; -x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_54, x_42); -x_8 = x_55; -goto block_41; -} -block_41: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_46; lean_object* x_47; lean_object* x_48; +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_46 = lean_ctor_get(x_8, 1); +lean_inc(x_46); lean_inc(x_1); -x_10 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_8); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 0) +x_47 = l_Lean_Parser_tokenFn(x_1, x_8); +x_48 = lean_ctor_get(x_47, 3); +lean_inc(x_48); +if (lean_obj_tag(x_48) == 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); +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_Lean_Parser_Term_let___elambda__1___closed__6; +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_let___elambda__1___closed__9; +x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_54, x_46); +x_12 = x_55; +goto block_45; +} +else +{ +lean_dec(x_46); +x_12 = x_47; +goto block_45; +} +} +else +{ +lean_object* x_56; lean_object* x_57; +lean_dec(x_50); +x_56 = l_Lean_Parser_Term_let___elambda__1___closed__9; +x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_56, x_46); +x_12 = x_57; +goto block_45; +} +} +else +{ +lean_object* x_58; lean_object* x_59; +lean_dec(x_48); +x_58 = l_Lean_Parser_Term_let___elambda__1___closed__9; +x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_58, x_46); +x_12 = x_59; +goto block_45; +} +block_45: +{ +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_inc(x_1); -x_13 = l_Lean_Parser_tokenFn(x_1, 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); +x_14 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_12); +x_15 = lean_ctor_get(x_14, 3); lean_inc(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) +if (lean_obj_tag(x_15) == 0) { -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_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -x_19 = lean_string_dec_eq(x_17, x_18); -lean_dec(x_17); -if (x_19 == 0) +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +lean_inc(x_1); +x_17 = l_Lean_Parser_tokenFn(x_1, 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_23; +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_checkStackTopFn___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___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; +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_dec(x_1); -x_20 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); -x_22 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_7); -return x_23; +x_24 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); +x_26 = l_Lean_Parser_Term_let___elambda__1___closed__2; +x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_11); +return x_27; } else { -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; -lean_dec(x_12); -x_24 = l_Lean_Parser_termParser___closed__2; -x_25 = lean_unsigned_to_nat(0u); -x_26 = l_Lean_Parser_categoryParser___elambda__1(x_24, x_25, x_1, x_13); -x_27 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_7); -return x_28; -} -} -else -{ -lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_dec(x_16); -lean_dec(x_1); -x_29 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_29, x_12); +x_28 = l_Lean_Parser_termParser___closed__2; +x_29 = lean_unsigned_to_nat(0u); +x_30 = l_Lean_Parser_categoryParser___elambda__1(x_28, x_29, x_1, x_17); x_31 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_7); +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_11); return x_32; } } else { lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -lean_dec(x_14); +lean_dec(x_20); lean_dec(x_1); x_33 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_33, x_12); +x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_33, x_16); x_35 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_7); +x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_11); return x_36; } } else { -lean_object* x_37; lean_object* x_38; -lean_dec(x_11); -lean_dec(x_1); -x_37 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkNode(x_10, x_37, x_7); -return x_38; -} -} -else -{ -lean_object* x_39; lean_object* x_40; -lean_dec(x_9); +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +lean_dec(x_18); lean_dec(x_1); +x_37 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_16); x_39 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_40 = l_Lean_Parser_ParserState_mkNode(x_8, x_39, x_7); +x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_11); return x_40; } } +else +{ +lean_object* x_41; lean_object* x_42; +lean_dec(x_15); +lean_dec(x_1); +x_41 = l_Lean_Parser_Term_let___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkNode(x_14, x_41, x_11); +return x_42; +} } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -x_56 = lean_ctor_get(x_2, 0); -lean_inc(x_56); -x_57 = lean_array_get_size(x_56); -lean_dec(x_56); -x_58 = lean_ctor_get(x_2, 1); -lean_inc(x_58); -lean_inc(x_1); -x_59 = lean_apply_2(x_4, x_1, x_2); -x_60 = lean_ctor_get(x_59, 3); +lean_object* x_43; lean_object* x_44; +lean_dec(x_13); +lean_dec(x_1); +x_43 = l_Lean_Parser_Term_let___elambda__1___closed__2; +x_44 = l_Lean_Parser_ParserState_mkNode(x_12, x_43, x_11); +return x_44; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_60); -if (lean_obj_tag(x_60) == 0) -{ -lean_dec(x_58); -lean_dec(x_57); -lean_dec(x_1); -return x_59; -} -else -{ -lean_object* x_61; lean_object* x_62; uint8_t x_63; -x_61 = lean_ctor_get(x_60, 0); -lean_inc(x_61); +x_61 = lean_array_get_size(x_60); lean_dec(x_60); -x_62 = lean_ctor_get(x_59, 1); +x_62 = lean_ctor_get(x_2, 1); lean_inc(x_62); -x_63 = lean_nat_dec_eq(x_62, x_58); -lean_dec(x_62); -if (x_63 == 0) +lean_inc(x_1); +x_63 = lean_apply_2(x_4, x_1, x_2); +x_64 = lean_ctor_get(x_63, 3); +lean_inc(x_64); +if (lean_obj_tag(x_64) == 0) { +lean_dec(x_62); lean_dec(x_61); -lean_dec(x_58); -lean_dec(x_57); lean_dec(x_1); -return x_59; +return x_63; } else { -lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_107; lean_object* x_108; -lean_inc(x_58); -x_64 = l_Lean_Parser_ParserState_restore(x_59, x_57, x_58); -lean_dec(x_57); +lean_object* x_65; lean_object* x_66; uint8_t x_67; x_65 = lean_ctor_get(x_64, 0); lean_inc(x_65); -x_66 = lean_array_get_size(x_65); +lean_dec(x_64); +x_66 = lean_ctor_get(x_63, 1); +lean_inc(x_66); +x_67 = lean_nat_dec_eq(x_66, x_62); +lean_dec(x_66); +if (x_67 == 0) +{ lean_dec(x_65); +lean_dec(x_62); +lean_dec(x_61); +lean_dec(x_1); +return x_63; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +lean_inc(x_62); +x_68 = l_Lean_Parser_ParserState_restore(x_63, x_61, x_62); +lean_dec(x_61); +x_69 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_70 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_71 = l_Lean_Parser_checkRbpLtFn(x_69, x_70, x_1, 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; lean_object* x_75; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_73 = lean_ctor_get(x_71, 0); +lean_inc(x_73); +x_74 = lean_array_get_size(x_73); +lean_dec(x_73); +x_115 = lean_ctor_get(x_71, 1); +lean_inc(x_115); lean_inc(x_1); -x_107 = l_Lean_Parser_tokenFn(x_1, x_64); -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); -x_110 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_109); -lean_dec(x_109); -if (lean_obj_tag(x_110) == 2) -{ -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_let___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_let___elambda__1___closed__9; -lean_inc(x_58); -x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_107, x_114, x_58); -x_67 = x_115; -goto block_106; -} -else -{ -x_67 = x_107; -goto block_106; -} -} -else -{ -lean_object* x_116; lean_object* x_117; -lean_dec(x_110); -x_116 = l_Lean_Parser_Term_let___elambda__1___closed__9; -lean_inc(x_58); -x_117 = l_Lean_Parser_ParserState_mkErrorsAt(x_107, x_116, x_58); -x_67 = x_117; -goto block_106; -} -} -else +x_116 = l_Lean_Parser_tokenFn(x_1, x_71); +x_117 = lean_ctor_get(x_116, 3); +lean_inc(x_117); +if (lean_obj_tag(x_117) == 0) { lean_object* x_118; lean_object* x_119; -lean_dec(x_108); -x_118 = l_Lean_Parser_Term_let___elambda__1___closed__9; -lean_inc(x_58); -x_119 = l_Lean_Parser_ParserState_mkErrorsAt(x_107, x_118, x_58); -x_67 = x_119; -goto block_106; +x_118 = lean_ctor_get(x_116, 0); +lean_inc(x_118); +x_119 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_118); +lean_dec(x_118); +if (lean_obj_tag(x_119) == 2) +{ +lean_object* x_120; lean_object* x_121; uint8_t x_122; +x_120 = lean_ctor_get(x_119, 1); +lean_inc(x_120); +lean_dec(x_119); +x_121 = l_Lean_Parser_Term_let___elambda__1___closed__6; +x_122 = lean_string_dec_eq(x_120, x_121); +lean_dec(x_120); +if (x_122 == 0) +{ +lean_object* x_123; lean_object* x_124; +x_123 = l_Lean_Parser_Term_let___elambda__1___closed__9; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_116, x_123, x_115); +x_75 = x_124; +goto block_114; } -block_106: +else { -lean_object* x_68; -x_68 = lean_ctor_get(x_67, 3); -lean_inc(x_68); -if (lean_obj_tag(x_68) == 0) +lean_dec(x_115); +x_75 = x_116; +goto block_114; +} +} +else { -lean_object* x_69; lean_object* x_70; -lean_inc(x_1); -x_69 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_67); -x_70 = lean_ctor_get(x_69, 3); -lean_inc(x_70); -if (lean_obj_tag(x_70) == 0) +lean_object* x_125; lean_object* x_126; +lean_dec(x_119); +x_125 = l_Lean_Parser_Term_let___elambda__1___closed__9; +x_126 = l_Lean_Parser_ParserState_mkErrorsAt(x_116, x_125, x_115); +x_75 = x_126; +goto block_114; +} +} +else { -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_1); -x_72 = l_Lean_Parser_tokenFn(x_1, x_69); -x_73 = lean_ctor_get(x_72, 3); -lean_inc(x_73); -if (lean_obj_tag(x_73) == 0) +lean_object* x_127; lean_object* x_128; +lean_dec(x_117); +x_127 = l_Lean_Parser_Term_let___elambda__1___closed__9; +x_128 = l_Lean_Parser_ParserState_mkErrorsAt(x_116, x_127, x_115); +x_75 = x_128; +goto block_114; +} +block_114: { -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_checkStackTopFn___spec__1(x_74); -lean_dec(x_74); -if (lean_obj_tag(x_75) == 2) -{ -lean_object* x_76; lean_object* x_77; uint8_t x_78; -x_76 = lean_ctor_get(x_75, 1); +lean_object* x_76; +x_76 = lean_ctor_get(x_75, 3); lean_inc(x_76); -lean_dec(x_75); -x_77 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -x_78 = lean_string_dec_eq(x_76, x_77); -lean_dec(x_76); -if (x_78 == 0) +if (lean_obj_tag(x_76) == 0) { -lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +lean_object* x_77; lean_object* x_78; +lean_inc(x_1); +x_77 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_75); +x_78 = lean_ctor_get(x_77, 3); +lean_inc(x_78); +if (lean_obj_tag(x_78) == 0) +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_79 = lean_ctor_get(x_77, 1); +lean_inc(x_79); +lean_inc(x_1); +x_80 = l_Lean_Parser_tokenFn(x_1, x_77); +x_81 = lean_ctor_get(x_80, 3); +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_checkStackTopFn___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_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___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; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_dec(x_1); -x_79 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_79, x_71); -x_81 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_82 = l_Lean_Parser_ParserState_mkNode(x_80, x_81, x_66); -x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_61, x_58); -lean_dec(x_58); -return x_83; +x_87 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_87, x_79); +x_89 = l_Lean_Parser_Term_let___elambda__1___closed__2; +x_90 = l_Lean_Parser_ParserState_mkNode(x_88, x_89, x_74); +x_91 = l_Lean_Parser_mergeOrElseErrors(x_90, x_65, x_62); +lean_dec(x_62); +return x_91; } else { -lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; -lean_dec(x_71); -x_84 = l_Lean_Parser_termParser___closed__2; -x_85 = lean_unsigned_to_nat(0u); -x_86 = l_Lean_Parser_categoryParser___elambda__1(x_84, x_85, x_1, x_72); -x_87 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_88 = l_Lean_Parser_ParserState_mkNode(x_86, x_87, x_66); -x_89 = l_Lean_Parser_mergeOrElseErrors(x_88, x_61, x_58); -lean_dec(x_58); -return x_89; +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_79); +x_92 = l_Lean_Parser_termParser___closed__2; +x_93 = lean_unsigned_to_nat(0u); +x_94 = l_Lean_Parser_categoryParser___elambda__1(x_92, x_93, x_1, x_80); +x_95 = l_Lean_Parser_Term_let___elambda__1___closed__2; +x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_74); +x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_65, x_62); +lean_dec(x_62); +return x_97; } } else { -lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; -lean_dec(x_75); -lean_dec(x_1); -x_90 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_90, x_71); -x_92 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_93 = l_Lean_Parser_ParserState_mkNode(x_91, x_92, x_66); -x_94 = l_Lean_Parser_mergeOrElseErrors(x_93, x_61, x_58); -lean_dec(x_58); -return x_94; -} -} -else -{ -lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; -lean_dec(x_73); -lean_dec(x_1); -x_95 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_96 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_95, x_71); -x_97 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_98 = l_Lean_Parser_ParserState_mkNode(x_96, x_97, x_66); -x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_61, x_58); -lean_dec(x_58); -return x_99; -} -} -else -{ -lean_object* x_100; lean_object* x_101; lean_object* x_102; -lean_dec(x_70); +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; +lean_dec(x_83); lean_dec(x_1); +x_98 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_99 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_98, x_79); x_100 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_101 = l_Lean_Parser_ParserState_mkNode(x_69, x_100, x_66); -x_102 = l_Lean_Parser_mergeOrElseErrors(x_101, x_61, x_58); -lean_dec(x_58); +x_101 = l_Lean_Parser_ParserState_mkNode(x_99, x_100, x_74); +x_102 = l_Lean_Parser_mergeOrElseErrors(x_101, x_65, x_62); +lean_dec(x_62); return x_102; } } else { -lean_object* x_103; lean_object* x_104; lean_object* x_105; -lean_dec(x_68); +lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_81); lean_dec(x_1); -x_103 = l_Lean_Parser_Term_let___elambda__1___closed__2; -x_104 = l_Lean_Parser_ParserState_mkNode(x_67, x_103, x_66); -x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_61, x_58); -lean_dec(x_58); -return x_105; +x_103 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_104 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_103, x_79); +x_105 = l_Lean_Parser_Term_let___elambda__1___closed__2; +x_106 = l_Lean_Parser_ParserState_mkNode(x_104, x_105, x_74); +x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_65, x_62); +lean_dec(x_62); +return x_107; } } +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; +lean_dec(x_78); +lean_dec(x_1); +x_108 = l_Lean_Parser_Term_let___elambda__1___closed__2; +x_109 = l_Lean_Parser_ParserState_mkNode(x_77, x_108, x_74); +x_110 = l_Lean_Parser_mergeOrElseErrors(x_109, x_65, x_62); +lean_dec(x_62); +return x_110; +} +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; +lean_dec(x_76); +lean_dec(x_1); +x_111 = l_Lean_Parser_Term_let___elambda__1___closed__2; +x_112 = l_Lean_Parser_ParserState_mkNode(x_75, x_111, x_74); +x_113 = l_Lean_Parser_mergeOrElseErrors(x_112, x_65, x_62); +lean_dec(x_62); +return x_113; +} +} +} +else +{ +lean_object* x_129; +lean_dec(x_72); +lean_dec(x_1); +x_129 = l_Lean_Parser_mergeOrElseErrors(x_71, x_65, x_62); +lean_dec(x_62); +return x_129; +} } } } @@ -35334,18 +36563,17 @@ return x_105; lean_object* _init_l_Lean_Parser_Term_let___closed__1() { _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_let___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Tactic_seq___closed__2; @@ -35388,16 +36616,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_let___closed__6() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_let___closed__5; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_let___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_let___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_let___closed__5; +x_3 = l_Lean_Parser_Term_let___closed__6; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_let___closed__7() { +lean_object* _init_l_Lean_Parser_Term_let___closed__8() { _start: { lean_object* x_1; @@ -35405,12 +36643,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_let___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_let___closed__8() { +lean_object* _init_l_Lean_Parser_Term_let___closed__9() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_let___closed__6; -x_2 = l_Lean_Parser_Term_let___closed__7; +x_1 = l_Lean_Parser_Term_let___closed__7; +x_2 = l_Lean_Parser_Term_let___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); @@ -35421,7 +36659,7 @@ lean_object* _init_l_Lean_Parser_Term_let() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_let___closed__8; +x_1 = l_Lean_Parser_Term_let___closed__9; return x_1; } } @@ -35537,391 +36775,424 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_42 = lean_ctor_get(x_2, 1); -lean_inc(x_42); -lean_inc(x_1); -x_43 = l_Lean_Parser_tokenFn(x_1, x_2); -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_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_dec(x_46); -x_48 = l_Lean_Parser_Term_let_x21___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 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; -x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_50, x_42); -x_8 = x_51; -goto block_41; -} -else -{ -lean_dec(x_42); -x_8 = x_43; -goto block_41; -} -} -else -{ -lean_object* x_52; lean_object* x_53; -lean_dec(x_46); -x_52 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; -x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_52, x_42); -x_8 = x_53; -goto block_41; -} -} -else -{ -lean_object* x_54; lean_object* x_55; -lean_dec(x_44); -x_54 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; -x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_54, x_42); -x_8 = x_55; -goto block_41; -} -block_41: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_46; lean_object* x_47; lean_object* x_48; +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_46 = lean_ctor_get(x_8, 1); +lean_inc(x_46); lean_inc(x_1); -x_10 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_8); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 0) +x_47 = l_Lean_Parser_tokenFn(x_1, x_8); +x_48 = lean_ctor_get(x_47, 3); +lean_inc(x_48); +if (lean_obj_tag(x_48) == 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); +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_Lean_Parser_Term_let_x21___elambda__1___closed__6; +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_let_x21___elambda__1___closed__9; +x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_54, x_46); +x_12 = x_55; +goto block_45; +} +else +{ +lean_dec(x_46); +x_12 = x_47; +goto block_45; +} +} +else +{ +lean_object* x_56; lean_object* x_57; +lean_dec(x_50); +x_56 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; +x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_56, x_46); +x_12 = x_57; +goto block_45; +} +} +else +{ +lean_object* x_58; lean_object* x_59; +lean_dec(x_48); +x_58 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; +x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_47, x_58, x_46); +x_12 = x_59; +goto block_45; +} +block_45: +{ +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_inc(x_1); -x_13 = l_Lean_Parser_tokenFn(x_1, 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); +x_14 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_12); +x_15 = lean_ctor_get(x_14, 3); lean_inc(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) +if (lean_obj_tag(x_15) == 0) { -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_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -x_19 = lean_string_dec_eq(x_17, x_18); -lean_dec(x_17); -if (x_19 == 0) +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +lean_inc(x_1); +x_17 = l_Lean_Parser_tokenFn(x_1, 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_23; +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_checkStackTopFn___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___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; +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_dec(x_1); -x_20 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); -x_22 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_7); -return x_23; +x_24 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); +x_26 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; +x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_11); +return x_27; } else { -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; -lean_dec(x_12); -x_24 = l_Lean_Parser_termParser___closed__2; -x_25 = lean_unsigned_to_nat(0u); -x_26 = l_Lean_Parser_categoryParser___elambda__1(x_24, x_25, x_1, x_13); -x_27 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_7); -return x_28; -} -} -else -{ -lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_dec(x_16); -lean_dec(x_1); -x_29 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_29, x_12); +x_28 = l_Lean_Parser_termParser___closed__2; +x_29 = lean_unsigned_to_nat(0u); +x_30 = l_Lean_Parser_categoryParser___elambda__1(x_28, x_29, x_1, x_17); x_31 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_7); +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_11); return x_32; } } else { lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -lean_dec(x_14); +lean_dec(x_20); lean_dec(x_1); x_33 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_33, x_12); +x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_33, x_16); x_35 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_7); +x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_11); return x_36; } } else { -lean_object* x_37; lean_object* x_38; -lean_dec(x_11); -lean_dec(x_1); -x_37 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkNode(x_10, x_37, x_7); -return x_38; -} -} -else -{ -lean_object* x_39; lean_object* x_40; -lean_dec(x_9); +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +lean_dec(x_18); lean_dec(x_1); +x_37 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_38 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_37, x_16); x_39 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_40 = l_Lean_Parser_ParserState_mkNode(x_8, x_39, x_7); +x_40 = l_Lean_Parser_ParserState_mkNode(x_38, x_39, x_11); return x_40; } } +else +{ +lean_object* x_41; lean_object* x_42; +lean_dec(x_15); +lean_dec(x_1); +x_41 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkNode(x_14, x_41, x_11); +return x_42; +} } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -x_56 = lean_ctor_get(x_2, 0); -lean_inc(x_56); -x_57 = lean_array_get_size(x_56); -lean_dec(x_56); -x_58 = lean_ctor_get(x_2, 1); -lean_inc(x_58); -lean_inc(x_1); -x_59 = lean_apply_2(x_4, x_1, x_2); -x_60 = lean_ctor_get(x_59, 3); +lean_object* x_43; lean_object* x_44; +lean_dec(x_13); +lean_dec(x_1); +x_43 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; +x_44 = l_Lean_Parser_ParserState_mkNode(x_12, x_43, x_11); +return x_44; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_60); -if (lean_obj_tag(x_60) == 0) -{ -lean_dec(x_58); -lean_dec(x_57); -lean_dec(x_1); -return x_59; -} -else -{ -lean_object* x_61; lean_object* x_62; uint8_t x_63; -x_61 = lean_ctor_get(x_60, 0); -lean_inc(x_61); +x_61 = lean_array_get_size(x_60); lean_dec(x_60); -x_62 = lean_ctor_get(x_59, 1); +x_62 = lean_ctor_get(x_2, 1); lean_inc(x_62); -x_63 = lean_nat_dec_eq(x_62, x_58); -lean_dec(x_62); -if (x_63 == 0) +lean_inc(x_1); +x_63 = lean_apply_2(x_4, x_1, x_2); +x_64 = lean_ctor_get(x_63, 3); +lean_inc(x_64); +if (lean_obj_tag(x_64) == 0) { +lean_dec(x_62); lean_dec(x_61); -lean_dec(x_58); -lean_dec(x_57); lean_dec(x_1); -return x_59; +return x_63; } else { -lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_107; lean_object* x_108; -lean_inc(x_58); -x_64 = l_Lean_Parser_ParserState_restore(x_59, x_57, x_58); -lean_dec(x_57); +lean_object* x_65; lean_object* x_66; uint8_t x_67; x_65 = lean_ctor_get(x_64, 0); lean_inc(x_65); -x_66 = lean_array_get_size(x_65); +lean_dec(x_64); +x_66 = lean_ctor_get(x_63, 1); +lean_inc(x_66); +x_67 = lean_nat_dec_eq(x_66, x_62); +lean_dec(x_66); +if (x_67 == 0) +{ lean_dec(x_65); +lean_dec(x_62); +lean_dec(x_61); +lean_dec(x_1); +return x_63; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +lean_inc(x_62); +x_68 = l_Lean_Parser_ParserState_restore(x_63, x_61, x_62); +lean_dec(x_61); +x_69 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_70 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_71 = l_Lean_Parser_checkRbpLtFn(x_69, x_70, x_1, 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; lean_object* x_75; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_73 = lean_ctor_get(x_71, 0); +lean_inc(x_73); +x_74 = lean_array_get_size(x_73); +lean_dec(x_73); +x_115 = lean_ctor_get(x_71, 1); +lean_inc(x_115); lean_inc(x_1); -x_107 = l_Lean_Parser_tokenFn(x_1, x_64); -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); -x_110 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_109); -lean_dec(x_109); -if (lean_obj_tag(x_110) == 2) -{ -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_let_x21___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_let_x21___elambda__1___closed__9; -lean_inc(x_58); -x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_107, x_114, x_58); -x_67 = x_115; -goto block_106; -} -else -{ -x_67 = x_107; -goto block_106; -} -} -else -{ -lean_object* x_116; lean_object* x_117; -lean_dec(x_110); -x_116 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; -lean_inc(x_58); -x_117 = l_Lean_Parser_ParserState_mkErrorsAt(x_107, x_116, x_58); -x_67 = x_117; -goto block_106; -} -} -else +x_116 = l_Lean_Parser_tokenFn(x_1, x_71); +x_117 = lean_ctor_get(x_116, 3); +lean_inc(x_117); +if (lean_obj_tag(x_117) == 0) { lean_object* x_118; lean_object* x_119; -lean_dec(x_108); -x_118 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; -lean_inc(x_58); -x_119 = l_Lean_Parser_ParserState_mkErrorsAt(x_107, x_118, x_58); -x_67 = x_119; -goto block_106; +x_118 = lean_ctor_get(x_116, 0); +lean_inc(x_118); +x_119 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_118); +lean_dec(x_118); +if (lean_obj_tag(x_119) == 2) +{ +lean_object* x_120; lean_object* x_121; uint8_t x_122; +x_120 = lean_ctor_get(x_119, 1); +lean_inc(x_120); +lean_dec(x_119); +x_121 = l_Lean_Parser_Term_let_x21___elambda__1___closed__6; +x_122 = lean_string_dec_eq(x_120, x_121); +lean_dec(x_120); +if (x_122 == 0) +{ +lean_object* x_123; lean_object* x_124; +x_123 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_116, x_123, x_115); +x_75 = x_124; +goto block_114; } -block_106: +else { -lean_object* x_68; -x_68 = lean_ctor_get(x_67, 3); -lean_inc(x_68); -if (lean_obj_tag(x_68) == 0) +lean_dec(x_115); +x_75 = x_116; +goto block_114; +} +} +else { -lean_object* x_69; lean_object* x_70; -lean_inc(x_1); -x_69 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_67); -x_70 = lean_ctor_get(x_69, 3); -lean_inc(x_70); -if (lean_obj_tag(x_70) == 0) +lean_object* x_125; lean_object* x_126; +lean_dec(x_119); +x_125 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; +x_126 = l_Lean_Parser_ParserState_mkErrorsAt(x_116, x_125, x_115); +x_75 = x_126; +goto block_114; +} +} +else { -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_1); -x_72 = l_Lean_Parser_tokenFn(x_1, x_69); -x_73 = lean_ctor_get(x_72, 3); -lean_inc(x_73); -if (lean_obj_tag(x_73) == 0) +lean_object* x_127; lean_object* x_128; +lean_dec(x_117); +x_127 = l_Lean_Parser_Term_let_x21___elambda__1___closed__9; +x_128 = l_Lean_Parser_ParserState_mkErrorsAt(x_116, x_127, x_115); +x_75 = x_128; +goto block_114; +} +block_114: { -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_checkStackTopFn___spec__1(x_74); -lean_dec(x_74); -if (lean_obj_tag(x_75) == 2) -{ -lean_object* x_76; lean_object* x_77; uint8_t x_78; -x_76 = lean_ctor_get(x_75, 1); +lean_object* x_76; +x_76 = lean_ctor_get(x_75, 3); lean_inc(x_76); -lean_dec(x_75); -x_77 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__1; -x_78 = lean_string_dec_eq(x_76, x_77); -lean_dec(x_76); -if (x_78 == 0) +if (lean_obj_tag(x_76) == 0) { -lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +lean_object* x_77; lean_object* x_78; +lean_inc(x_1); +x_77 = l_Lean_Parser_Term_letDecl___elambda__1(x_1, x_75); +x_78 = lean_ctor_get(x_77, 3); +lean_inc(x_78); +if (lean_obj_tag(x_78) == 0) +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_79 = lean_ctor_get(x_77, 1); +lean_inc(x_79); +lean_inc(x_1); +x_80 = l_Lean_Parser_tokenFn(x_1, x_77); +x_81 = lean_ctor_get(x_80, 3); +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_checkStackTopFn___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_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___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; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_dec(x_1); -x_79 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_80 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_79, x_71); -x_81 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_82 = l_Lean_Parser_ParserState_mkNode(x_80, x_81, x_66); -x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_61, x_58); -lean_dec(x_58); -return x_83; +x_87 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_88 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_87, x_79); +x_89 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; +x_90 = l_Lean_Parser_ParserState_mkNode(x_88, x_89, x_74); +x_91 = l_Lean_Parser_mergeOrElseErrors(x_90, x_65, x_62); +lean_dec(x_62); +return x_91; } else { -lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; -lean_dec(x_71); -x_84 = l_Lean_Parser_termParser___closed__2; -x_85 = lean_unsigned_to_nat(0u); -x_86 = l_Lean_Parser_categoryParser___elambda__1(x_84, x_85, x_1, x_72); -x_87 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_88 = l_Lean_Parser_ParserState_mkNode(x_86, x_87, x_66); -x_89 = l_Lean_Parser_mergeOrElseErrors(x_88, x_61, x_58); -lean_dec(x_58); -return x_89; +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_79); +x_92 = l_Lean_Parser_termParser___closed__2; +x_93 = lean_unsigned_to_nat(0u); +x_94 = l_Lean_Parser_categoryParser___elambda__1(x_92, x_93, x_1, x_80); +x_95 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; +x_96 = l_Lean_Parser_ParserState_mkNode(x_94, x_95, x_74); +x_97 = l_Lean_Parser_mergeOrElseErrors(x_96, x_65, x_62); +lean_dec(x_62); +return x_97; } } else { -lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; -lean_dec(x_75); -lean_dec(x_1); -x_90 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_90, x_71); -x_92 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_93 = l_Lean_Parser_ParserState_mkNode(x_91, x_92, x_66); -x_94 = l_Lean_Parser_mergeOrElseErrors(x_93, x_61, x_58); -lean_dec(x_58); -return x_94; -} -} -else -{ -lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; -lean_dec(x_73); -lean_dec(x_1); -x_95 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; -x_96 = l_Lean_Parser_ParserState_mkErrorsAt(x_72, x_95, x_71); -x_97 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_98 = l_Lean_Parser_ParserState_mkNode(x_96, x_97, x_66); -x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_61, x_58); -lean_dec(x_58); -return x_99; -} -} -else -{ -lean_object* x_100; lean_object* x_101; lean_object* x_102; -lean_dec(x_70); +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; +lean_dec(x_83); lean_dec(x_1); +x_98 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_99 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_98, x_79); x_100 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_101 = l_Lean_Parser_ParserState_mkNode(x_69, x_100, x_66); -x_102 = l_Lean_Parser_mergeOrElseErrors(x_101, x_61, x_58); -lean_dec(x_58); +x_101 = l_Lean_Parser_ParserState_mkNode(x_99, x_100, x_74); +x_102 = l_Lean_Parser_mergeOrElseErrors(x_101, x_65, x_62); +lean_dec(x_62); return x_102; } } else { -lean_object* x_103; lean_object* x_104; lean_object* x_105; -lean_dec(x_68); +lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_81); lean_dec(x_1); -x_103 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; -x_104 = l_Lean_Parser_ParserState_mkNode(x_67, x_103, x_66); -x_105 = l_Lean_Parser_mergeOrElseErrors(x_104, x_61, x_58); -lean_dec(x_58); -return x_105; +x_103 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_seq___elambda__1___spec__2___closed__4; +x_104 = l_Lean_Parser_ParserState_mkErrorsAt(x_80, x_103, x_79); +x_105 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; +x_106 = l_Lean_Parser_ParserState_mkNode(x_104, x_105, x_74); +x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_65, x_62); +lean_dec(x_62); +return x_107; } } +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; +lean_dec(x_78); +lean_dec(x_1); +x_108 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; +x_109 = l_Lean_Parser_ParserState_mkNode(x_77, x_108, x_74); +x_110 = l_Lean_Parser_mergeOrElseErrors(x_109, x_65, x_62); +lean_dec(x_62); +return x_110; +} +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; +lean_dec(x_76); +lean_dec(x_1); +x_111 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; +x_112 = l_Lean_Parser_ParserState_mkNode(x_75, x_111, x_74); +x_113 = l_Lean_Parser_mergeOrElseErrors(x_112, x_65, x_62); +lean_dec(x_62); +return x_113; +} +} +} +else +{ +lean_object* x_129; +lean_dec(x_72); +lean_dec(x_1); +x_129 = l_Lean_Parser_mergeOrElseErrors(x_71, x_65, x_62); +lean_dec(x_62); +return x_129; +} } } } @@ -35930,11 +37201,10 @@ return x_105; lean_object* _init_l_Lean_Parser_Term_let_x21___closed__1() { _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_let_x21___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_let_x21___closed__2() { @@ -35960,16 +37230,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_let_x21___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_let_x21___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_let_x21___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_let_x21___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_let_x21___closed__3; +x_3 = l_Lean_Parser_Term_let_x21___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_let_x21___closed__5() { +lean_object* _init_l_Lean_Parser_Term_let_x21___closed__6() { _start: { lean_object* x_1; @@ -35977,12 +37257,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_let_x21___elambda__1), 2, 0) return x_1; } } -lean_object* _init_l_Lean_Parser_Term_let_x21___closed__6() { +lean_object* _init_l_Lean_Parser_Term_let_x21___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_let_x21___closed__4; -x_2 = l_Lean_Parser_Term_let_x21___closed__5; +x_1 = l_Lean_Parser_Term_let_x21___closed__5; +x_2 = l_Lean_Parser_Term_let_x21___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); @@ -35993,7 +37273,7 @@ lean_object* _init_l_Lean_Parser_Term_let_x21() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_let_x21___closed__6; +x_1 = l_Lean_Parser_Term_let_x21___closed__7; return x_1; } } @@ -36109,12 +37389,11 @@ return x_6; 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___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; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__2; +x_2 = l_Lean_Parser_Term_leftArrow___elambda__1___closed__4; +x_3 = l_Lean_Parser_unicodeSymbolInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_leftArrow___closed__2() { @@ -36861,7 +38140,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_doId___closed__2; @@ -37675,7 +38954,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_leftArrow; @@ -37688,18 +38967,17 @@ return x_5; lean_object* _init_l_Lean_Parser_Term_doPat___closed__2() { _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_doPat___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_doPat___closed__2; @@ -37720,7 +38998,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_doPat___closed__4; @@ -37917,7 +39195,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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_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; @@ -38528,379 +39806,412 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_40; lean_object* x_41; lean_object* x_42; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_40 = lean_ctor_get(x_2, 1); -lean_inc(x_40); -lean_inc(x_1); -x_41 = l_Lean_Parser_tokenFn(x_1, x_2); -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_Lean_Parser_Term_structInst___elambda__1___closed__5; -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_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40); -x_8 = x_49; -goto block_39; -} -else -{ -lean_dec(x_40); -x_8 = x_41; -goto block_39; -} -} -else -{ -lean_object* x_50; lean_object* x_51; -lean_dec(x_44); -x_50 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40); -x_8 = x_51; -goto block_39; -} -} -else -{ -lean_object* x_52; lean_object* x_53; -lean_dec(x_42); -x_52 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40); -x_8 = x_53; -goto block_39; -} -block_39: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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) { -uint8_t x_10; lean_object* x_11; lean_object* x_12; -x_10 = 0; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_44; 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_44 = lean_ctor_get(x_8, 1); +lean_inc(x_44); lean_inc(x_1); -x_11 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_10, x_10, x_1, x_8); -x_12 = lean_ctor_get(x_11, 3); -lean_inc(x_12); -if (lean_obj_tag(x_12) == 0) +x_45 = l_Lean_Parser_tokenFn(x_1, x_8); +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; -x_13 = lean_ctor_get(x_11, 1); +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_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_structInst___elambda__1___closed__5; +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_structInst___elambda__1___closed__17; +x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_44); +x_12 = x_53; +goto block_43; +} +else +{ +lean_dec(x_44); +x_12 = x_45; +goto block_43; +} +} +else +{ +lean_object* x_54; lean_object* x_55; +lean_dec(x_48); +x_54 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_44); +x_12 = x_55; +goto block_43; +} +} +else +{ +lean_object* x_56; lean_object* x_57; +lean_dec(x_46); +x_56 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_44); +x_12 = x_57; +goto block_43; +} +block_43: +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_12, 3); 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) +if (lean_obj_tag(x_13) == 0) { -lean_object* x_16; lean_object* x_17; -x_16 = lean_ctor_get(x_14, 0); +uint8_t x_14; lean_object* x_15; lean_object* x_16; +x_14 = 0; +lean_inc(x_1); +x_15 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_14, x_14, x_1, x_12); +x_16 = lean_ctor_get(x_15, 3); 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) +if (lean_obj_tag(x_16) == 0) { -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_Term_explicitUniv___elambda__1___closed__7; -x_20 = lean_string_dec_eq(x_18, x_19); -lean_dec(x_18); -if (x_20 == 0) +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_15, 1); +lean_inc(x_17); +x_18 = l_Lean_Parser_tokenFn(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; -x_21 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_22 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_21, x_13); -x_23 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_7); -return x_24; +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_18, 0); +lean_inc(x_20); +x_21 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_20); +lean_dec(x_20); +if (lean_obj_tag(x_21) == 2) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; +x_22 = lean_ctor_get(x_21, 1); +lean_inc(x_22); +lean_dec(x_21); +x_23 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__7; +x_24 = lean_string_dec_eq(x_22, x_23); +lean_dec(x_22); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_25 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_25, x_17); +x_27 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; +x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_11); +return x_28; } else { -lean_object* x_25; lean_object* x_26; -lean_dec(x_13); -x_25 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_26 = l_Lean_Parser_ParserState_mkNode(x_14, x_25, x_7); -return x_26; -} -} -else -{ -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_object* x_29; lean_object* x_30; lean_dec(x_17); -x_27 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_27, x_13); x_29 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_7); +x_30 = l_Lean_Parser_ParserState_mkNode(x_18, x_29, x_11); return x_30; } } else { lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_15); +lean_dec(x_21); x_31 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_31, x_13); +x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_31, x_17); x_33 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_7); +x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_11); return x_34; } } else { -lean_object* x_35; lean_object* x_36; -lean_dec(x_12); -lean_dec(x_1); -x_35 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_11, x_35, x_7); -return x_36; -} -} -else -{ -lean_object* x_37; lean_object* x_38; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_19); +x_35 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; +x_36 = l_Lean_Parser_ParserState_mkErrorsAt(x_18, x_35, x_17); x_37 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkNode(x_8, x_37, x_7); +x_38 = l_Lean_Parser_ParserState_mkNode(x_36, x_37, x_11); return x_38; } } +else +{ +lean_object* x_39; lean_object* x_40; +lean_dec(x_16); +lean_dec(x_1); +x_39 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; +x_40 = l_Lean_Parser_ParserState_mkNode(x_15, x_39, x_11); +return x_40; +} } else { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_2, 0); -lean_inc(x_54); -x_55 = lean_array_get_size(x_54); -lean_dec(x_54); -x_56 = lean_ctor_get(x_2, 1); -lean_inc(x_56); -lean_inc(x_1); -x_57 = lean_apply_2(x_4, x_1, x_2); -x_58 = lean_ctor_get(x_57, 3); +lean_object* x_41; lean_object* x_42; +lean_dec(x_13); +lean_dec(x_1); +x_41 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkNode(x_12, x_41, x_11); +return x_42; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +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_2, 0); lean_inc(x_58); -if (lean_obj_tag(x_58) == 0) -{ -lean_dec(x_56); -lean_dec(x_55); -lean_dec(x_1); -return x_57; -} -else -{ -lean_object* x_59; lean_object* x_60; uint8_t x_61; -x_59 = lean_ctor_get(x_58, 0); -lean_inc(x_59); +x_59 = lean_array_get_size(x_58); lean_dec(x_58); -x_60 = lean_ctor_get(x_57, 1); +x_60 = lean_ctor_get(x_2, 1); lean_inc(x_60); -x_61 = lean_nat_dec_eq(x_60, x_56); -lean_dec(x_60); -if (x_61 == 0) +lean_inc(x_1); +x_61 = lean_apply_2(x_4, x_1, x_2); +x_62 = lean_ctor_get(x_61, 3); +lean_inc(x_62); +if (lean_obj_tag(x_62) == 0) { +lean_dec(x_60); lean_dec(x_59); -lean_dec(x_56); -lean_dec(x_55); lean_dec(x_1); -return x_57; +return x_61; } else { -lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_103; lean_object* x_104; -lean_inc(x_56); -x_62 = l_Lean_Parser_ParserState_restore(x_57, x_55, x_56); -lean_dec(x_55); +lean_object* x_63; lean_object* x_64; uint8_t x_65; x_63 = lean_ctor_get(x_62, 0); lean_inc(x_63); -x_64 = lean_array_get_size(x_63); +lean_dec(x_62); +x_64 = lean_ctor_get(x_61, 1); +lean_inc(x_64); +x_65 = lean_nat_dec_eq(x_64, x_60); +lean_dec(x_64); +if (x_65 == 0) +{ lean_dec(x_63); +lean_dec(x_60); +lean_dec(x_59); +lean_dec(x_1); +return x_61; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_inc(x_60); +x_66 = l_Lean_Parser_ParserState_restore(x_61, x_59, x_60); +lean_dec(x_59); +x_67 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_68 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_69 = l_Lean_Parser_checkRbpLtFn(x_67, 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_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_71 = lean_ctor_get(x_69, 0); +lean_inc(x_71); +x_72 = lean_array_get_size(x_71); +lean_dec(x_71); +x_111 = lean_ctor_get(x_69, 1); +lean_inc(x_111); lean_inc(x_1); -x_103 = l_Lean_Parser_tokenFn(x_1, x_62); -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; -x_105 = lean_ctor_get(x_103, 0); -lean_inc(x_105); -x_106 = l_Array_back___at_Lean_Parser_checkStackTopFn___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_Lean_Parser_Term_structInst___elambda__1___closed__5; -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_Term_structInst___elambda__1___closed__17; -lean_inc(x_56); -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_110, x_56); -x_65 = x_111; -goto block_102; -} -else -{ -x_65 = x_103; -goto block_102; -} -} -else -{ -lean_object* x_112; lean_object* x_113; -lean_dec(x_106); -x_112 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_56); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_112, x_56); -x_65 = x_113; -goto block_102; -} -} -else +x_112 = l_Lean_Parser_tokenFn(x_1, x_69); +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_dec(x_104); -x_114 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; -lean_inc(x_56); -x_115 = l_Lean_Parser_ParserState_mkErrorsAt(x_103, x_114, x_56); -x_65 = x_115; -goto block_102; +x_114 = lean_ctor_get(x_112, 0); +lean_inc(x_114); +x_115 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_114); +lean_dec(x_114); +if (lean_obj_tag(x_115) == 2) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +lean_dec(x_115); +x_117 = l_Lean_Parser_Term_structInst___elambda__1___closed__5; +x_118 = lean_string_dec_eq(x_116, x_117); +lean_dec(x_116); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; +x_119 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_119, x_111); +x_73 = x_120; +goto block_110; } -block_102: +else { -lean_object* x_66; -x_66 = lean_ctor_get(x_65, 3); -lean_inc(x_66); -if (lean_obj_tag(x_66) == 0) +lean_dec(x_111); +x_73 = x_112; +goto block_110; +} +} +else { -uint8_t x_67; lean_object* x_68; lean_object* x_69; -x_67 = 0; +lean_object* x_121; lean_object* x_122; +lean_dec(x_115); +x_121 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_121, x_111); +x_73 = x_122; +goto block_110; +} +} +else +{ +lean_object* x_123; lean_object* x_124; +lean_dec(x_113); +x_123 = l_Lean_Parser_Term_structInst___elambda__1___closed__17; +x_124 = l_Lean_Parser_ParserState_mkErrorsAt(x_112, x_123, x_111); +x_73 = x_124; +goto block_110; +} +block_110: +{ +lean_object* x_74; +x_74 = lean_ctor_get(x_73, 3); +lean_inc(x_74); +if (lean_obj_tag(x_74) == 0) +{ +uint8_t x_75; lean_object* x_76; lean_object* x_77; +x_75 = 0; lean_inc(x_1); -x_68 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_67, x_67, x_1, x_65); -x_69 = lean_ctor_get(x_68, 3); -lean_inc(x_69); -if (lean_obj_tag(x_69) == 0) +x_76 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_75, x_75, x_1, x_73); +x_77 = lean_ctor_get(x_76, 3); +lean_inc(x_77); +if (lean_obj_tag(x_77) == 0) { -lean_object* x_70; lean_object* x_71; lean_object* x_72; -x_70 = lean_ctor_get(x_68, 1); -lean_inc(x_70); -x_71 = l_Lean_Parser_tokenFn(x_1, x_68); -x_72 = lean_ctor_get(x_71, 3); -lean_inc(x_72); -if (lean_obj_tag(x_72) == 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); +x_79 = l_Lean_Parser_tokenFn(x_1, x_76); +x_80 = lean_ctor_get(x_79, 3); +lean_inc(x_80); +if (lean_obj_tag(x_80) == 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_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_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_explicitUniv___elambda__1___closed__7; -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_explicitUniv___elambda__1___closed__11; -x_79 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_78, x_70); -x_80 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_81 = l_Lean_Parser_ParserState_mkNode(x_79, x_80, x_64); -x_82 = l_Lean_Parser_mergeOrElseErrors(x_81, x_59, x_56); -lean_dec(x_56); -return x_82; -} -else -{ -lean_object* x_83; lean_object* x_84; lean_object* x_85; -lean_dec(x_70); -x_83 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_84 = l_Lean_Parser_ParserState_mkNode(x_71, x_83, x_64); -x_85 = l_Lean_Parser_mergeOrElseErrors(x_84, x_59, x_56); -lean_dec(x_56); -return x_85; -} -} -else +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_explicitUniv___elambda__1___closed__7; +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; -lean_dec(x_74); x_86 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_86, x_70); +x_87 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_86, x_78); x_88 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_64); -x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_59, x_56); -lean_dec(x_56); +x_89 = l_Lean_Parser_ParserState_mkNode(x_87, x_88, x_72); +x_90 = l_Lean_Parser_mergeOrElseErrors(x_89, x_63, x_60); +lean_dec(x_60); 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_72); -x_91 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__11; -x_92 = l_Lean_Parser_ParserState_mkErrorsAt(x_71, x_91, x_70); -x_93 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_94 = l_Lean_Parser_ParserState_mkNode(x_92, x_93, x_64); -x_95 = l_Lean_Parser_mergeOrElseErrors(x_94, x_59, x_56); -lean_dec(x_56); -return x_95; +lean_object* x_91; lean_object* x_92; lean_object* x_93; +lean_dec(x_78); +x_91 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; +x_92 = l_Lean_Parser_ParserState_mkNode(x_79, x_91, x_72); +x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_63, x_60); +lean_dec(x_60); +return x_93; } } else { -lean_object* x_96; lean_object* x_97; lean_object* x_98; -lean_dec(x_69); -lean_dec(x_1); +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_Term_explicitUniv___elambda__1___closed__11; +x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_94, x_78); x_96 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_97 = l_Lean_Parser_ParserState_mkNode(x_68, x_96, x_64); -x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_59, x_56); -lean_dec(x_56); +x_97 = l_Lean_Parser_ParserState_mkNode(x_95, x_96, x_72); +x_98 = l_Lean_Parser_mergeOrElseErrors(x_97, x_63, x_60); +lean_dec(x_60); return x_98; } } else { -lean_object* x_99; lean_object* x_100; lean_object* x_101; -lean_dec(x_66); -lean_dec(x_1); -x_99 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; -x_100 = l_Lean_Parser_ParserState_mkNode(x_65, x_99, x_64); -x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_59, x_56); -lean_dec(x_56); -return x_101; +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_Term_explicitUniv___elambda__1___closed__11; +x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_79, x_99, x_78); +x_101 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; +x_102 = l_Lean_Parser_ParserState_mkNode(x_100, x_101, x_72); +x_103 = l_Lean_Parser_mergeOrElseErrors(x_102, x_63, x_60); +lean_dec(x_60); +return x_103; } } +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +lean_dec(x_77); +lean_dec(x_1); +x_104 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; +x_105 = l_Lean_Parser_ParserState_mkNode(x_76, x_104, x_72); +x_106 = l_Lean_Parser_mergeOrElseErrors(x_105, x_63, x_60); +lean_dec(x_60); +return x_106; +} +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; +lean_dec(x_74); +lean_dec(x_1); +x_107 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1___closed__2; +x_108 = l_Lean_Parser_ParserState_mkNode(x_73, x_107, x_72); +x_109 = l_Lean_Parser_mergeOrElseErrors(x_108, x_63, x_60); +lean_dec(x_60); +return x_109; +} +} +} +else +{ +lean_object* x_125; +lean_dec(x_70); +lean_dec(x_1); +x_125 = l_Lean_Parser_mergeOrElseErrors(x_69, x_63, x_60); +lean_dec(x_60); +return x_125; +} } } } @@ -38941,16 +40252,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_bracketedDoSeq___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq___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_bracketedDoSeq___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_bracketedDoSeq___closed__3; +x_3 = l_Lean_Parser_Term_bracketedDoSeq___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq___closed__5() { +lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq___closed__6() { _start: { lean_object* x_1; @@ -38958,12 +40279,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bracketedDoSeq___elambda__1) return x_1; } } -lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq___closed__6() { +lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_bracketedDoSeq___closed__4; -x_2 = l_Lean_Parser_Term_bracketedDoSeq___closed__5; +x_1 = l_Lean_Parser_Term_bracketedDoSeq___closed__5; +x_2 = l_Lean_Parser_Term_bracketedDoSeq___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); @@ -38974,7 +40295,7 @@ lean_object* _init_l_Lean_Parser_Term_bracketedDoSeq() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_bracketedDoSeq___closed__6; +x_1 = l_Lean_Parser_Term_bracketedDoSeq___closed__7; return x_1; } } @@ -39031,108 +40352,141 @@ if (x_5 == 0) { lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -lean_inc(x_1); -x_8 = l_Lean_Parser_Term_leftArrow___elambda__1(x_1, x_2); +x_6 = lean_unsigned_to_nat(1u); +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(0u); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); -x_13 = l_Lean_Parser_Term_liftMethod___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7); -return x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +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_12 = l_Lean_Parser_Term_leftArrow___elambda__1(x_1, x_8); +x_13 = lean_ctor_get(x_12, 3); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(0u); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = l_Lean_Parser_Term_liftMethod___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_11); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_liftMethod___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_12, x_19, x_11); +return x_20; +} } else { -lean_object* x_15; lean_object* x_16; lean_dec(x_9); lean_dec(x_1); -x_15 = l_Lean_Parser_Term_liftMethod___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_8, x_15, x_7); -return x_16; +return x_8; } } else { -lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; -x_17 = lean_ctor_get(x_2, 0); -lean_inc(x_17); -x_18 = lean_array_get_size(x_17); -lean_dec(x_17); -x_19 = lean_ctor_get(x_2, 1); -lean_inc(x_19); -lean_inc(x_1); -x_20 = lean_apply_2(x_4, x_1, x_2); -x_21 = lean_ctor_get(x_20, 3); +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_2, 0); lean_inc(x_21); -if (lean_obj_tag(x_21) == 0) -{ -lean_dec(x_19); -lean_dec(x_18); -lean_dec(x_1); -return x_20; -} -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); +x_22 = lean_array_get_size(x_21); lean_dec(x_21); -x_23 = lean_ctor_get(x_20, 1); +x_23 = lean_ctor_get(x_2, 1); lean_inc(x_23); -x_24 = lean_nat_dec_eq(x_23, x_19); -lean_dec(x_23); -if (x_24 == 0) +lean_inc(x_1); +x_24 = lean_apply_2(x_4, x_1, x_2); +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); -lean_dec(x_19); -lean_dec(x_18); lean_dec(x_1); -return x_20; +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_19); -x_25 = l_Lean_Parser_ParserState_restore(x_20, x_18, x_19); -lean_dec(x_18); +lean_object* x_26; lean_object* x_27; uint8_t x_28; x_26 = lean_ctor_get(x_25, 0); lean_inc(x_26); -x_27 = lean_array_get_size(x_26); -lean_dec(x_26); -lean_inc(x_1); -x_28 = l_Lean_Parser_Term_leftArrow___elambda__1(x_1, x_25); -x_29 = lean_ctor_get(x_28, 3); -lean_inc(x_29); -if (lean_obj_tag(x_29) == 0) +lean_dec(x_25); +x_27 = lean_ctor_get(x_24, 1); +lean_inc(x_27); +x_28 = lean_nat_dec_eq(x_27, x_23); +lean_dec(x_27); +if (x_28 == 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; -x_30 = l_Lean_Parser_termParser___closed__2; -x_31 = lean_unsigned_to_nat(0u); -x_32 = l_Lean_Parser_categoryParser___elambda__1(x_30, x_31, x_1, x_28); -x_33 = l_Lean_Parser_Term_liftMethod___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_27); -x_35 = l_Lean_Parser_mergeOrElseErrors(x_34, x_22, x_19); -lean_dec(x_19); -return x_35; +lean_dec(x_26); +lean_dec(x_23); +lean_dec(x_22); +lean_dec(x_1); +return x_24; } else { -lean_object* x_36; lean_object* x_37; lean_object* x_38; -lean_dec(x_29); +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_inc(x_23); +x_29 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); +lean_dec(x_22); +x_30 = lean_unsigned_to_nat(1u); +x_31 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_32 = l_Lean_Parser_checkRbpLtFn(x_30, x_31, 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; lean_object* x_37; +x_34 = lean_ctor_get(x_32, 0); +lean_inc(x_34); +x_35 = lean_array_get_size(x_34); +lean_dec(x_34); +lean_inc(x_1); +x_36 = l_Lean_Parser_Term_leftArrow___elambda__1(x_1, x_32); +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_object* x_42; lean_object* x_43; +x_38 = l_Lean_Parser_termParser___closed__2; +x_39 = lean_unsigned_to_nat(0u); +x_40 = l_Lean_Parser_categoryParser___elambda__1(x_38, x_39, x_1, x_36); +x_41 = l_Lean_Parser_Term_liftMethod___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkNode(x_40, x_41, x_35); +x_43 = l_Lean_Parser_mergeOrElseErrors(x_42, x_26, x_23); +lean_dec(x_23); +return x_43; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_dec(x_37); lean_dec(x_1); -x_36 = l_Lean_Parser_Term_liftMethod___elambda__1___closed__2; -x_37 = l_Lean_Parser_ParserState_mkNode(x_28, x_36, x_27); -x_38 = l_Lean_Parser_mergeOrElseErrors(x_37, x_22, x_19); -lean_dec(x_19); -return x_38; +x_44 = l_Lean_Parser_Term_liftMethod___elambda__1___closed__2; +x_45 = l_Lean_Parser_ParserState_mkNode(x_36, x_44, x_35); +x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_26, x_23); +lean_dec(x_23); +return x_46; +} +} +else +{ +lean_object* x_47; +lean_dec(x_33); +lean_dec(x_1); +x_47 = l_Lean_Parser_mergeOrElseErrors(x_32, x_26, x_23); +lean_dec(x_23); +return x_47; } } } @@ -39146,7 +40500,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_leftArrow; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_3 = l_Lean_Parser_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); @@ -39166,16 +40520,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_liftMethod___closed__3() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_liftMethod___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_liftMethod___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_liftMethod___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_liftMethod___closed__2; +x_3 = l_Lean_Parser_Term_liftMethod___closed__3; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_liftMethod___closed__4() { +lean_object* _init_l_Lean_Parser_Term_liftMethod___closed__5() { _start: { lean_object* x_1; @@ -39183,12 +40547,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_liftMethod___elambda__1), 2, return x_1; } } -lean_object* _init_l_Lean_Parser_Term_liftMethod___closed__5() { +lean_object* _init_l_Lean_Parser_Term_liftMethod___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_liftMethod___closed__3; -x_2 = l_Lean_Parser_Term_liftMethod___closed__4; +x_1 = l_Lean_Parser_Term_liftMethod___closed__4; +x_2 = l_Lean_Parser_Term_liftMethod___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); @@ -39199,7 +40563,7 @@ lean_object* _init_l_Lean_Parser_Term_liftMethod() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_liftMethod___closed__5; +x_1 = l_Lean_Parser_Term_liftMethod___closed__6; return x_1; } } @@ -39315,332 +40679,365 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_31 = lean_ctor_get(x_2, 1); -lean_inc(x_31); -lean_inc(x_1); -x_32 = l_Lean_Parser_tokenFn(x_1, x_2); -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_checkStackTopFn___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_do___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_do___elambda__1___closed__9; -x_40 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_39, x_31); -x_8 = x_40; -goto block_30; -} -else -{ -lean_dec(x_31); -x_8 = x_32; -goto block_30; -} -} -else -{ -lean_object* x_41; lean_object* x_42; -lean_dec(x_35); -x_41 = l_Lean_Parser_Term_do___elambda__1___closed__9; -x_42 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_41, x_31); -x_8 = x_42; -goto block_30; -} -} -else -{ -lean_object* x_43; lean_object* x_44; -lean_dec(x_33); -x_43 = l_Lean_Parser_Term_do___elambda__1___closed__9; -x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_32, x_43, x_31); -x_8 = x_44; -goto block_30; -} -block_30: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_35; lean_object* x_36; lean_object* x_37; 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_35 = lean_ctor_get(x_8, 1); +lean_inc(x_35); lean_inc(x_1); -x_13 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1(x_1, x_8); -x_14 = lean_ctor_get(x_13, 3); +x_36 = l_Lean_Parser_tokenFn(x_1, x_8); +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); +x_39 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_38); +lean_dec(x_38); +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_Term_do___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_Term_do___elambda__1___closed__9; +x_44 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_43, x_35); +x_12 = x_44; +goto block_34; +} +else +{ +lean_dec(x_35); +x_12 = x_36; +goto block_34; +} +} +else +{ +lean_object* x_45; lean_object* x_46; +lean_dec(x_39); +x_45 = l_Lean_Parser_Term_do___elambda__1___closed__9; +x_46 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_45, x_35); +x_12 = x_46; +goto block_34; +} +} +else +{ +lean_object* x_47; lean_object* x_48; +lean_dec(x_37); +x_47 = l_Lean_Parser_Term_do___elambda__1___closed__9; +x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_36, x_47, x_35); +x_12 = x_48; +goto block_34; +} +block_34: +{ +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_18; +x_14 = lean_ctor_get(x_12, 0); 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_do___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_13, x_15, 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); +x_15 = lean_array_get_size(x_14); lean_dec(x_14); -x_18 = lean_ctor_get(x_13, 1); +x_16 = lean_ctor_get(x_12, 1); +lean_inc(x_16); +lean_inc(x_1); +x_17 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1(x_1, x_12); +x_18 = lean_ctor_get(x_17, 3); lean_inc(x_18); -x_19 = lean_nat_dec_eq(x_18, x_12); -lean_dec(x_18); -if (x_19 == 0) +if (lean_obj_tag(x_18) == 0) { -lean_object* x_20; lean_object* x_21; -lean_dec(x_17); -lean_dec(x_12); -lean_dec(x_11); +lean_object* x_19; lean_object* x_20; +lean_dec(x_16); +lean_dec(x_15); lean_dec(x_1); -x_20 = l_Lean_Parser_Term_do___elambda__1___closed__2; -x_21 = l_Lean_Parser_ParserState_mkNode(x_13, x_20, x_7); -return x_21; +x_19 = l_Lean_Parser_Term_do___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_17, x_19, x_11); +return x_20; } else { -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_inc(x_12); -x_22 = l_Lean_Parser_ParserState_restore(x_13, x_11, x_12); -lean_dec(x_11); -x_23 = 0; -x_24 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_23, x_23, x_1, x_22); -x_25 = l_Lean_Parser_mergeOrElseErrors(x_24, x_17, x_12); -lean_dec(x_12); -x_26 = l_Lean_Parser_Term_do___elambda__1___closed__2; -x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_7); -return x_27; +lean_object* x_21; lean_object* x_22; uint8_t x_23; +x_21 = lean_ctor_get(x_18, 0); +lean_inc(x_21); +lean_dec(x_18); +x_22 = lean_ctor_get(x_17, 1); +lean_inc(x_22); +x_23 = lean_nat_dec_eq(x_22, x_16); +lean_dec(x_22); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; +lean_dec(x_21); +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_1); +x_24 = l_Lean_Parser_Term_do___elambda__1___closed__2; +x_25 = l_Lean_Parser_ParserState_mkNode(x_17, x_24, x_11); +return x_25; +} +else +{ +lean_object* x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +lean_inc(x_16); +x_26 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16); +lean_dec(x_15); +x_27 = 0; +x_28 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_27, x_27, x_1, x_26); +x_29 = l_Lean_Parser_mergeOrElseErrors(x_28, x_21, x_16); +lean_dec(x_16); +x_30 = l_Lean_Parser_Term_do___elambda__1___closed__2; +x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_11); +return x_31; +} +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_13); +lean_dec(x_1); +x_32 = l_Lean_Parser_Term_do___elambda__1___closed__2; +x_33 = l_Lean_Parser_ParserState_mkNode(x_12, x_32, x_11); +return x_33; } } } else { -lean_object* x_28; lean_object* x_29; lean_dec(x_9); lean_dec(x_1); -x_28 = l_Lean_Parser_Term_do___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_8, x_28, x_7); -return x_29; -} +return x_8; } } else { -lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; -x_45 = lean_ctor_get(x_2, 0); -lean_inc(x_45); -x_46 = lean_array_get_size(x_45); -lean_dec(x_45); -x_47 = lean_ctor_get(x_2, 1); -lean_inc(x_47); -lean_inc(x_1); -x_48 = lean_apply_2(x_4, x_1, x_2); -x_49 = lean_ctor_get(x_48, 3); +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_49 = lean_ctor_get(x_2, 0); lean_inc(x_49); -if (lean_obj_tag(x_49) == 0) -{ -lean_dec(x_47); -lean_dec(x_46); -lean_dec(x_1); -return x_48; -} -else -{ -lean_object* x_50; lean_object* x_51; uint8_t x_52; -x_50 = lean_ctor_get(x_49, 0); -lean_inc(x_50); +x_50 = lean_array_get_size(x_49); lean_dec(x_49); -x_51 = lean_ctor_get(x_48, 1); +x_51 = lean_ctor_get(x_2, 1); lean_inc(x_51); -x_52 = lean_nat_dec_eq(x_51, x_47); -lean_dec(x_51); -if (x_52 == 0) +lean_inc(x_1); +x_52 = lean_apply_2(x_4, x_1, x_2); +x_53 = lean_ctor_get(x_52, 3); +lean_inc(x_53); +if (lean_obj_tag(x_53) == 0) { +lean_dec(x_51); lean_dec(x_50); -lean_dec(x_47); -lean_dec(x_46); lean_dec(x_1); -return x_48; +return x_52; } else { -lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_83; lean_object* x_84; -lean_inc(x_47); -x_53 = l_Lean_Parser_ParserState_restore(x_48, x_46, x_47); -lean_dec(x_46); +lean_object* x_54; lean_object* x_55; uint8_t x_56; x_54 = lean_ctor_get(x_53, 0); lean_inc(x_54); -x_55 = lean_array_get_size(x_54); +lean_dec(x_53); +x_55 = lean_ctor_get(x_52, 1); +lean_inc(x_55); +x_56 = lean_nat_dec_eq(x_55, x_51); +lean_dec(x_55); +if (x_56 == 0) +{ lean_dec(x_54); +lean_dec(x_51); +lean_dec(x_50); +lean_dec(x_1); +return x_52; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_inc(x_51); +x_57 = l_Lean_Parser_ParserState_restore(x_52, x_50, x_51); +lean_dec(x_50); +x_58 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_59 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_60 = l_Lean_Parser_checkRbpLtFn(x_58, x_59, x_1, x_57); +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_91; lean_object* x_92; lean_object* x_93; +x_62 = lean_ctor_get(x_60, 0); +lean_inc(x_62); +x_63 = lean_array_get_size(x_62); +lean_dec(x_62); +x_91 = lean_ctor_get(x_60, 1); +lean_inc(x_91); lean_inc(x_1); -x_83 = l_Lean_Parser_tokenFn(x_1, x_53); -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_do___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_90; lean_object* x_91; -x_90 = l_Lean_Parser_Term_do___elambda__1___closed__9; -lean_inc(x_47); -x_91 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_90, x_47); -x_56 = x_91; -goto block_82; -} -else -{ -x_56 = x_83; -goto block_82; -} -} -else -{ -lean_object* x_92; lean_object* x_93; -lean_dec(x_86); -x_92 = l_Lean_Parser_Term_do___elambda__1___closed__9; -lean_inc(x_47); -x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_92, x_47); -x_56 = x_93; -goto block_82; -} -} -else +x_92 = l_Lean_Parser_tokenFn(x_1, x_60); +x_93 = lean_ctor_get(x_92, 3); +lean_inc(x_93); +if (lean_obj_tag(x_93) == 0) { lean_object* x_94; lean_object* x_95; -lean_dec(x_84); -x_94 = l_Lean_Parser_Term_do___elambda__1___closed__9; -lean_inc(x_47); -x_95 = l_Lean_Parser_ParserState_mkErrorsAt(x_83, x_94, x_47); -x_56 = x_95; -goto block_82; -} -block_82: +x_94 = lean_ctor_get(x_92, 0); +lean_inc(x_94); +x_95 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_94); +lean_dec(x_94); +if (lean_obj_tag(x_95) == 2) { -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_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_do___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_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); -x_59 = lean_array_get_size(x_58); -lean_dec(x_58); -x_60 = lean_ctor_get(x_56, 1); -lean_inc(x_60); -lean_inc(x_1); -x_61 = l_Lean_Parser_Term_bracketedDoSeq___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_dec(x_60); -lean_dec(x_59); -lean_dec(x_1); -x_63 = l_Lean_Parser_Term_do___elambda__1___closed__2; -x_64 = l_Lean_Parser_ParserState_mkNode(x_61, x_63, x_55); -x_65 = l_Lean_Parser_mergeOrElseErrors(x_64, x_50, x_47); -lean_dec(x_47); -return x_65; +lean_object* x_99; lean_object* x_100; +x_99 = l_Lean_Parser_Term_do___elambda__1___closed__9; +x_100 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_99, x_91); +x_64 = x_100; +goto block_90; } else { -lean_object* x_66; lean_object* x_67; uint8_t x_68; -x_66 = lean_ctor_get(x_62, 0); +lean_dec(x_91); +x_64 = x_92; +goto block_90; +} +} +else +{ +lean_object* x_101; lean_object* x_102; +lean_dec(x_95); +x_101 = l_Lean_Parser_Term_do___elambda__1___closed__9; +x_102 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_101, x_91); +x_64 = x_102; +goto block_90; +} +} +else +{ +lean_object* x_103; lean_object* x_104; +lean_dec(x_93); +x_103 = l_Lean_Parser_Term_do___elambda__1___closed__9; +x_104 = l_Lean_Parser_ParserState_mkErrorsAt(x_92, x_103, x_91); +x_64 = x_104; +goto block_90; +} +block_90: +{ +lean_object* x_65; +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; +x_66 = lean_ctor_get(x_64, 0); lean_inc(x_66); -lean_dec(x_62); -x_67 = lean_ctor_get(x_61, 1); -lean_inc(x_67); -x_68 = lean_nat_dec_eq(x_67, x_60); -lean_dec(x_67); -if (x_68 == 0) -{ -lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_67 = lean_array_get_size(x_66); lean_dec(x_66); -lean_dec(x_60); -lean_dec(x_59); +x_68 = lean_ctor_get(x_64, 1); +lean_inc(x_68); +lean_inc(x_1); +x_69 = l_Lean_Parser_Term_bracketedDoSeq___elambda__1(x_1, x_64); +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_dec(x_68); +lean_dec(x_67); lean_dec(x_1); -x_69 = l_Lean_Parser_Term_do___elambda__1___closed__2; -x_70 = l_Lean_Parser_ParserState_mkNode(x_61, x_69, x_55); -x_71 = l_Lean_Parser_mergeOrElseErrors(x_70, x_50, x_47); -lean_dec(x_47); -return x_71; +x_71 = l_Lean_Parser_Term_do___elambda__1___closed__2; +x_72 = l_Lean_Parser_ParserState_mkNode(x_69, x_71, x_63); +x_73 = l_Lean_Parser_mergeOrElseErrors(x_72, x_54, x_51); +lean_dec(x_51); +return x_73; } else { -lean_object* x_72; uint8_t x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; -lean_inc(x_60); -x_72 = l_Lean_Parser_ParserState_restore(x_61, x_59, x_60); -lean_dec(x_59); -x_73 = 0; -x_74 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_73, x_73, x_1, x_72); -x_75 = l_Lean_Parser_mergeOrElseErrors(x_74, x_66, x_60); -lean_dec(x_60); -x_76 = l_Lean_Parser_Term_do___elambda__1___closed__2; -x_77 = l_Lean_Parser_ParserState_mkNode(x_75, x_76, x_55); -x_78 = l_Lean_Parser_mergeOrElseErrors(x_77, x_50, x_47); -lean_dec(x_47); -return x_78; +lean_object* x_74; lean_object* x_75; uint8_t x_76; +x_74 = lean_ctor_get(x_70, 0); +lean_inc(x_74); +lean_dec(x_70); +x_75 = lean_ctor_get(x_69, 1); +lean_inc(x_75); +x_76 = lean_nat_dec_eq(x_75, x_68); +lean_dec(x_75); +if (x_76 == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; +lean_dec(x_74); +lean_dec(x_68); +lean_dec(x_67); +lean_dec(x_1); +x_77 = l_Lean_Parser_Term_do___elambda__1___closed__2; +x_78 = l_Lean_Parser_ParserState_mkNode(x_69, x_77, x_63); +x_79 = l_Lean_Parser_mergeOrElseErrors(x_78, x_54, x_51); +lean_dec(x_51); +return x_79; +} +else +{ +lean_object* x_80; uint8_t 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_68); +x_80 = l_Lean_Parser_ParserState_restore(x_69, x_67, x_68); +lean_dec(x_67); +x_81 = 0; +x_82 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_doSeq___elambda__1___spec__1(x_81, x_81, x_1, x_80); +x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_74, x_68); +lean_dec(x_68); +x_84 = l_Lean_Parser_Term_do___elambda__1___closed__2; +x_85 = l_Lean_Parser_ParserState_mkNode(x_83, x_84, x_63); +x_86 = l_Lean_Parser_mergeOrElseErrors(x_85, x_54, x_51); +lean_dec(x_51); +return x_86; } } } else { -lean_object* x_79; lean_object* x_80; lean_object* x_81; -lean_dec(x_57); +lean_object* x_87; lean_object* x_88; lean_object* x_89; +lean_dec(x_65); lean_dec(x_1); -x_79 = l_Lean_Parser_Term_do___elambda__1___closed__2; -x_80 = l_Lean_Parser_ParserState_mkNode(x_56, x_79, x_55); -x_81 = l_Lean_Parser_mergeOrElseErrors(x_80, x_50, x_47); -lean_dec(x_47); -return x_81; +x_87 = l_Lean_Parser_Term_do___elambda__1___closed__2; +x_88 = l_Lean_Parser_ParserState_mkNode(x_64, x_87, x_63); +x_89 = l_Lean_Parser_mergeOrElseErrors(x_88, x_54, x_51); +lean_dec(x_51); +return x_89; } } } +else +{ +lean_object* x_105; +lean_dec(x_61); +lean_dec(x_1); +x_105 = l_Lean_Parser_mergeOrElseErrors(x_60, x_54, x_51); +lean_dec(x_51); +return x_105; +} +} } } } @@ -39648,11 +41045,10 @@ return x_81; lean_object* _init_l_Lean_Parser_Term_do___closed__1() { _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_do___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_do___closed__2() { @@ -39692,16 +41088,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_do___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_do___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_do___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_do___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_do___closed__4; +x_3 = l_Lean_Parser_Term_do___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_do___closed__6() { +lean_object* _init_l_Lean_Parser_Term_do___closed__7() { _start: { lean_object* x_1; @@ -39709,12 +41115,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_do___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_do___closed__7() { +lean_object* _init_l_Lean_Parser_Term_do___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_do___closed__5; -x_2 = l_Lean_Parser_Term_do___closed__6; +x_1 = l_Lean_Parser_Term_do___closed__6; +x_2 = l_Lean_Parser_Term_do___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); @@ -39725,7 +41131,7 @@ lean_object* _init_l_Lean_Parser_Term_do() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_do___closed__7; +x_1 = l_Lean_Parser_Term_do___closed__8; return x_1; } } @@ -40070,11 +41476,10 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_nativeRefl___closed__1() { _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_nativeRefl___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_nativeRefl___closed__2() { @@ -40480,11 +41885,10 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_nativeDecide___closed__1() { _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_nativeDecide___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_nativeDecide___closed__2() { @@ -40890,11 +42294,10 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_decide___closed__1() { _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_decide___elambda__1___closed__6; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_decide___closed__2() { @@ -41071,227 +42474,260 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_18 = lean_ctor_get(x_2, 1); -lean_inc(x_18); -lean_inc(x_1); -x_19 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_21 = lean_ctor_get(x_19, 0); -lean_inc(x_21); -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); -lean_dec(x_22); -x_24 = l_Lean_Parser_Term_not___elambda__1___closed__6; -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; -x_26 = l_Lean_Parser_Term_not___elambda__1___closed__9; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); -x_8 = x_27; -goto block_17; -} -else -{ -lean_dec(x_18); -x_8 = x_19; -goto block_17; -} -} -else -{ -lean_object* x_28; lean_object* x_29; -lean_dec(x_22); -x_28 = l_Lean_Parser_Term_not___elambda__1___closed__9; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_28, x_18); -x_8 = x_29; -goto block_17; -} -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_dec(x_20); -x_30 = l_Lean_Parser_Term_not___elambda__1___closed__9; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); -x_8 = x_31; -goto block_17; -} -block_17: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(40u); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); -x_13 = l_Lean_Parser_Term_not___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7); -return x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_22; lean_object* x_23; lean_object* x_24; +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_22 = lean_ctor_get(x_8, 1); +lean_inc(x_22); +lean_inc(x_1); +x_23 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_25 = lean_ctor_get(x_23, 0); +lean_inc(x_25); +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); +lean_dec(x_26); +x_28 = l_Lean_Parser_Term_not___elambda__1___closed__6; +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; +x_30 = l_Lean_Parser_Term_not___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); +x_12 = x_31; +goto block_21; +} +else +{ +lean_dec(x_22); +x_12 = x_23; +goto block_21; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_26); +x_32 = l_Lean_Parser_Term_not___elambda__1___closed__9; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22); +x_12 = x_33; +goto block_21; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_24); +x_34 = l_Lean_Parser_Term_not___elambda__1___closed__9; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22); +x_12 = x_35; +goto block_21; +} +block_21: +{ +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_18; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(40u); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = l_Lean_Parser_Term_not___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_11); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_not___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_12, x_19, x_11); +return x_20; +} +} } else { -lean_object* x_15; lean_object* x_16; lean_dec(x_9); lean_dec(x_1); -x_15 = l_Lean_Parser_Term_not___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_8, x_15, x_7); -return x_16; -} +return x_8; } } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_32 = lean_ctor_get(x_2, 0); -lean_inc(x_32); -x_33 = lean_array_get_size(x_32); -lean_dec(x_32); -x_34 = lean_ctor_get(x_2, 1); -lean_inc(x_34); -lean_inc(x_1); -x_35 = lean_apply_2(x_4, x_1, x_2); -x_36 = lean_ctor_get(x_35, 3); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_2, 0); lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) -{ -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_1); -return x_35; -} -else -{ -lean_object* x_37; lean_object* x_38; uint8_t x_39; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); +x_37 = lean_array_get_size(x_36); lean_dec(x_36); -x_38 = lean_ctor_get(x_35, 1); +x_38 = lean_ctor_get(x_2, 1); lean_inc(x_38); -x_39 = lean_nat_dec_eq(x_38, x_34); -lean_dec(x_38); -if (x_39 == 0) +lean_inc(x_1); +x_39 = lean_apply_2(x_4, x_1, x_2); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { +lean_dec(x_38); lean_dec(x_37); -lean_dec(x_34); -lean_dec(x_33); lean_dec(x_1); -return x_35; +return x_39; } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_55; lean_object* x_56; -lean_inc(x_34); -x_40 = l_Lean_Parser_ParserState_restore(x_35, x_33, x_34); -lean_dec(x_33); +lean_object* x_41; lean_object* x_42; uint8_t x_43; x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -x_42 = lean_array_get_size(x_41); +lean_dec(x_40); +x_42 = lean_ctor_get(x_39, 1); +lean_inc(x_42); +x_43 = lean_nat_dec_eq(x_42, x_38); +lean_dec(x_42); +if (x_43 == 0) +{ lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_37); +lean_dec(x_1); +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_inc(x_38); +x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); +lean_dec(x_37); +x_45 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_46 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_47 = l_Lean_Parser_checkRbpLtFn(x_45, x_46, x_1, x_44); +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_63; lean_object* x_64; lean_object* x_65; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +x_63 = lean_ctor_get(x_47, 1); +lean_inc(x_63); lean_inc(x_1); -x_55 = l_Lean_Parser_tokenFn(x_1, x_40); -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_not___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_not___elambda__1___closed__9; -lean_inc(x_34); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_34); -x_43 = x_63; -goto block_54; -} -else -{ -x_43 = x_55; -goto block_54; -} -} -else -{ -lean_object* x_64; lean_object* x_65; -lean_dec(x_58); -x_64 = l_Lean_Parser_Term_not___elambda__1___closed__9; -lean_inc(x_34); -x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_34); -x_43 = x_65; -goto block_54; -} -} -else +x_64 = l_Lean_Parser_tokenFn(x_1, x_47); +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_dec(x_56); -x_66 = l_Lean_Parser_Term_not___elambda__1___closed__9; -lean_inc(x_34); -x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_34); -x_43 = x_67; -goto block_54; -} -block_54: +x_66 = lean_ctor_get(x_64, 0); +lean_inc(x_66); +x_67 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_66); +lean_dec(x_66); +if (lean_obj_tag(x_67) == 2) { -lean_object* x_44; -x_44 = lean_ctor_get(x_43, 3); -lean_inc(x_44); -if (lean_obj_tag(x_44) == 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_not___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_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(40u); -x_47 = l_Lean_Parser_categoryParser___elambda__1(x_45, x_46, x_1, x_43); -x_48 = l_Lean_Parser_Term_not___elambda__1___closed__2; -x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_42); -x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_37, x_34); -lean_dec(x_34); -return x_50; +lean_object* x_71; lean_object* x_72; +x_71 = l_Lean_Parser_Term_not___elambda__1___closed__9; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_63); +x_51 = x_72; +goto block_62; } 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_Term_not___elambda__1___closed__2; -x_52 = l_Lean_Parser_ParserState_mkNode(x_43, x_51, x_42); -x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_37, x_34); -lean_dec(x_34); -return x_53; +lean_dec(x_63); +x_51 = x_64; +goto block_62; } } +else +{ +lean_object* x_73; lean_object* x_74; +lean_dec(x_67); +x_73 = l_Lean_Parser_Term_not___elambda__1___closed__9; +x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_63); +x_51 = x_74; +goto block_62; +} +} +else +{ +lean_object* x_75; lean_object* x_76; +lean_dec(x_65); +x_75 = l_Lean_Parser_Term_not___elambda__1___closed__9; +x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_63); +x_51 = x_76; +goto block_62; +} +block_62: +{ +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; lean_object* x_57; lean_object* x_58; +x_53 = l_Lean_Parser_termParser___closed__2; +x_54 = lean_unsigned_to_nat(40u); +x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_51); +x_56 = l_Lean_Parser_Term_not___elambda__1___closed__2; +x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_50); +x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_41, x_38); +lean_dec(x_38); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_dec(x_52); +lean_dec(x_1); +x_59 = l_Lean_Parser_Term_not___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_51, x_59, x_50); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_41, x_38); +lean_dec(x_38); +return x_61; +} +} +} +else +{ +lean_object* x_77; +lean_dec(x_48); +lean_dec(x_1); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_47, x_41, x_38); +lean_dec(x_38); +return x_77; +} } } } @@ -41300,11 +42736,10 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_not___closed__1() { _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_not___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_not___closed__2() { @@ -41342,16 +42777,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_not___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_not___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_not___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_not___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_not___closed__4; +x_3 = l_Lean_Parser_Term_not___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_not___closed__6() { +lean_object* _init_l_Lean_Parser_Term_not___closed__7() { _start: { lean_object* x_1; @@ -41359,12 +42804,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_not___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_not___closed__7() { +lean_object* _init_l_Lean_Parser_Term_not___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_not___closed__5; -x_2 = l_Lean_Parser_Term_not___closed__6; +x_1 = l_Lean_Parser_Term_not___closed__6; +x_2 = l_Lean_Parser_Term_not___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); @@ -41375,7 +42820,7 @@ lean_object* _init_l_Lean_Parser_Term_not() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_not___closed__7; +x_1 = l_Lean_Parser_Term_not___closed__8; return x_1; } } @@ -41491,227 +42936,260 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_18 = lean_ctor_get(x_2, 1); -lean_inc(x_18); -lean_inc(x_1); -x_19 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_21 = lean_ctor_get(x_19, 0); -lean_inc(x_21); -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); -lean_dec(x_22); -x_24 = l_Lean_Parser_Term_bnot___elambda__1___closed__6; -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; -x_26 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); -x_8 = x_27; -goto block_17; -} -else -{ -lean_dec(x_18); -x_8 = x_19; -goto block_17; -} -} -else -{ -lean_object* x_28; lean_object* x_29; -lean_dec(x_22); -x_28 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_28, x_18); -x_8 = x_29; -goto block_17; -} -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_dec(x_20); -x_30 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); -x_8 = x_31; -goto block_17; -} -block_17: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(40u); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); -x_13 = l_Lean_Parser_Term_bnot___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7); -return x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_22; lean_object* x_23; lean_object* x_24; +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_22 = lean_ctor_get(x_8, 1); +lean_inc(x_22); +lean_inc(x_1); +x_23 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_25 = lean_ctor_get(x_23, 0); +lean_inc(x_25); +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); +lean_dec(x_26); +x_28 = l_Lean_Parser_Term_bnot___elambda__1___closed__6; +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; +x_30 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); +x_12 = x_31; +goto block_21; +} +else +{ +lean_dec(x_22); +x_12 = x_23; +goto block_21; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_26); +x_32 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22); +x_12 = x_33; +goto block_21; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_24); +x_34 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22); +x_12 = x_35; +goto block_21; +} +block_21: +{ +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_18; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(40u); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = l_Lean_Parser_Term_bnot___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_11); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_bnot___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_12, x_19, x_11); +return x_20; +} +} } else { -lean_object* x_15; lean_object* x_16; lean_dec(x_9); lean_dec(x_1); -x_15 = l_Lean_Parser_Term_bnot___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_8, x_15, x_7); -return x_16; -} +return x_8; } } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_32 = lean_ctor_get(x_2, 0); -lean_inc(x_32); -x_33 = lean_array_get_size(x_32); -lean_dec(x_32); -x_34 = lean_ctor_get(x_2, 1); -lean_inc(x_34); -lean_inc(x_1); -x_35 = lean_apply_2(x_4, x_1, x_2); -x_36 = lean_ctor_get(x_35, 3); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_2, 0); lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) -{ -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_1); -return x_35; -} -else -{ -lean_object* x_37; lean_object* x_38; uint8_t x_39; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); +x_37 = lean_array_get_size(x_36); lean_dec(x_36); -x_38 = lean_ctor_get(x_35, 1); +x_38 = lean_ctor_get(x_2, 1); lean_inc(x_38); -x_39 = lean_nat_dec_eq(x_38, x_34); -lean_dec(x_38); -if (x_39 == 0) +lean_inc(x_1); +x_39 = lean_apply_2(x_4, x_1, x_2); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { +lean_dec(x_38); lean_dec(x_37); -lean_dec(x_34); -lean_dec(x_33); lean_dec(x_1); -return x_35; +return x_39; } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_55; lean_object* x_56; -lean_inc(x_34); -x_40 = l_Lean_Parser_ParserState_restore(x_35, x_33, x_34); -lean_dec(x_33); +lean_object* x_41; lean_object* x_42; uint8_t x_43; x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -x_42 = lean_array_get_size(x_41); +lean_dec(x_40); +x_42 = lean_ctor_get(x_39, 1); +lean_inc(x_42); +x_43 = lean_nat_dec_eq(x_42, x_38); +lean_dec(x_42); +if (x_43 == 0) +{ lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_37); +lean_dec(x_1); +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_inc(x_38); +x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); +lean_dec(x_37); +x_45 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_46 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_47 = l_Lean_Parser_checkRbpLtFn(x_45, x_46, x_1, x_44); +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_63; lean_object* x_64; lean_object* x_65; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +x_63 = lean_ctor_get(x_47, 1); +lean_inc(x_63); lean_inc(x_1); -x_55 = l_Lean_Parser_tokenFn(x_1, x_40); -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_bnot___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_bnot___elambda__1___closed__9; -lean_inc(x_34); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_34); -x_43 = x_63; -goto block_54; -} -else -{ -x_43 = x_55; -goto block_54; -} -} -else -{ -lean_object* x_64; lean_object* x_65; -lean_dec(x_58); -x_64 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; -lean_inc(x_34); -x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_34); -x_43 = x_65; -goto block_54; -} -} -else +x_64 = l_Lean_Parser_tokenFn(x_1, x_47); +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_dec(x_56); -x_66 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; -lean_inc(x_34); -x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_34); -x_43 = x_67; -goto block_54; -} -block_54: +x_66 = lean_ctor_get(x_64, 0); +lean_inc(x_66); +x_67 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_66); +lean_dec(x_66); +if (lean_obj_tag(x_67) == 2) { -lean_object* x_44; -x_44 = lean_ctor_get(x_43, 3); -lean_inc(x_44); -if (lean_obj_tag(x_44) == 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_bnot___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_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(40u); -x_47 = l_Lean_Parser_categoryParser___elambda__1(x_45, x_46, x_1, x_43); -x_48 = l_Lean_Parser_Term_bnot___elambda__1___closed__2; -x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_42); -x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_37, x_34); -lean_dec(x_34); -return x_50; +lean_object* x_71; lean_object* x_72; +x_71 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_63); +x_51 = x_72; +goto block_62; } 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_Term_bnot___elambda__1___closed__2; -x_52 = l_Lean_Parser_ParserState_mkNode(x_43, x_51, x_42); -x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_37, x_34); -lean_dec(x_34); -return x_53; +lean_dec(x_63); +x_51 = x_64; +goto block_62; } } +else +{ +lean_object* x_73; lean_object* x_74; +lean_dec(x_67); +x_73 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; +x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_63); +x_51 = x_74; +goto block_62; +} +} +else +{ +lean_object* x_75; lean_object* x_76; +lean_dec(x_65); +x_75 = l_Lean_Parser_Term_bnot___elambda__1___closed__9; +x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_63); +x_51 = x_76; +goto block_62; +} +block_62: +{ +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; lean_object* x_57; lean_object* x_58; +x_53 = l_Lean_Parser_termParser___closed__2; +x_54 = lean_unsigned_to_nat(40u); +x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_51); +x_56 = l_Lean_Parser_Term_bnot___elambda__1___closed__2; +x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_50); +x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_41, x_38); +lean_dec(x_38); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_dec(x_52); +lean_dec(x_1); +x_59 = l_Lean_Parser_Term_bnot___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_51, x_59, x_50); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_41, x_38); +lean_dec(x_38); +return x_61; +} +} +} +else +{ +lean_object* x_77; +lean_dec(x_48); +lean_dec(x_1); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_47, x_41, x_38); +lean_dec(x_38); +return x_77; +} } } } @@ -41720,11 +43198,10 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_bnot___closed__1() { _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_bnot___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_bnot___closed__2() { @@ -41752,16 +43229,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_bnot___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_bnot___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_bnot___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_bnot___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_bnot___closed__3; +x_3 = l_Lean_Parser_Term_bnot___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_bnot___closed__5() { +lean_object* _init_l_Lean_Parser_Term_bnot___closed__6() { _start: { lean_object* x_1; @@ -41769,12 +43256,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_bnot___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_bnot___closed__6() { +lean_object* _init_l_Lean_Parser_Term_bnot___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_bnot___closed__4; -x_2 = l_Lean_Parser_Term_bnot___closed__5; +x_1 = l_Lean_Parser_Term_bnot___closed__5; +x_2 = l_Lean_Parser_Term_bnot___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); @@ -41785,7 +43272,7 @@ lean_object* _init_l_Lean_Parser_Term_bnot() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_bnot___closed__6; +x_1 = l_Lean_Parser_Term_bnot___closed__7; return x_1; } } @@ -41893,227 +43380,260 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_18 = lean_ctor_get(x_2, 1); -lean_inc(x_18); -lean_inc(x_1); -x_19 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -x_21 = lean_ctor_get(x_19, 0); -lean_inc(x_21); -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); -lean_dec(x_22); -x_24 = l_Lean_Parser_Term_uminus___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_26; lean_object* x_27; -x_26 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); -x_8 = x_27; -goto block_17; -} -else -{ -lean_dec(x_18); -x_8 = x_19; -goto block_17; -} -} -else -{ -lean_object* x_28; lean_object* x_29; -lean_dec(x_22); -x_28 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_28, x_18); -x_8 = x_29; -goto block_17; -} -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_dec(x_20); -x_30 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); -x_8 = x_31; -goto block_17; -} -block_17: -{ -lean_object* x_9; +x_6 = lean_unsigned_to_nat(66u); +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_10 = l_Lean_Parser_termParser___closed__2; -x_11 = lean_unsigned_to_nat(100u); -x_12 = l_Lean_Parser_categoryParser___elambda__1(x_10, x_11, x_1, x_8); -x_13 = l_Lean_Parser_Term_uminus___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_7); -return x_14; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_22; lean_object* x_23; lean_object* x_24; +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_22 = lean_ctor_get(x_8, 1); +lean_inc(x_22); +lean_inc(x_1); +x_23 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_25 = lean_ctor_get(x_23, 0); +lean_inc(x_25); +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); +lean_dec(x_26); +x_28 = l_Lean_Parser_Term_uminus___elambda__1___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; +x_30 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_30, x_22); +x_12 = x_31; +goto block_21; +} +else +{ +lean_dec(x_22); +x_12 = x_23; +goto block_21; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_26); +x_32 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_32, x_22); +x_12 = x_33; +goto block_21; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_24); +x_34 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_23, x_34, x_22); +x_12 = x_35; +goto block_21; +} +block_21: +{ +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_18; +x_14 = l_Lean_Parser_termParser___closed__2; +x_15 = lean_unsigned_to_nat(100u); +x_16 = l_Lean_Parser_categoryParser___elambda__1(x_14, x_15, x_1, x_12); +x_17 = l_Lean_Parser_Term_uminus___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_16, x_17, x_11); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_uminus___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkNode(x_12, x_19, x_11); +return x_20; +} +} } else { -lean_object* x_15; lean_object* x_16; lean_dec(x_9); lean_dec(x_1); -x_15 = l_Lean_Parser_Term_uminus___elambda__1___closed__2; -x_16 = l_Lean_Parser_ParserState_mkNode(x_8, x_15, x_7); -return x_16; -} +return x_8; } } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_32 = lean_ctor_get(x_2, 0); -lean_inc(x_32); -x_33 = lean_array_get_size(x_32); -lean_dec(x_32); -x_34 = lean_ctor_get(x_2, 1); -lean_inc(x_34); -lean_inc(x_1); -x_35 = lean_apply_2(x_4, x_1, x_2); -x_36 = lean_ctor_get(x_35, 3); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_2, 0); lean_inc(x_36); -if (lean_obj_tag(x_36) == 0) -{ -lean_dec(x_34); -lean_dec(x_33); -lean_dec(x_1); -return x_35; -} -else -{ -lean_object* x_37; lean_object* x_38; uint8_t x_39; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); +x_37 = lean_array_get_size(x_36); lean_dec(x_36); -x_38 = lean_ctor_get(x_35, 1); +x_38 = lean_ctor_get(x_2, 1); lean_inc(x_38); -x_39 = lean_nat_dec_eq(x_38, x_34); -lean_dec(x_38); -if (x_39 == 0) +lean_inc(x_1); +x_39 = lean_apply_2(x_4, x_1, x_2); +x_40 = lean_ctor_get(x_39, 3); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) { +lean_dec(x_38); lean_dec(x_37); -lean_dec(x_34); -lean_dec(x_33); lean_dec(x_1); -return x_35; +return x_39; } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_55; lean_object* x_56; -lean_inc(x_34); -x_40 = l_Lean_Parser_ParserState_restore(x_35, x_33, x_34); -lean_dec(x_33); +lean_object* x_41; lean_object* x_42; uint8_t x_43; x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -x_42 = lean_array_get_size(x_41); +lean_dec(x_40); +x_42 = lean_ctor_get(x_39, 1); +lean_inc(x_42); +x_43 = lean_nat_dec_eq(x_42, x_38); +lean_dec(x_42); +if (x_43 == 0) +{ lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_37); +lean_dec(x_1); +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_inc(x_38); +x_44 = l_Lean_Parser_ParserState_restore(x_39, x_37, x_38); +lean_dec(x_37); +x_45 = lean_unsigned_to_nat(66u); +x_46 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_47 = l_Lean_Parser_checkRbpLtFn(x_45, x_46, x_1, x_44); +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_63; lean_object* x_64; lean_object* x_65; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +x_50 = lean_array_get_size(x_49); +lean_dec(x_49); +x_63 = lean_ctor_get(x_47, 1); +lean_inc(x_63); lean_inc(x_1); -x_55 = l_Lean_Parser_tokenFn(x_1, x_40); -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_uminus___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_uminus___elambda__1___closed__8; -lean_inc(x_34); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_62, x_34); -x_43 = x_63; -goto block_54; -} -else -{ -x_43 = x_55; -goto block_54; -} -} -else -{ -lean_object* x_64; lean_object* x_65; -lean_dec(x_58); -x_64 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; -lean_inc(x_34); -x_65 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_64, x_34); -x_43 = x_65; -goto block_54; -} -} -else +x_64 = l_Lean_Parser_tokenFn(x_1, x_47); +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_dec(x_56); -x_66 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; -lean_inc(x_34); -x_67 = l_Lean_Parser_ParserState_mkErrorsAt(x_55, x_66, x_34); -x_43 = x_67; -goto block_54; -} -block_54: +x_66 = lean_ctor_get(x_64, 0); +lean_inc(x_66); +x_67 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_66); +lean_dec(x_66); +if (lean_obj_tag(x_67) == 2) { -lean_object* x_44; -x_44 = lean_ctor_get(x_43, 3); -lean_inc(x_44); -if (lean_obj_tag(x_44) == 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_uminus___elambda__1___closed__5; +x_70 = lean_string_dec_eq(x_68, x_69); +lean_dec(x_68); +if (x_70 == 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(100u); -x_47 = l_Lean_Parser_categoryParser___elambda__1(x_45, x_46, x_1, x_43); -x_48 = l_Lean_Parser_Term_uminus___elambda__1___closed__2; -x_49 = l_Lean_Parser_ParserState_mkNode(x_47, x_48, x_42); -x_50 = l_Lean_Parser_mergeOrElseErrors(x_49, x_37, x_34); -lean_dec(x_34); -return x_50; +lean_object* x_71; lean_object* x_72; +x_71 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_71, x_63); +x_51 = x_72; +goto block_62; } 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_Term_uminus___elambda__1___closed__2; -x_52 = l_Lean_Parser_ParserState_mkNode(x_43, x_51, x_42); -x_53 = l_Lean_Parser_mergeOrElseErrors(x_52, x_37, x_34); -lean_dec(x_34); -return x_53; +lean_dec(x_63); +x_51 = x_64; +goto block_62; } } +else +{ +lean_object* x_73; lean_object* x_74; +lean_dec(x_67); +x_73 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; +x_74 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_73, x_63); +x_51 = x_74; +goto block_62; +} +} +else +{ +lean_object* x_75; lean_object* x_76; +lean_dec(x_65); +x_75 = l_Lean_Parser_Term_uminus___elambda__1___closed__8; +x_76 = l_Lean_Parser_ParserState_mkErrorsAt(x_64, x_75, x_63); +x_51 = x_76; +goto block_62; +} +block_62: +{ +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; lean_object* x_57; lean_object* x_58; +x_53 = l_Lean_Parser_termParser___closed__2; +x_54 = lean_unsigned_to_nat(100u); +x_55 = l_Lean_Parser_categoryParser___elambda__1(x_53, x_54, x_1, x_51); +x_56 = l_Lean_Parser_Term_uminus___elambda__1___closed__2; +x_57 = l_Lean_Parser_ParserState_mkNode(x_55, x_56, x_50); +x_58 = l_Lean_Parser_mergeOrElseErrors(x_57, x_41, x_38); +lean_dec(x_38); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_dec(x_52); +lean_dec(x_1); +x_59 = l_Lean_Parser_Term_uminus___elambda__1___closed__2; +x_60 = l_Lean_Parser_ParserState_mkNode(x_51, x_59, x_50); +x_61 = l_Lean_Parser_mergeOrElseErrors(x_60, x_41, x_38); +lean_dec(x_38); +return x_61; +} +} +} +else +{ +lean_object* x_77; +lean_dec(x_48); +lean_dec(x_1); +x_77 = l_Lean_Parser_mergeOrElseErrors(x_47, x_41, x_38); +lean_dec(x_38); +return x_77; +} } } } @@ -42122,11 +43642,10 @@ return x_53; lean_object* _init_l_Lean_Parser_Term_uminus___closed__1() { _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_uminus___elambda__1___closed__5; -x_2 = l_Lean_Parser_Level_addLit___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_uminus___closed__2() { @@ -42164,16 +43683,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_uminus___closed__5() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_uminus___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_uminus___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_uminus___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_uminus___closed__4; +x_3 = l_Lean_Parser_Term_uminus___closed__5; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_uminus___closed__6() { +lean_object* _init_l_Lean_Parser_Term_uminus___closed__7() { _start: { lean_object* x_1; @@ -42181,12 +43710,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_uminus___elambda__1), 2, 0); return x_1; } } -lean_object* _init_l_Lean_Parser_Term_uminus___closed__7() { +lean_object* _init_l_Lean_Parser_Term_uminus___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_uminus___closed__5; -x_2 = l_Lean_Parser_Term_uminus___closed__6; +x_1 = l_Lean_Parser_Term_uminus___closed__6; +x_2 = l_Lean_Parser_Term_uminus___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); @@ -42197,7 +43726,7 @@ lean_object* _init_l_Lean_Parser_Term_uminus() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_uminus___closed__7; +x_1 = l_Lean_Parser_Term_uminus___closed__8; return x_1; } } @@ -43014,7 +44543,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_Lean_Parser_antiquotNestedExpr___closed__2; +x_1 = l_Lean_Parser_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; @@ -43025,7 +44554,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Term_namedArgument___closed__2; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__5; +x_2 = l_Lean_Parser_antiquotNestedExpr___closed__4; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } @@ -43186,95 +44715,109 @@ return x_15; lean_object* l_Lean_Parser_Term_app___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_6 = l_Lean_Parser_Term_namedArgument___elambda__1(x_1, x_2); -x_7 = lean_ctor_get(x_6, 3); +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = l_Lean_Parser_appPrec; +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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) +{ +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_5, 0); 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); -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_13; lean_object* x_14; uint8_t x_15; -x_13 = lean_ctor_get(x_7, 0); -lean_inc(x_13); +x_8 = lean_array_get_size(x_7); 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) -{ -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; +x_9 = lean_ctor_get(x_5, 1); +lean_inc(x_9); 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) +x_10 = l_Lean_Parser_Term_namedArgument___elambda__1(x_1, x_5); +x_11 = lean_ctor_get(x_10, 3); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 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; +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +lean_dec(x_9); +x_12 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(x_1, x_10); +x_13 = l_Lean_nullKind; +lean_inc(x_8); +x_14 = l_Lean_Parser_ParserState_mkNode(x_12, x_13, x_8); +x_15 = l_Lean_mkAppStx___closed__8; +x_16 = l_Lean_Parser_ParserState_mkTrailingNode(x_14, x_15, x_8); +lean_dec(x_8); +return x_16; } else { -lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_25); +lean_object* x_17; lean_object* x_18; uint8_t x_19; +x_17 = lean_ctor_get(x_11, 0); +lean_inc(x_17); +lean_dec(x_11); +x_18 = lean_ctor_get(x_10, 1); +lean_inc(x_18); +x_19 = lean_nat_dec_eq(x_18, x_9); +lean_dec(x_18); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_dec(x_17); +lean_dec(x_9); lean_dec(x_1); -x_31 = l_Lean_nullKind; -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_4); -lean_dec(x_4); -return x_34; +x_20 = l_Lean_nullKind; +lean_inc(x_8); +x_21 = l_Lean_Parser_ParserState_mkNode(x_10, x_20, x_8); +x_22 = l_Lean_mkAppStx___closed__8; +x_23 = l_Lean_Parser_ParserState_mkTrailingNode(x_21, x_22, x_8); +lean_dec(x_8); +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_9); +x_24 = l_Lean_Parser_ParserState_restore(x_10, x_8, x_9); +x_25 = l_Lean_Parser_termParser___closed__2; +lean_inc(x_1); +x_26 = l_Lean_Parser_categoryParser___elambda__1(x_25, x_3, x_1, x_24); +x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_17, x_9); +lean_dec(x_9); +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; +x_29 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_app___elambda__1___spec__1(x_1, x_27); +x_30 = l_Lean_nullKind; +lean_inc(x_8); +x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_8); +x_32 = l_Lean_mkAppStx___closed__8; +x_33 = l_Lean_Parser_ParserState_mkTrailingNode(x_31, x_32, 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_dec(x_28); +lean_dec(x_1); +x_34 = l_Lean_nullKind; +lean_inc(x_8); +x_35 = l_Lean_Parser_ParserState_mkNode(x_27, x_34, x_8); +x_36 = l_Lean_mkAppStx___closed__8; +x_37 = l_Lean_Parser_ParserState_mkTrailingNode(x_35, x_36, x_8); +lean_dec(x_8); +return x_37; } } } } +else +{ +lean_dec(x_6); +lean_dec(x_1); +return x_5; +} +} } lean_object* _init_l_Lean_Parser_Term_app___closed__1() { _start: @@ -43303,17 +44846,27 @@ 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* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_app___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } 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), 2, 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__2; -x_2 = l_Lean_Parser_Term_app___closed__3; +x_1 = l_Lean_Parser_Term_app___closed__3; +x_2 = l_Lean_Parser_Term_app___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); @@ -43324,7 +44877,7 @@ lean_object* _init_l_Lean_Parser_Term_app() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_app___closed__4; +x_1 = l_Lean_Parser_Term_app___closed__5; return x_1; } } @@ -43460,249 +45013,244 @@ return x_2; lean_object* l_Lean_Parser_Term_proj___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_41; uint8_t x_42; +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_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 = lean_ctor_get(x_2, 1); -lean_inc(x_6); -x_7 = lean_array_get_size(x_5); -x_41 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_5); -lean_dec(x_5); -x_42 = l_Lean_Parser_checkTailNoWs(x_41); -lean_dec(x_41); -if (x_42 == 0) -{ -lean_object* x_43; lean_object* x_44; -lean_dec(x_6); -x_43 = l_Lean_Parser_Term_proj___elambda__1___closed__3; -x_44 = l_Lean_Parser_ParserState_mkError(x_2, x_43); -x_8 = x_44; -goto block_40; -} -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; -x_45 = lean_ctor_get(x_1, 0); -lean_inc(x_45); -x_46 = lean_ctor_get(x_45, 0); -lean_inc(x_46); -lean_dec(x_45); -x_47 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_structInstLVal___elambda__1___spec__1___closed__1; -x_48 = l_Lean_Parser_Term_proj___elambda__1___closed__3; -x_49 = lean_unsigned_to_nat(0u); -x_50 = l_Lean_Parser_strAux___main(x_47, x_48, x_49, x_1, x_2); -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; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; -lean_inc_n(x_6, 2); -lean_inc(x_46); -x_52 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_52, 0, x_46); -lean_ctor_set(x_52, 1, x_6); -lean_ctor_set(x_52, 2, x_6); -x_53 = l_Lean_Parser_Term_proj___elambda__1___closed__4; -x_54 = lean_nat_add(x_6, x_53); -lean_inc(x_54); -x_55 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_55, 0, x_46); -lean_ctor_set(x_55, 1, x_54); -lean_ctor_set(x_55, 2, x_54); -x_56 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_56, 0, x_52); -x_57 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_57, 0, x_6); -x_58 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_58, 0, x_55); -x_59 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_59, 0, x_56); -lean_ctor_set(x_59, 1, x_57); -lean_ctor_set(x_59, 2, x_58); -x_60 = lean_alloc_ctor(2, 2, 0); -lean_ctor_set(x_60, 0, x_59); -lean_ctor_set(x_60, 1, x_47); -x_61 = l_Lean_Parser_ParserState_pushSyntax(x_50, x_60); -x_8 = x_61; -goto block_40; -} -else -{ -lean_dec(x_51); -lean_dec(x_46); -lean_dec(x_6); -x_8 = x_50; -goto block_40; -} -} -block_40: -{ -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; uint8_t x_28; -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_5 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_6 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_7 = l_Lean_Parser_checkRbpLtFn(x_5, x_6, x_1, x_2); +x_8 = lean_ctor_get(x_7, 3); lean_inc(x_8); -lean_inc(x_1); -x_28 = l_Lean_Parser_tryAnti(x_1, x_8); -if (x_28 == 0) +if (lean_obj_tag(x_8) == 0) { -lean_object* x_29; -lean_dec(x_4); -x_29 = l_Lean_Parser_fieldIdxFn(x_1, x_8); -x_13 = x_29; -goto block_27; -} -else -{ -lean_object* x_30; lean_object* x_31; -lean_inc(x_1); -x_30 = lean_apply_2(x_4, x_1, x_8); -x_31 = lean_ctor_get(x_30, 3); -lean_inc(x_31); -if (lean_obj_tag(x_31) == 0) -{ -x_13 = x_30; -goto block_27; -} -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_12); -lean_dec(x_33); -if (x_34 == 0) -{ -lean_dec(x_32); -x_13 = x_30; -goto block_27; -} -else -{ -lean_object* x_35; lean_object* x_36; lean_object* x_37; -lean_inc(x_12); -x_35 = l_Lean_Parser_ParserState_restore(x_30, x_11, x_12); -x_36 = l_Lean_Parser_fieldIdxFn(x_1, x_35); -x_37 = l_Lean_Parser_mergeOrElseErrors(x_36, x_32, x_12); -x_13 = x_37; -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_38; lean_object* x_39; +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_45; uint8_t x_46; +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +x_11 = lean_array_get_size(x_9); +x_45 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_9); lean_dec(x_9); +x_46 = l_Lean_Parser_checkTailNoWs(x_45); +lean_dec(x_45); +if (x_46 == 0) +{ +lean_object* x_47; lean_object* x_48; +lean_dec(x_10); +x_47 = l_Lean_Parser_Term_proj___elambda__1___closed__3; +x_48 = l_Lean_Parser_ParserState_mkError(x_7, x_47); +x_12 = x_48; +goto block_44; +} +else +{ +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; +x_49 = lean_ctor_get(x_1, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +lean_dec(x_49); +x_51 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_structInstLVal___elambda__1___spec__1___closed__1; +x_52 = l_Lean_Parser_Term_proj___elambda__1___closed__3; +x_53 = lean_unsigned_to_nat(0u); +x_54 = l_Lean_Parser_strAux___main(x_51, x_52, x_53, x_1, x_7); +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_63; lean_object* x_64; lean_object* x_65; +lean_inc_n(x_10, 2); +lean_inc(x_50); +x_56 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_56, 0, x_50); +lean_ctor_set(x_56, 1, x_10); +lean_ctor_set(x_56, 2, x_10); +x_57 = l_Lean_Parser_Term_proj___elambda__1___closed__4; +x_58 = lean_nat_add(x_10, x_57); +lean_inc(x_58); +x_59 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_59, 0, x_50); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_59, 2, x_58); +x_60 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_60, 0, x_56); +x_61 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_61, 0, x_10); +x_62 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_62, 0, x_59); +x_63 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_63, 0, x_60); +lean_ctor_set(x_63, 1, x_61); +lean_ctor_set(x_63, 2, x_62); +x_64 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_51); +x_65 = l_Lean_Parser_ParserState_pushSyntax(x_54, x_64); +x_12 = x_65; +goto block_44; +} +else +{ +lean_dec(x_55); +lean_dec(x_50); +lean_dec(x_10); +x_12 = x_54; +goto block_44; +} +} +block_44: +{ +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; uint8_t x_32; +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_12); +lean_inc(x_1); +x_32 = l_Lean_Parser_tryAnti(x_1, x_12); +if (x_32 == 0) +{ +lean_object* x_33; +lean_dec(x_4); +x_33 = l_Lean_Parser_fieldIdxFn(x_1, x_12); +x_17 = x_33; +goto block_31; +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_inc(x_1); +x_34 = lean_apply_2(x_4, x_1, x_12); +x_35 = lean_ctor_get(x_34, 3); +lean_inc(x_35); +if (lean_obj_tag(x_35) == 0) +{ +x_17 = x_34; +goto block_31; +} +else +{ +lean_object* x_36; lean_object* x_37; uint8_t x_38; +x_36 = lean_ctor_get(x_35, 0); +lean_inc(x_36); +lean_dec(x_35); +x_37 = lean_ctor_get(x_34, 1); +lean_inc(x_37); +x_38 = lean_nat_dec_eq(x_37, x_16); +lean_dec(x_37); +if (x_38 == 0) +{ +lean_dec(x_36); +x_17 = x_34; +goto block_31; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_inc(x_16); +x_39 = l_Lean_Parser_ParserState_restore(x_34, x_15, x_16); +x_40 = l_Lean_Parser_fieldIdxFn(x_1, x_39); +x_41 = l_Lean_Parser_mergeOrElseErrors(x_40, x_36, x_16); +x_17 = x_41; +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_dec(x_16); +lean_dec(x_15); +lean_dec(x_1); +x_19 = l_Lean_Parser_Term_proj___elambda__1___closed__2; +x_20 = l_Lean_Parser_ParserState_mkTrailingNode(x_17, x_19, x_11); +lean_dec(x_11); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; uint8_t x_23; +x_21 = lean_ctor_get(x_18, 0); +lean_inc(x_21); +lean_dec(x_18); +x_22 = lean_ctor_get(x_17, 1); +lean_inc(x_22); +x_23 = lean_nat_dec_eq(x_22, x_16); +lean_dec(x_22); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; +lean_dec(x_21); +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_1); +x_24 = l_Lean_Parser_Term_proj___elambda__1___closed__2; +x_25 = l_Lean_Parser_ParserState_mkTrailingNode(x_17, x_24, x_11); +lean_dec(x_11); +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_inc(x_16); +x_26 = l_Lean_Parser_ParserState_restore(x_17, x_15, x_16); +lean_dec(x_15); +x_27 = l_Lean_Parser_ident___elambda__1(x_1, x_26); +x_28 = l_Lean_Parser_mergeOrElseErrors(x_27, x_21, x_16); +lean_dec(x_16); +x_29 = l_Lean_Parser_Term_proj___elambda__1___closed__2; +x_30 = l_Lean_Parser_ParserState_mkTrailingNode(x_28, x_29, x_11); +lean_dec(x_11); +return x_30; +} +} +} +} +else +{ +lean_object* x_42; lean_object* x_43; +lean_dec(x_13); lean_dec(x_4); lean_dec(x_1); -x_38 = l_Lean_Parser_Term_proj___elambda__1___closed__2; -x_39 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_38, x_7); -lean_dec(x_7); -return x_39; +x_42 = l_Lean_Parser_Term_proj___elambda__1___closed__2; +x_43 = l_Lean_Parser_ParserState_mkTrailingNode(x_12, x_42, x_11); +lean_dec(x_11); +return x_43; } } } +else +{ +lean_dec(x_8); +lean_dec(x_4); +lean_dec(x_1); +return x_7; +} +} } lean_object* _init_l_Lean_Parser_Term_proj___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_appPrec; -x_2 = lean_unsigned_to_nat(1u); -x_3 = lean_nat_add(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_Term_proj___closed__2() { -_start: -{ lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_Term_proj___closed__1; -x_2 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_2, 0, x_1); +x_1 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_structInstLVal___elambda__1___spec__1___closed__1; +x_2 = l_Lean_Parser_symbolNoWsInfo(x_1); return x_2; } } -lean_object* _init_l_Lean_Parser_Term_proj___closed__3() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_manyAux___main___at_Lean_Parser_Term_structInstLVal___elambda__1___spec__1___closed__1; -x_2 = l_Lean_Parser_Term_proj___closed__2; -x_3 = l_Lean_Parser_symbolNoWsInfo(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_Term_proj___closed__4() { +lean_object* _init_l_Lean_Parser_Term_proj___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; @@ -43714,11 +45262,31 @@ x_4 = l_Lean_Parser_orelseInfo(x_3, x_2); return x_4; } } +lean_object* _init_l_Lean_Parser_Term_proj___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Term_proj___closed__1; +x_2 = l_Lean_Parser_Term_proj___closed__2; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_proj___closed__4() { +_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__3; +x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); +return x_3; +} +} lean_object* _init_l_Lean_Parser_Term_proj___closed__5() { _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_epsilonInfo; x_2 = l_Lean_Parser_Term_proj___closed__4; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; @@ -43727,27 +45295,17 @@ 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___elambda__1___closed__2; -x_2 = l_Lean_Parser_Term_proj___closed__5; -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; 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() { +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___closed__6; -x_2 = l_Lean_Parser_Term_proj___closed__7; +x_1 = l_Lean_Parser_Term_proj___closed__5; +x_2 = l_Lean_Parser_Term_proj___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); @@ -43758,7 +45316,7 @@ lean_object* _init_l_Lean_Parser_Term_proj() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_proj___closed__8; +x_1 = l_Lean_Parser_Term_proj___closed__7; return x_1; } } @@ -43796,8 +45354,8 @@ lean_object* _init_l_Lean_Parser_Term_arrow___elambda__1___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_depArrow___elambda__1___closed__8; -x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__10; +x_1 = l_Lean_Parser_Term_depArrow___elambda__1___closed__6; +x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__8; x_3 = lean_unsigned_to_nat(25u); x_4 = l_Lean_Parser_Term_unicodeInfixR(x_1, x_2, x_3); return x_4; @@ -43913,195 +45471,209 @@ return 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; -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); -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); -if (x_40 == 0) +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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) { -lean_object* x_41; lean_object* x_42; -lean_dec(x_4); -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; -} -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_structInstArrayRef___elambda__1___closed__5; -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); -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_object* x_58; lean_object* x_59; -lean_inc_n(x_4, 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_4); -lean_ctor_set(x_50, 2, x_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); -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(1, 1, 0); -lean_ctor_set(x_54, 0, x_50); -x_55 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_55, 0, x_4); -x_56 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_56, 0, x_53); -x_57 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_57, 0, x_54); -lean_ctor_set(x_57, 1, x_55); -lean_ctor_set(x_57, 2, x_56); -x_58 = lean_alloc_ctor(2, 2, 0); -lean_ctor_set(x_58, 0, x_57); -lean_ctor_set(x_58, 1, x_45); -x_59 = l_Lean_Parser_ParserState_pushSyntax(x_48, x_58); -x_6 = x_59; -goto block_38; -} -else -{ -lean_dec(x_49); -lean_dec(x_44); -lean_dec(x_4); -x_6 = x_48; -goto block_38; -} -} -block_38: -{ -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_43; uint8_t x_44; +x_7 = lean_ctor_get(x_5, 0); lean_inc(x_7); -if (lean_obj_tag(x_7) == 0) +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +x_9 = lean_array_get_size(x_7); +x_43 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_7); +lean_dec(x_7); +x_44 = l_Lean_Parser_checkTailNoWs(x_43); +lean_dec(x_43); +if (x_44 == 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); -lean_inc(x_1); -x_10 = l_Lean_Parser_categoryParser___elambda__1(x_8, x_9, x_1, x_6); +lean_object* x_45; lean_object* x_46; +lean_dec(x_8); +x_45 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__3; +x_46 = l_Lean_Parser_ParserState_mkError(x_5, x_45); +x_10 = x_46; +goto block_42; +} +else +{ +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; +x_47 = lean_ctor_get(x_1, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_47, 0); +lean_inc(x_48); +lean_dec(x_47); +x_49 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__5; +x_50 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__3; +x_51 = lean_unsigned_to_nat(0u); +x_52 = l_Lean_Parser_strAux___main(x_49, x_50, x_51, x_1, x_5); +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_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +lean_inc_n(x_8, 2); +lean_inc(x_48); +x_54 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_54, 0, x_48); +lean_ctor_set(x_54, 1, x_8); +lean_ctor_set(x_54, 2, x_8); +x_55 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__4; +x_56 = lean_nat_add(x_8, x_55); +lean_inc(x_56); +x_57 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_57, 0, x_48); +lean_ctor_set(x_57, 1, x_56); +lean_ctor_set(x_57, 2, x_56); +x_58 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_58, 0, x_54); +x_59 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_59, 0, x_8); +x_60 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_60, 0, x_57); +x_61 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_61, 0, x_58); +lean_ctor_set(x_61, 1, x_59); +lean_ctor_set(x_61, 2, x_60); +x_62 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_49); +x_63 = l_Lean_Parser_ParserState_pushSyntax(x_52, x_62); +x_10 = x_63; +goto block_42; +} +else +{ +lean_dec(x_53); +lean_dec(x_48); +lean_dec(x_8); +x_10 = x_52; +goto block_42; +} +} +block_42: +{ +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; -x_12 = lean_ctor_get(x_10, 1); -lean_inc(x_12); -x_13 = l_Lean_Parser_tokenFn(x_1, 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_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = l_Lean_Parser_termParser___closed__2; +x_13 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_14 = l_Lean_Parser_categoryParser___elambda__1(x_12, x_13, x_1, x_10); +x_15 = lean_ctor_get(x_14, 3); lean_inc(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) +if (lean_obj_tag(x_15) == 0) { -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_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__6; -x_19 = lean_string_dec_eq(x_17, x_18); -lean_dec(x_17); -if (x_19 == 0) +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +x_17 = l_Lean_Parser_tokenFn(x_1, 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_23; -x_20 = l_Lean_Parser_Term_structInstArrayRef___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___closed__2; -x_23 = l_Lean_Parser_ParserState_mkTrailingNode(x_21, x_22, x_5); -lean_dec(x_5); -return x_23; +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_checkStackTopFn___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_structInstArrayRef___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; +x_24 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; +x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); +x_26 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2; +x_27 = l_Lean_Parser_ParserState_mkTrailingNode(x_25, x_26, x_9); +lean_dec(x_9); +return x_27; } else { -lean_object* x_24; lean_object* x_25; -lean_dec(x_12); -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; -} -} -else -{ -lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +lean_object* x_28; lean_object* x_29; lean_dec(x_16); -x_26 = l_Lean_Parser_Term_structInstArrayRef___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___closed__2; -x_29 = l_Lean_Parser_ParserState_mkTrailingNode(x_27, x_28, x_5); -lean_dec(x_5); +x_29 = l_Lean_Parser_ParserState_mkTrailingNode(x_17, x_28, 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_dec(x_14); +lean_dec(x_20); x_30 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_30, x_16); 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); +x_33 = l_Lean_Parser_ParserState_mkTrailingNode(x_31, x_32, x_9); +lean_dec(x_9); return x_33; } } 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___closed__2; -x_35 = l_Lean_Parser_ParserState_mkTrailingNode(x_10, x_34, x_5); -lean_dec(x_5); -return x_35; +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_dec(x_18); +x_34 = l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__9; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_34, x_16); +x_36 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2; +x_37 = l_Lean_Parser_ParserState_mkTrailingNode(x_35, x_36, x_9); +lean_dec(x_9); +return x_37; } } else { -lean_object* x_36; lean_object* x_37; -lean_dec(x_7); +lean_object* x_38; lean_object* x_39; +lean_dec(x_15); lean_dec(x_1); -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; +x_38 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2; +x_39 = l_Lean_Parser_ParserState_mkTrailingNode(x_14, x_38, x_9); +lean_dec(x_9); +return x_39; } } +else +{ +lean_object* x_40; lean_object* x_41; +lean_dec(x_11); +lean_dec(x_1); +x_40 = l_Lean_Parser_Term_arrayRef___elambda__1___closed__2; +x_41 = l_Lean_Parser_ParserState_mkTrailingNode(x_10, x_40, x_9); +lean_dec(x_9); +return x_41; +} +} +} +else +{ +lean_dec(x_6); +lean_dec(x_1); +return x_5; +} } } lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__1() { _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_structInstArrayRef___elambda__1___closed__5; -x_2 = l_Lean_Parser_Term_proj___closed__2; -x_3 = l_Lean_Parser_symbolNoWsInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolNoWsInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__2() { @@ -44127,17 +45699,27 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__4() { _start: { -lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_arrayRef___elambda__1), 2, 0); -return x_1; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_arrayRef___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_arrayRef___closed__5() { _start: { +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__6() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_arrayRef___closed__3; -x_2 = l_Lean_Parser_Term_arrayRef___closed__4; +x_1 = l_Lean_Parser_Term_arrayRef___closed__4; +x_2 = l_Lean_Parser_Term_arrayRef___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); @@ -44148,7 +45730,7 @@ lean_object* _init_l_Lean_Parser_Term_arrayRef() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_arrayRef___closed__5; +x_1 = l_Lean_Parser_Term_arrayRef___closed__6; return x_1; } } @@ -44193,137 +45775,152 @@ return x_1; 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; -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_6 = l_Lean_Parser_dollarSymbol___elambda__1(x_1, x_2); -x_7 = lean_ctor_get(x_6, 3); +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = lean_unsigned_to_nat(1u); +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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) +{ +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_5, 0); 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___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); -if (lean_obj_tag(x_10) == 0) -{ -lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; -lean_dec(x_4); -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_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; -} -else -{ -uint8_t x_16; -lean_dec(x_1); -x_16 = !lean_is_exclusive(x_9); -if (x_16 == 0) -{ -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_17 = lean_ctor_get(x_9, 0); -x_18 = lean_ctor_get(x_9, 3); -lean_dec(x_18); -x_19 = lean_ctor_get(x_9, 1); -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___closed__2; -x_22 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_21, x_5); -lean_dec(x_5); -return x_22; -} -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; -x_23 = lean_ctor_get(x_9, 0); -x_24 = lean_ctor_get(x_9, 2); -lean_inc(x_24); -lean_inc(x_23); -lean_dec(x_9); -x_25 = l_Array_shrink___main___rarg(x_23, x_5); -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_10); -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; -} -} -} -else -{ -lean_object* x_29; +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +x_9 = lean_array_get_size(x_7); lean_dec(x_7); -x_29 = lean_ctor_get(x_6, 3); -lean_inc(x_29); -if (lean_obj_tag(x_29) == 0) +lean_inc(x_1); +x_10 = l_Lean_Parser_dollarSymbol___elambda__1(x_1, x_5); +x_11 = lean_ctor_get(x_10, 3); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -lean_dec(x_4); -x_30 = l_Lean_Parser_termParser___closed__2; -x_31 = lean_unsigned_to_nat(0u); -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; +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = l_Lean_Parser_Term_dollar___elambda__1___closed__3; +x_13 = l_Lean_Parser_checkWsBeforeFn(x_12, x_1, 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; lean_object* x_17; lean_object* x_18; lean_object* x_19; +lean_dec(x_8); +x_15 = l_Lean_Parser_termParser___closed__2; +x_16 = lean_unsigned_to_nat(0u); +x_17 = l_Lean_Parser_categoryParser___elambda__1(x_15, x_16, x_1, x_13); +x_18 = l_Lean_Parser_Term_dollar___elambda__1___closed__2; +x_19 = l_Lean_Parser_ParserState_mkTrailingNode(x_17, x_18, x_9); +lean_dec(x_9); +return x_19; } else { -uint8_t x_35; +uint8_t x_20; lean_dec(x_1); -x_35 = !lean_is_exclusive(x_6); -if (x_35 == 0) +x_20 = !lean_is_exclusive(x_13); +if (x_20 == 0) { -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 = lean_ctor_get(x_6, 0); -x_37 = lean_ctor_get(x_6, 3); -lean_dec(x_37); -x_38 = lean_ctor_get(x_6, 1); -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___closed__2; -x_41 = l_Lean_Parser_ParserState_mkTrailingNode(x_6, x_40, x_5); -lean_dec(x_5); -return x_41; +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_13, 0); +x_22 = lean_ctor_get(x_13, 3); +lean_dec(x_22); +x_23 = lean_ctor_get(x_13, 1); +lean_dec(x_23); +x_24 = l_Array_shrink___main___rarg(x_21, x_9); +lean_ctor_set(x_13, 1, x_8); +lean_ctor_set(x_13, 0, x_24); +x_25 = l_Lean_Parser_Term_dollar___elambda__1___closed__2; +x_26 = l_Lean_Parser_ParserState_mkTrailingNode(x_13, x_25, x_9); +lean_dec(x_9); +return x_26; +} +else +{ +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 = lean_ctor_get(x_13, 0); +x_28 = lean_ctor_get(x_13, 2); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_13); +x_29 = l_Array_shrink___main___rarg(x_27, x_9); +x_30 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_8); +lean_ctor_set(x_30, 2, x_28); +lean_ctor_set(x_30, 3, x_14); +x_31 = l_Lean_Parser_Term_dollar___elambda__1___closed__2; +x_32 = l_Lean_Parser_ParserState_mkTrailingNode(x_30, x_31, x_9); +lean_dec(x_9); +return x_32; +} +} +} +else +{ +lean_object* x_33; +lean_dec(x_11); +x_33 = lean_ctor_get(x_10, 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_object* x_37; lean_object* x_38; +lean_dec(x_8); +x_34 = l_Lean_Parser_termParser___closed__2; +x_35 = lean_unsigned_to_nat(0u); +x_36 = l_Lean_Parser_categoryParser___elambda__1(x_34, x_35, x_1, x_10); +x_37 = l_Lean_Parser_Term_dollar___elambda__1___closed__2; +x_38 = l_Lean_Parser_ParserState_mkTrailingNode(x_36, x_37, x_9); +lean_dec(x_9); +return x_38; +} +else +{ +uint8_t x_39; +lean_dec(x_1); +x_39 = !lean_is_exclusive(x_10); +if (x_39 == 0) +{ +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 = lean_ctor_get(x_10, 0); +x_41 = lean_ctor_get(x_10, 3); +lean_dec(x_41); +x_42 = lean_ctor_get(x_10, 1); +lean_dec(x_42); +x_43 = l_Array_shrink___main___rarg(x_40, x_9); +lean_ctor_set(x_10, 1, x_8); +lean_ctor_set(x_10, 0, x_43); +x_44 = l_Lean_Parser_Term_dollar___elambda__1___closed__2; +x_45 = l_Lean_Parser_ParserState_mkTrailingNode(x_10, x_44, 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_object* x_51; +x_46 = lean_ctor_get(x_10, 0); +x_47 = lean_ctor_get(x_10, 2); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_10); +x_48 = l_Array_shrink___main___rarg(x_46, x_9); +x_49 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_8); +lean_ctor_set(x_49, 2, x_47); +lean_ctor_set(x_49, 3, x_33); +x_50 = l_Lean_Parser_Term_dollar___elambda__1___closed__2; +x_51 = l_Lean_Parser_ParserState_mkTrailingNode(x_49, x_50, x_9); +lean_dec(x_9); +return x_51; +} +} +} } 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 = lean_ctor_get(x_6, 0); -x_43 = lean_ctor_get(x_6, 2); -lean_inc(x_43); -lean_inc(x_42); lean_dec(x_6); -x_44 = l_Array_shrink___main___rarg(x_42, x_5); -x_45 = lean_alloc_ctor(0, 4, 0); -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___closed__2; -x_47 = l_Lean_Parser_ParserState_mkTrailingNode(x_45, x_46, x_5); -lean_dec(x_5); -return x_47; -} -} +lean_dec(x_1); +return x_5; } } } @@ -44343,7 +45940,7 @@ 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_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_Parser_Term_dollar___closed__1; @@ -44364,17 +45961,27 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_dollar___closed__4() { _start: { -lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_dollar___elambda__1), 2, 0); -return x_1; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_dollar___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_dollar___closed__5() { _start: { +lean_object* x_1; +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__6() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_dollar___closed__3; -x_2 = l_Lean_Parser_Term_dollar___closed__4; +x_1 = l_Lean_Parser_Term_dollar___closed__4; +x_2 = l_Lean_Parser_Term_dollar___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); @@ -44385,7 +45992,7 @@ lean_object* _init_l_Lean_Parser_Term_dollar() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_dollar___closed__5; +x_1 = l_Lean_Parser_Term_dollar___closed__6; return x_1; } } @@ -44471,212 +46078,227 @@ return x_3; lean_object* l_Lean_Parser_Term_dollarProj___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_40; lean_object* x_41; lean_object* x_42; +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_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 = lean_array_get_size(x_5); -lean_dec(x_5); -x_40 = lean_ctor_get(x_2, 1); -lean_inc(x_40); -lean_inc(x_1); -x_41 = l_Lean_Parser_tokenFn(x_1, x_2); -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_Lean_Parser_Term_dollarProj___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_48; lean_object* x_49; -x_48 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7; -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40); -x_7 = x_49; -goto block_39; -} -else -{ -lean_dec(x_40); -x_7 = x_41; -goto block_39; -} -} -else -{ -lean_object* x_50; lean_object* x_51; -lean_dec(x_44); -x_50 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7; -x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40); -x_7 = x_51; -goto block_39; -} -} -else -{ -lean_object* x_52; lean_object* x_53; -lean_dec(x_42); -x_52 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7; -x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40); -x_7 = x_53; -goto block_39; -} -block_39: -{ -lean_object* x_8; +x_5 = lean_unsigned_to_nat(1u); +x_6 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_7 = l_Lean_Parser_checkRbpLtFn(x_5, x_6, 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_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_27; +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_44; lean_object* x_45; lean_object* x_46; 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_7); +x_44 = lean_ctor_get(x_7, 1); +lean_inc(x_44); lean_inc(x_1); -x_27 = l_Lean_Parser_tryAnti(x_1, x_7); -if (x_27 == 0) +x_45 = l_Lean_Parser_tokenFn(x_1, x_7); +x_46 = lean_ctor_get(x_45, 3); +lean_inc(x_46); +if (lean_obj_tag(x_46) == 0) { -lean_object* x_28; -lean_dec(x_4); -x_28 = l_Lean_Parser_fieldIdxFn(x_1, x_7); -x_12 = x_28; -goto block_26; +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_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_dollarProj___elambda__1___closed__4; +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_dollarProj___elambda__1___closed__7; +x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_52, x_44); +x_11 = x_53; +goto block_43; } else { -lean_object* x_29; lean_object* x_30; -lean_inc(x_1); -x_29 = lean_apply_2(x_4, x_1, x_7); -x_30 = lean_ctor_get(x_29, 3); -lean_inc(x_30); -if (lean_obj_tag(x_30) == 0) -{ -x_12 = x_29; -goto block_26; +lean_dec(x_44); +x_11 = x_45; +goto block_43; +} } else { -lean_object* x_31; lean_object* x_32; uint8_t x_33; -x_31 = lean_ctor_get(x_30, 0); -lean_inc(x_31); -lean_dec(x_30); -x_32 = lean_ctor_get(x_29, 1); -lean_inc(x_32); -x_33 = lean_nat_dec_eq(x_32, x_11); -lean_dec(x_32); -if (x_33 == 0) -{ -lean_dec(x_31); -x_12 = x_29; -goto block_26; +lean_object* x_54; lean_object* x_55; +lean_dec(x_48); +x_54 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7; +x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_54, x_44); +x_11 = x_55; +goto block_43; +} } else { -lean_object* x_34; lean_object* x_35; lean_object* x_36; -lean_inc(x_11); -x_34 = l_Lean_Parser_ParserState_restore(x_29, x_10, x_11); -x_35 = l_Lean_Parser_fieldIdxFn(x_1, x_34); -x_36 = l_Lean_Parser_mergeOrElseErrors(x_35, x_31, x_11); -x_12 = x_36; -goto block_26; +lean_object* x_56; lean_object* x_57; +lean_dec(x_46); +x_56 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__7; +x_57 = l_Lean_Parser_ParserState_mkErrorsAt(x_45, x_56, x_44); +x_11 = x_57; +goto block_43; } -} -} -block_26: +block_43: { -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; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_31; +x_13 = lean_ctor_get(x_11, 0); 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); +x_14 = lean_array_get_size(x_13); 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; +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); lean_inc(x_11); -x_21 = l_Lean_Parser_ParserState_restore(x_12, x_10, x_11); +lean_inc(x_1); +x_31 = l_Lean_Parser_tryAnti(x_1, x_11); +if (x_31 == 0) +{ +lean_object* x_32; +lean_dec(x_4); +x_32 = l_Lean_Parser_fieldIdxFn(x_1, x_11); +x_16 = x_32; +goto block_30; +} +else +{ +lean_object* x_33; lean_object* x_34; +lean_inc(x_1); +x_33 = lean_apply_2(x_4, x_1, x_11); +x_34 = lean_ctor_get(x_33, 3); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +x_16 = x_33; +goto block_30; +} +else +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 0); +lean_inc(x_35); +lean_dec(x_34); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +x_37 = lean_nat_dec_eq(x_36, x_15); +lean_dec(x_36); +if (x_37 == 0) +{ +lean_dec(x_35); +x_16 = x_33; +goto block_30; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +lean_inc(x_15); +x_38 = l_Lean_Parser_ParserState_restore(x_33, x_14, x_15); +x_39 = l_Lean_Parser_fieldIdxFn(x_1, x_38); +x_40 = l_Lean_Parser_mergeOrElseErrors(x_39, x_35, x_15); +x_16 = x_40; +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_1); +x_18 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2; +x_19 = l_Lean_Parser_ParserState_mkTrailingNode(x_16, x_18, x_10); 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; +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_1); +x_23 = l_Lean_Parser_Term_dollarProj___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 = l_Lean_Parser_ident___elambda__1(x_1, x_25); +x_27 = l_Lean_Parser_mergeOrElseErrors(x_26, x_20, x_15); +lean_dec(x_15); +x_28 = l_Lean_Parser_Term_dollarProj___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_37; lean_object* x_38; +lean_object* x_41; lean_object* x_42; +lean_dec(x_12); +lean_dec(x_4); +lean_dec(x_1); +x_41 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2; +x_42 = l_Lean_Parser_ParserState_mkTrailingNode(x_11, x_41, x_10); +lean_dec(x_10); +return x_42; +} +} +} +else +{ lean_dec(x_8); lean_dec(x_4); lean_dec(x_1); -x_37 = l_Lean_Parser_Term_dollarProj___elambda__1___closed__2; -x_38 = l_Lean_Parser_ParserState_mkTrailingNode(x_7, x_37, x_6); -lean_dec(x_6); -return x_38; -} +return x_7; } } } lean_object* _init_l_Lean_Parser_Term_dollarProj___closed__1() { _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_dollarProj___elambda__1___closed__4; -x_2 = l_Lean_Parser_dollarSymbol___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_dollarProj___closed__2() { @@ -44684,7 +46306,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__4; +x_2 = l_Lean_Parser_Term_proj___closed__2; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } @@ -44702,17 +46324,27 @@ return x_3; 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), 2, 0); -return x_1; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_dollarProj___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_dollarProj___closed__5() { _start: { +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_dollarProj___elambda__1), 2, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Parser_Term_dollarProj___closed__6() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_dollarProj___closed__3; -x_2 = l_Lean_Parser_Term_dollarProj___closed__4; +x_1 = l_Lean_Parser_Term_dollarProj___closed__4; +x_2 = l_Lean_Parser_Term_dollarProj___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); @@ -44723,7 +46355,7 @@ lean_object* _init_l_Lean_Parser_Term_dollarProj() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_dollarProj___closed__5; +x_1 = l_Lean_Parser_Term_dollarProj___closed__6; return x_1; } } @@ -45106,103 +46738,117 @@ return x_3; lean_object* l_Lean_Parser_Term_where___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_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); -if (lean_obj_tag(x_16) == 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); -lean_dec(x_18); -x_20 = l___private_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 (x_21 == 0) -{ -lean_object* x_22; lean_object* x_23; -x_22 = l___private_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_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_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_16); -x_26 = l___private_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_15, x_26, x_14); -x_5 = x_27; -goto block_13; -} -block_13: -{ -lean_object* x_6; +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = lean_unsigned_to_nat(1u); +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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_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; +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_18; lean_object* x_19; lean_object* x_20; +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_18 = lean_ctor_get(x_5, 1); +lean_inc(x_18); +lean_inc(x_1); +x_19 = l_Lean_Parser_tokenFn(x_1, x_5); +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; +x_21 = lean_ctor_get(x_19, 0); +lean_inc(x_21); +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); +lean_dec(x_22); +x_24 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__2; +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; +x_26 = l___private_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_19, x_26, x_18); +x_9 = x_27; +goto block_17; +} +else +{ +lean_dec(x_18); +x_9 = x_19; +goto block_17; +} +} +else +{ +lean_object* x_28; lean_object* x_29; +lean_dec(x_22); +x_28 = l___private_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_19, x_28, x_18); +x_9 = x_29; +goto block_17; +} +} +else +{ +lean_object* x_30; lean_object* x_31; +lean_dec(x_20); +x_30 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__5; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); +x_9 = x_31; +goto block_17; +} +block_17: +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_9, 3); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = 0; +x_12 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_where___elambda__1___spec__1(x_11, x_11, x_1, x_9); +x_13 = l_Lean_Parser_Term_where___elambda__1___closed__2; +x_14 = l_Lean_Parser_ParserState_mkTrailingNode(x_12, x_13, x_8); +lean_dec(x_8); +return x_14; +} +else +{ +lean_object* x_15; lean_object* x_16; +lean_dec(x_10); +lean_dec(x_1); +x_15 = l_Lean_Parser_Term_where___elambda__1___closed__2; +x_16 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_15, x_8); +lean_dec(x_8); +return x_16; +} +} } else { -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_5, x_11, x_4); -lean_dec(x_4); -return x_12; -} +return x_5; } } } lean_object* _init_l_Lean_Parser_Term_where___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; +lean_object* x_1; lean_object* x_2; x_1 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_where___elambda__1___spec__2___closed__2; -x_2 = l_Lean_Parser_dollarSymbol___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_where___closed__2() { @@ -45260,17 +46906,27 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_where___closed__7() { _start: { -lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_where___elambda__1), 2, 0); -return x_1; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_where___closed__6; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } 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), 2, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Parser_Term_where___closed__9() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_where___closed__6; -x_2 = l_Lean_Parser_Term_where___closed__7; +x_1 = l_Lean_Parser_Term_where___closed__7; +x_2 = l_Lean_Parser_Term_where___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); @@ -45281,7 +46937,7 @@ lean_object* _init_l_Lean_Parser_Term_where() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_where___closed__8; +x_1 = l_Lean_Parser_Term_where___closed__9; return x_1; } } @@ -47660,92 +49316,107 @@ return x_3; lean_object* l_Lean_Parser_Term_subst___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_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); -if (lean_obj_tag(x_16) == 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); -lean_dec(x_18); -x_20 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___closed__2; -x_21 = lean_string_dec_eq(x_19, x_20); -lean_dec(x_19); -if (x_21 == 0) -{ -lean_object* x_22; lean_object* x_23; -x_22 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___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_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_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___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_16); -x_26 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___closed__5; -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; +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = lean_unsigned_to_nat(75u); +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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_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_subst___elambda__1___spec__1(x_7, x_7, x_1, x_5); -x_9 = l_Lean_Parser_Term_subst___elambda__1___closed__2; -x_10 = l_Lean_Parser_ParserState_mkTrailingNode(x_8, x_9, x_4); -lean_dec(x_4); -return x_10; +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_18; lean_object* x_19; lean_object* x_20; +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_18 = lean_ctor_get(x_5, 1); +lean_inc(x_18); +lean_inc(x_1); +x_19 = l_Lean_Parser_tokenFn(x_1, x_5); +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; +x_21 = lean_ctor_get(x_19, 0); +lean_inc(x_21); +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); +lean_dec(x_22); +x_24 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___closed__2; +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; +x_26 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___closed__5; +x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_26, x_18); +x_9 = x_27; +goto block_17; +} +else +{ +lean_dec(x_18); +x_9 = x_19; +goto block_17; +} +} +else +{ +lean_object* x_28; lean_object* x_29; +lean_dec(x_22); +x_28 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___closed__5; +x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_28, x_18); +x_9 = x_29; +goto block_17; +} +} +else +{ +lean_object* x_30; lean_object* x_31; +lean_dec(x_20); +x_30 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___closed__5; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_19, x_30, x_18); +x_9 = x_31; +goto block_17; +} +block_17: +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_9, 3); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = 0; +x_12 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_subst___elambda__1___spec__1(x_11, x_11, x_1, x_9); +x_13 = l_Lean_Parser_Term_subst___elambda__1___closed__2; +x_14 = l_Lean_Parser_ParserState_mkTrailingNode(x_12, x_13, x_8); +lean_dec(x_8); +return x_14; +} +else +{ +lean_object* x_15; lean_object* x_16; +lean_dec(x_10); +lean_dec(x_1); +x_15 = l_Lean_Parser_Term_subst___elambda__1___closed__2; +x_16 = l_Lean_Parser_ParserState_mkTrailingNode(x_9, x_15, x_8); +lean_dec(x_8); +return x_16; +} +} } else { -lean_object* x_11; lean_object* x_12; lean_dec(x_6); lean_dec(x_1); -x_11 = l_Lean_Parser_Term_subst___elambda__1___closed__2; -x_12 = l_Lean_Parser_ParserState_mkTrailingNode(x_5, x_11, x_4); -lean_dec(x_4); -return x_12; -} +return x_5; } } } @@ -47753,9 +49424,8 @@ lean_object* _init_l_Lean_Parser_Term_subst___closed__1() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = lean_unsigned_to_nat(75u); -x_2 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_2, 0, x_1); +x_1 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___closed__2; +x_2 = l_Lean_Parser_symbolInfo(x_1); return x_2; } } @@ -47763,41 +49433,41 @@ lean_object* _init_l_Lean_Parser_Term_subst___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_subst___elambda__1___spec__2___closed__2; -x_2 = l_Lean_Parser_Term_subst___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_Term_subst___closed__3() { -_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(75u); x_3 = l_Lean_Parser_categoryParser(x_1, x_2); return x_3; } } -lean_object* _init_l_Lean_Parser_Term_subst___closed__4() { +lean_object* _init_l_Lean_Parser_Term_subst___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_subst___closed__3; +x_1 = l_Lean_Parser_Term_subst___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_subst___closed__2; +x_3 = l_Lean_Parser_Term_subst___closed__1; x_4 = l_Lean_Parser_sepBy1Info(x_2, x_3); return x_4; } } +lean_object* _init_l_Lean_Parser_Term_subst___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Term_subst___closed__1; +x_2 = l_Lean_Parser_Term_subst___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} lean_object* _init_l_Lean_Parser_Term_subst___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_subst___closed__2; +x_1 = l_Lean_Parser_Term_subst___elambda__1___closed__2; x_2 = l_Lean_Parser_Term_subst___closed__4; -x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); return x_3; } } @@ -47805,9 +49475,9 @@ lean_object* _init_l_Lean_Parser_Term_subst___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_subst___elambda__1___closed__2; +x_1 = l_Lean_Parser_epsilonInfo; x_2 = l_Lean_Parser_Term_subst___closed__5; -x_3 = l_Lean_Parser_nodeInfo(x_1, x_2); +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } } @@ -50051,377 +51721,410 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_39 = lean_ctor_get(x_2, 1); -lean_inc(x_39); -lean_inc(x_1); -x_40 = l_Lean_Parser_tokenFn(x_1, x_2); -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; -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); -lean_dec(x_43); -x_45 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__6; -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_tacticBlock___elambda__1___closed__14; -x_48 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_47, x_39); -x_8 = x_48; -goto block_38; -} -else -{ -lean_dec(x_39); -x_8 = x_40; -goto block_38; -} -} -else -{ -lean_object* x_49; lean_object* x_50; -lean_dec(x_43); -x_49 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_49, x_39); -x_8 = x_50; -goto block_38; -} -} -else -{ -lean_object* x_51; lean_object* x_52; -lean_dec(x_41); -x_51 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_40, x_51, x_39); -x_8 = x_52; -goto block_38; -} -block_38: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_43; lean_object* x_44; lean_object* x_45; +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_43 = lean_ctor_get(x_8, 1); +lean_inc(x_43); lean_inc(x_1); -x_10 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_8); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 0) +x_44 = l_Lean_Parser_tokenFn(x_1, x_8); +x_45 = lean_ctor_get(x_44, 3); +lean_inc(x_45); +if (lean_obj_tag(x_45) == 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_1, x_10); -x_14 = lean_ctor_get(x_13, 3); -lean_inc(x_14); -if (lean_obj_tag(x_14) == 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_15; lean_object* x_16; -x_15 = lean_ctor_get(x_13, 0); +lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_48 = lean_ctor_get(x_47, 1); +lean_inc(x_48); +lean_dec(x_47); +x_49 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__6; +x_50 = lean_string_dec_eq(x_48, x_49); +lean_dec(x_48); +if (x_50 == 0) +{ +lean_object* x_51; lean_object* x_52; +x_51 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_51, x_43); +x_12 = x_52; +goto block_42; +} +else +{ +lean_dec(x_43); +x_12 = x_44; +goto block_42; +} +} +else +{ +lean_object* x_53; lean_object* x_54; +lean_dec(x_47); +x_53 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_53, x_43); +x_12 = x_54; +goto block_42; +} +} +else +{ +lean_object* x_55; lean_object* x_56; +lean_dec(x_45); +x_55 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_56 = l_Lean_Parser_ParserState_mkErrorsAt(x_44, x_55, x_43); +x_12 = x_56; +goto block_42; +} +block_42: +{ +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_inc(x_1); +x_14 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_12); +x_15 = lean_ctor_get(x_14, 3); lean_inc(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) +if (lean_obj_tag(x_15) == 0) { -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_Lean_Parser_Term_tacticBlock___elambda__1___closed__8; -x_19 = lean_string_dec_eq(x_17, x_18); -lean_dec(x_17); -if (x_19 == 0) +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +x_17 = l_Lean_Parser_tokenFn(x_1, 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_23; -x_20 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_21 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_20, x_12); -x_22 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_23 = l_Lean_Parser_ParserState_mkNode(x_21, x_22, x_7); -return x_23; +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_checkStackTopFn___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_tacticBlock___elambda__1___closed__8; +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; +x_24 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; +x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); +x_26 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; +x_27 = l_Lean_Parser_ParserState_mkNode(x_25, x_26, x_11); +return x_27; } else { -lean_object* x_24; lean_object* x_25; -lean_dec(x_12); -x_24 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_25 = l_Lean_Parser_ParserState_mkNode(x_13, 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_28; lean_object* x_29; lean_dec(x_16); -x_26 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_27 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_26, x_12); x_28 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_29 = l_Lean_Parser_ParserState_mkNode(x_27, x_28, x_7); +x_29 = l_Lean_Parser_ParserState_mkNode(x_17, x_28, x_11); return x_29; } } else { lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; -lean_dec(x_14); +lean_dec(x_20); x_30 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_13, x_30, x_12); +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_30, x_16); x_32 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_7); +x_33 = l_Lean_Parser_ParserState_mkNode(x_31, x_32, x_11); return x_33; } } else { -lean_object* x_34; lean_object* x_35; -lean_dec(x_11); -lean_dec(x_1); -x_34 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_35 = l_Lean_Parser_ParserState_mkNode(x_10, x_34, x_7); -return x_35; -} -} -else -{ -lean_object* x_36; lean_object* x_37; -lean_dec(x_9); -lean_dec(x_1); +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_dec(x_18); +x_34 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; +x_35 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_34, x_16); x_36 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_37 = l_Lean_Parser_ParserState_mkNode(x_8, x_36, x_7); +x_37 = l_Lean_Parser_ParserState_mkNode(x_35, x_36, x_11); return x_37; } } +else +{ +lean_object* x_38; lean_object* x_39; +lean_dec(x_15); +lean_dec(x_1); +x_38 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; +x_39 = l_Lean_Parser_ParserState_mkNode(x_14, x_38, x_11); +return x_39; +} } else { -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_2, 0); -lean_inc(x_53); -x_54 = lean_array_get_size(x_53); -lean_dec(x_53); -x_55 = lean_ctor_get(x_2, 1); -lean_inc(x_55); -lean_inc(x_1); -x_56 = lean_apply_2(x_4, x_1, x_2); -x_57 = lean_ctor_get(x_56, 3); +lean_object* x_40; lean_object* x_41; +lean_dec(x_13); +lean_dec(x_1); +x_40 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; +x_41 = l_Lean_Parser_ParserState_mkNode(x_12, x_40, x_11); +return x_41; +} +} +} +else +{ +lean_dec(x_9); +lean_dec(x_1); +return x_8; +} +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_57 = lean_ctor_get(x_2, 0); lean_inc(x_57); -if (lean_obj_tag(x_57) == 0) -{ -lean_dec(x_55); -lean_dec(x_54); -lean_dec(x_1); -return x_56; -} -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); +x_58 = lean_array_get_size(x_57); lean_dec(x_57); -x_59 = lean_ctor_get(x_56, 1); +x_59 = lean_ctor_get(x_2, 1); lean_inc(x_59); -x_60 = lean_nat_dec_eq(x_59, x_55); -lean_dec(x_59); -if (x_60 == 0) +lean_inc(x_1); +x_60 = lean_apply_2(x_4, x_1, x_2); +x_61 = lean_ctor_get(x_60, 3); +lean_inc(x_61); +if (lean_obj_tag(x_61) == 0) { +lean_dec(x_59); lean_dec(x_58); -lean_dec(x_55); -lean_dec(x_54); lean_dec(x_1); -return x_56; +return x_60; } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_101; lean_object* x_102; -lean_inc(x_55); -x_61 = l_Lean_Parser_ParserState_restore(x_56, x_54, x_55); -lean_dec(x_54); +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_63 = lean_array_get_size(x_62); +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_59); +lean_dec(x_63); +if (x_64 == 0) +{ lean_dec(x_62); +lean_dec(x_59); +lean_dec(x_58); +lean_dec(x_1); +return x_60; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_inc(x_59); +x_65 = l_Lean_Parser_ParserState_restore(x_60, x_58, x_59); +lean_dec(x_58); +x_66 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_67 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_68 = l_Lean_Parser_checkRbpLtFn(x_66, x_67, 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; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_70 = lean_ctor_get(x_68, 0); +lean_inc(x_70); +x_71 = lean_array_get_size(x_70); +lean_dec(x_70); +x_109 = lean_ctor_get(x_68, 1); +lean_inc(x_109); lean_inc(x_1); -x_101 = l_Lean_Parser_tokenFn(x_1, x_61); -x_102 = lean_ctor_get(x_101, 3); -lean_inc(x_102); -if (lean_obj_tag(x_102) == 0) -{ -lean_object* x_103; lean_object* x_104; -x_103 = lean_ctor_get(x_101, 0); -lean_inc(x_103); -x_104 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_103); -lean_dec(x_103); -if (lean_obj_tag(x_104) == 2) -{ -lean_object* x_105; lean_object* x_106; uint8_t x_107; -x_105 = lean_ctor_get(x_104, 1); -lean_inc(x_105); -lean_dec(x_104); -x_106 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__6; -x_107 = lean_string_dec_eq(x_105, x_106); -lean_dec(x_105); -if (x_107 == 0) -{ -lean_object* x_108; lean_object* x_109; -x_108 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -lean_inc(x_55); -x_109 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_108, x_55); -x_64 = x_109; -goto block_100; -} -else -{ -x_64 = x_101; -goto block_100; -} -} -else -{ -lean_object* x_110; lean_object* x_111; -lean_dec(x_104); -x_110 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -lean_inc(x_55); -x_111 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_110, x_55); -x_64 = x_111; -goto block_100; -} -} -else +x_110 = l_Lean_Parser_tokenFn(x_1, x_68); +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_102); -x_112 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; -lean_inc(x_55); -x_113 = l_Lean_Parser_ParserState_mkErrorsAt(x_101, x_112, x_55); -x_64 = x_113; -goto block_100; +x_112 = lean_ctor_get(x_110, 0); +lean_inc(x_112); +x_113 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_112); +lean_dec(x_112); +if (lean_obj_tag(x_113) == 2) +{ +lean_object* x_114; lean_object* x_115; uint8_t x_116; +x_114 = lean_ctor_get(x_113, 1); +lean_inc(x_114); +lean_dec(x_113); +x_115 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__6; +x_116 = lean_string_dec_eq(x_114, x_115); +lean_dec(x_114); +if (x_116 == 0) +{ +lean_object* x_117; lean_object* x_118; +x_117 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_118 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_117, x_109); +x_72 = x_118; +goto block_108; } -block_100: +else { -lean_object* x_65; -x_65 = lean_ctor_get(x_64, 3); -lean_inc(x_65); -if (lean_obj_tag(x_65) == 0) +lean_dec(x_109); +x_72 = x_110; +goto block_108; +} +} +else { -lean_object* x_66; lean_object* x_67; -lean_inc(x_1); -x_66 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_64); -x_67 = lean_ctor_get(x_66, 3); -lean_inc(x_67); -if (lean_obj_tag(x_67) == 0) +lean_object* x_119; lean_object* x_120; +lean_dec(x_113); +x_119 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_120 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_119, x_109); +x_72 = x_120; +goto block_108; +} +} +else { -lean_object* x_68; lean_object* x_69; lean_object* x_70; -x_68 = lean_ctor_get(x_66, 1); -lean_inc(x_68); -x_69 = l_Lean_Parser_tokenFn(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_121; lean_object* x_122; +lean_dec(x_111); +x_121 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__14; +x_122 = l_Lean_Parser_ParserState_mkErrorsAt(x_110, x_121, x_109); +x_72 = x_122; +goto block_108; +} +block_108: { -lean_object* x_71; lean_object* x_72; -x_71 = lean_ctor_get(x_69, 0); -lean_inc(x_71); -x_72 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_71); -lean_dec(x_71); -if (lean_obj_tag(x_72) == 2) -{ -lean_object* x_73; lean_object* x_74; uint8_t x_75; -x_73 = lean_ctor_get(x_72, 1); +lean_object* x_73; +x_73 = lean_ctor_get(x_72, 3); lean_inc(x_73); -lean_dec(x_72); -x_74 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__8; -x_75 = lean_string_dec_eq(x_73, x_74); -lean_dec(x_73); -if (x_75 == 0) +if (lean_obj_tag(x_73) == 0) { -lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; -x_76 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_77 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_76, x_68); -x_78 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_79 = l_Lean_Parser_ParserState_mkNode(x_77, x_78, x_63); -x_80 = l_Lean_Parser_mergeOrElseErrors(x_79, x_58, x_55); -lean_dec(x_55); -return x_80; -} -else +lean_object* x_74; lean_object* x_75; +lean_inc(x_1); +x_74 = l_Lean_Parser_Tactic_seq___elambda__1(x_1, x_72); +x_75 = lean_ctor_get(x_74, 3); +lean_inc(x_75); +if (lean_obj_tag(x_75) == 0) { -lean_object* x_81; lean_object* x_82; lean_object* x_83; -lean_dec(x_68); -x_81 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_82 = l_Lean_Parser_ParserState_mkNode(x_69, x_81, x_63); -x_83 = l_Lean_Parser_mergeOrElseErrors(x_82, x_58, x_55); -lean_dec(x_55); -return x_83; -} -} -else +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_74, 1); +lean_inc(x_76); +x_77 = l_Lean_Parser_tokenFn(x_1, x_74); +x_78 = lean_ctor_get(x_77, 3); +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_checkStackTopFn___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_Term_tacticBlock___elambda__1___closed__8; +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; lean_object* x_86; lean_object* x_87; lean_object* x_88; -lean_dec(x_72); x_84 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_84, x_68); +x_85 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_84, x_76); x_86 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_87 = l_Lean_Parser_ParserState_mkNode(x_85, x_86, x_63); -x_88 = l_Lean_Parser_mergeOrElseErrors(x_87, x_58, x_55); -lean_dec(x_55); +x_87 = l_Lean_Parser_ParserState_mkNode(x_85, x_86, x_71); +x_88 = l_Lean_Parser_mergeOrElseErrors(x_87, x_62, x_59); +lean_dec(x_59); return x_88; } -} else { -lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; -lean_dec(x_70); -x_89 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; -x_90 = l_Lean_Parser_ParserState_mkErrorsAt(x_69, x_89, x_68); -x_91 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_92 = l_Lean_Parser_ParserState_mkNode(x_90, x_91, x_63); -x_93 = l_Lean_Parser_mergeOrElseErrors(x_92, x_58, x_55); -lean_dec(x_55); -return x_93; +lean_object* x_89; lean_object* x_90; lean_object* x_91; +lean_dec(x_76); +x_89 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; +x_90 = l_Lean_Parser_ParserState_mkNode(x_77, x_89, x_71); +x_91 = l_Lean_Parser_mergeOrElseErrors(x_90, x_62, x_59); +lean_dec(x_59); +return x_91; } } else { -lean_object* x_94; lean_object* x_95; lean_object* x_96; -lean_dec(x_67); -lean_dec(x_1); +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_80); +x_92 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; +x_93 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_92, x_76); x_94 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_95 = l_Lean_Parser_ParserState_mkNode(x_66, x_94, x_63); -x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_58, x_55); -lean_dec(x_55); +x_95 = l_Lean_Parser_ParserState_mkNode(x_93, x_94, x_71); +x_96 = l_Lean_Parser_mergeOrElseErrors(x_95, x_62, x_59); +lean_dec(x_59); return x_96; } } else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; -lean_dec(x_65); -lean_dec(x_1); -x_97 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; -x_98 = l_Lean_Parser_ParserState_mkNode(x_64, x_97, x_63); -x_99 = l_Lean_Parser_mergeOrElseErrors(x_98, x_58, x_55); -lean_dec(x_55); -return x_99; +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +lean_dec(x_78); +x_97 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__11; +x_98 = l_Lean_Parser_ParserState_mkErrorsAt(x_77, x_97, x_76); +x_99 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; +x_100 = l_Lean_Parser_ParserState_mkNode(x_98, x_99, x_71); +x_101 = l_Lean_Parser_mergeOrElseErrors(x_100, x_62, x_59); +lean_dec(x_59); +return x_101; } } +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +lean_dec(x_75); +lean_dec(x_1); +x_102 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; +x_103 = l_Lean_Parser_ParserState_mkNode(x_74, x_102, x_71); +x_104 = l_Lean_Parser_mergeOrElseErrors(x_103, x_62, x_59); +lean_dec(x_59); +return x_104; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_73); +lean_dec(x_1); +x_105 = l_Lean_Parser_Term_tacticBlock___elambda__1___closed__2; +x_106 = l_Lean_Parser_ParserState_mkNode(x_72, x_105, x_71); +x_107 = l_Lean_Parser_mergeOrElseErrors(x_106, x_62, x_59); +lean_dec(x_59); +return x_107; +} +} +} +else +{ +lean_object* x_123; +lean_dec(x_69); +lean_dec(x_1); +x_123 = l_Lean_Parser_mergeOrElseErrors(x_68, x_62, x_59); +lean_dec(x_59); +return x_123; +} } } } @@ -50430,21 +52133,19 @@ return x_99; lean_object* _init_l_Lean_Parser_Term_tacticBlock___closed__1() { _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_tacticBlock___elambda__1___closed__6; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_tacticBlock___closed__2() { _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_tacticBlock___elambda__1___closed__8; -x_2 = l_Lean_Syntax_decodeNatLitVal___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_tacticBlock___closed__3() { @@ -50482,16 +52183,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_tacticBlock___closed__6() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_tacticBlock___closed__5; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_tacticBlock___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_tacticBlock___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_tacticBlock___closed__5; +x_3 = l_Lean_Parser_Term_tacticBlock___closed__6; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_tacticBlock___closed__7() { +lean_object* _init_l_Lean_Parser_Term_tacticBlock___closed__8() { _start: { lean_object* x_1; @@ -50499,12 +52210,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tacticBlock___elambda__1), 2 return x_1; } } -lean_object* _init_l_Lean_Parser_Term_tacticBlock___closed__8() { +lean_object* _init_l_Lean_Parser_Term_tacticBlock___closed__9() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_tacticBlock___closed__6; -x_2 = l_Lean_Parser_Term_tacticBlock___closed__7; +x_1 = l_Lean_Parser_Term_tacticBlock___closed__7; +x_2 = l_Lean_Parser_Term_tacticBlock___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); @@ -50515,7 +52226,7 @@ lean_object* _init_l_Lean_Parser_Term_tacticBlock() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_tacticBlock___closed__8; +x_1 = l_Lean_Parser_Term_tacticBlock___closed__9; return x_1; } } @@ -50631,223 +52342,256 @@ lean_inc(x_1); x_5 = l_Lean_Parser_tryAnti(x_1, x_2); if (x_5 == 0) { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_16; lean_object* x_17; lean_object* x_18; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_4); -x_6 = lean_ctor_get(x_2, 0); -lean_inc(x_6); -x_7 = lean_array_get_size(x_6); -lean_dec(x_6); -x_16 = lean_ctor_get(x_2, 1); -lean_inc(x_16); -lean_inc(x_1); -x_17 = l_Lean_Parser_tokenFn(x_1, x_2); -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_checkStackTopFn___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_byTactic___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; -x_24 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; -x_25 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_24, x_16); -x_8 = x_25; -goto block_15; -} -else -{ -lean_dec(x_16); -x_8 = x_17; -goto block_15; -} -} -else -{ -lean_object* x_26; lean_object* x_27; -lean_dec(x_20); -x_26 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; -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_dec(x_18); -x_28 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_17, x_28, x_16); -x_8 = x_29; -goto block_15; -} -block_15: -{ -lean_object* x_9; +x_6 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_7 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_8 = l_Lean_Parser_checkRbpLtFn(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_10; lean_object* x_11; lean_object* x_12; -x_10 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_8); -x_11 = l_Lean_Parser_Term_byTactic___elambda__1___closed__2; -x_12 = l_Lean_Parser_ParserState_mkNode(x_10, x_11, x_7); -return x_12; +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_20; lean_object* x_21; lean_object* x_22; +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_20 = lean_ctor_get(x_8, 1); +lean_inc(x_20); +lean_inc(x_1); +x_21 = l_Lean_Parser_tokenFn(x_1, x_8); +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; +x_23 = lean_ctor_get(x_21, 0); +lean_inc(x_23); +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); +lean_dec(x_24); +x_26 = l_Lean_Parser_Term_byTactic___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_28; lean_object* x_29; +x_28 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; +x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_28, x_20); +x_12 = x_29; +goto block_19; +} +else +{ +lean_dec(x_20); +x_12 = x_21; +goto block_19; +} +} +else +{ +lean_object* x_30; lean_object* x_31; +lean_dec(x_24); +x_30 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; +x_31 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_30, x_20); +x_12 = x_31; +goto block_19; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_22); +x_32 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_21, x_32, x_20); +x_12 = x_33; +goto block_19; +} +block_19: +{ +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; +x_14 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_12); +x_15 = l_Lean_Parser_Term_byTactic___elambda__1___closed__2; +x_16 = l_Lean_Parser_ParserState_mkNode(x_14, x_15, x_11); +return x_16; +} +else +{ +lean_object* x_17; lean_object* x_18; +lean_dec(x_13); +lean_dec(x_1); +x_17 = l_Lean_Parser_Term_byTactic___elambda__1___closed__2; +x_18 = l_Lean_Parser_ParserState_mkNode(x_12, x_17, x_11); +return x_18; +} +} } else { -lean_object* x_13; lean_object* x_14; lean_dec(x_9); lean_dec(x_1); -x_13 = l_Lean_Parser_Term_byTactic___elambda__1___closed__2; -x_14 = l_Lean_Parser_ParserState_mkNode(x_8, x_13, x_7); -return x_14; -} +return x_8; } } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_30 = lean_ctor_get(x_2, 0); -lean_inc(x_30); -x_31 = lean_array_get_size(x_30); -lean_dec(x_30); -x_32 = lean_ctor_get(x_2, 1); -lean_inc(x_32); -lean_inc(x_1); -x_33 = lean_apply_2(x_4, x_1, x_2); -x_34 = lean_ctor_get(x_33, 3); +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_2, 0); lean_inc(x_34); -if (lean_obj_tag(x_34) == 0) -{ -lean_dec(x_32); -lean_dec(x_31); -lean_dec(x_1); -return x_33; -} -else -{ -lean_object* x_35; lean_object* x_36; uint8_t x_37; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); +x_35 = lean_array_get_size(x_34); lean_dec(x_34); -x_36 = lean_ctor_get(x_33, 1); +x_36 = lean_ctor_get(x_2, 1); lean_inc(x_36); -x_37 = lean_nat_dec_eq(x_36, x_32); -lean_dec(x_36); -if (x_37 == 0) +lean_inc(x_1); +x_37 = lean_apply_2(x_4, x_1, x_2); +x_38 = lean_ctor_get(x_37, 3); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) { +lean_dec(x_36); lean_dec(x_35); -lean_dec(x_32); -lean_dec(x_31); lean_dec(x_1); -return x_33; +return x_37; } else { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_51; lean_object* x_52; -lean_inc(x_32); -x_38 = l_Lean_Parser_ParserState_restore(x_33, x_31, x_32); -lean_dec(x_31); +lean_object* x_39; lean_object* x_40; uint8_t x_41; x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -x_40 = lean_array_get_size(x_39); +lean_dec(x_38); +x_40 = lean_ctor_get(x_37, 1); +lean_inc(x_40); +x_41 = lean_nat_dec_eq(x_40, x_36); +lean_dec(x_40); +if (x_41 == 0) +{ lean_dec(x_39); +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_1); +return x_37; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_inc(x_36); +x_42 = l_Lean_Parser_ParserState_restore(x_37, x_35, x_36); +lean_dec(x_35); +x_43 = l_Lean_Parser_Term_if___elambda__1___closed__11; +x_44 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_45 = l_Lean_Parser_checkRbpLtFn(x_43, 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) +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_47 = lean_ctor_get(x_45, 0); +lean_inc(x_47); +x_48 = lean_array_get_size(x_47); +lean_dec(x_47); +x_59 = lean_ctor_get(x_45, 1); +lean_inc(x_59); lean_inc(x_1); -x_51 = l_Lean_Parser_tokenFn(x_1, x_38); -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_byTactic___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_byTactic___elambda__1___closed__9; -lean_inc(x_32); -x_59 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_58, x_32); -x_41 = x_59; -goto block_50; -} -else -{ -x_41 = x_51; -goto block_50; -} -} -else -{ -lean_object* x_60; lean_object* x_61; -lean_dec(x_54); -x_60 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; -lean_inc(x_32); -x_61 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_60, x_32); -x_41 = x_61; -goto block_50; -} -} -else +x_60 = l_Lean_Parser_tokenFn(x_1, x_45); +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_dec(x_52); -x_62 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; -lean_inc(x_32); -x_63 = l_Lean_Parser_ParserState_mkErrorsAt(x_51, x_62, x_32); -x_41 = x_63; -goto block_50; -} -block_50: +x_62 = lean_ctor_get(x_60, 0); +lean_inc(x_62); +x_63 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_62); +lean_dec(x_62); +if (lean_obj_tag(x_63) == 2) { -lean_object* x_42; -x_42 = lean_ctor_get(x_41, 3); -lean_inc(x_42); -if (lean_obj_tag(x_42) == 0) +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_byTactic___elambda__1___closed__6; +x_66 = lean_string_dec_eq(x_64, x_65); +lean_dec(x_64); +if (x_66 == 0) { -lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; -x_43 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_41); -x_44 = l_Lean_Parser_Term_byTactic___elambda__1___closed__2; -x_45 = l_Lean_Parser_ParserState_mkNode(x_43, x_44, x_40); -x_46 = l_Lean_Parser_mergeOrElseErrors(x_45, x_35, x_32); -lean_dec(x_32); -return x_46; +lean_object* x_67; lean_object* x_68; +x_67 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; +x_68 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_67, x_59); +x_49 = x_68; +goto block_58; } else { -lean_object* x_47; lean_object* x_48; lean_object* x_49; -lean_dec(x_42); -lean_dec(x_1); -x_47 = l_Lean_Parser_Term_byTactic___elambda__1___closed__2; -x_48 = l_Lean_Parser_ParserState_mkNode(x_41, x_47, x_40); -x_49 = l_Lean_Parser_mergeOrElseErrors(x_48, x_35, x_32); -lean_dec(x_32); -return x_49; +lean_dec(x_59); +x_49 = x_60; +goto block_58; } } +else +{ +lean_object* x_69; lean_object* x_70; +lean_dec(x_63); +x_69 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; +x_70 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_69, x_59); +x_49 = x_70; +goto block_58; +} +} +else +{ +lean_object* x_71; lean_object* x_72; +lean_dec(x_61); +x_71 = l_Lean_Parser_Term_byTactic___elambda__1___closed__9; +x_72 = l_Lean_Parser_ParserState_mkErrorsAt(x_60, x_71, x_59); +x_49 = x_72; +goto block_58; +} +block_58: +{ +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_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_51 = l_Lean_Parser_Tactic_nonEmptySeq___elambda__1(x_1, x_49); +x_52 = l_Lean_Parser_Term_byTactic___elambda__1___closed__2; +x_53 = l_Lean_Parser_ParserState_mkNode(x_51, x_52, x_48); +x_54 = l_Lean_Parser_mergeOrElseErrors(x_53, x_39, x_36); +lean_dec(x_36); +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_Term_byTactic___elambda__1___closed__2; +x_56 = l_Lean_Parser_ParserState_mkNode(x_49, x_55, x_48); +x_57 = l_Lean_Parser_mergeOrElseErrors(x_56, x_39, x_36); +lean_dec(x_36); +return x_57; +} +} +} +else +{ +lean_object* x_73; +lean_dec(x_46); +lean_dec(x_1); +x_73 = l_Lean_Parser_mergeOrElseErrors(x_45, x_39, x_36); +lean_dec(x_36); +return x_73; +} } } } @@ -50856,11 +52600,10 @@ return x_49; lean_object* _init_l_Lean_Parser_Term_byTactic___closed__1() { _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_byTactic___elambda__1___closed__6; -x_2 = l_Lean_Parser_Term_if___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_byTactic___closed__2() { @@ -50888,16 +52631,26 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_byTactic___closed__4() { _start: { +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_byTactic___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Parser_Term_byTactic___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_byTactic___elambda__1___closed__4; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_byTactic___closed__3; +x_3 = l_Lean_Parser_Term_byTactic___closed__4; x_4 = l_Lean_Parser_orelseInfo(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Parser_Term_byTactic___closed__5() { +lean_object* _init_l_Lean_Parser_Term_byTactic___closed__6() { _start: { lean_object* x_1; @@ -50905,12 +52658,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_byTactic___elambda__1), 2, 0 return x_1; } } -lean_object* _init_l_Lean_Parser_Term_byTactic___closed__6() { +lean_object* _init_l_Lean_Parser_Term_byTactic___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_byTactic___closed__4; -x_2 = l_Lean_Parser_Term_byTactic___closed__5; +x_1 = l_Lean_Parser_Term_byTactic___closed__5; +x_2 = l_Lean_Parser_Term_byTactic___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); @@ -50921,7 +52674,7 @@ lean_object* _init_l_Lean_Parser_Term_byTactic() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_byTactic___closed__6; +x_1 = l_Lean_Parser_Term_byTactic___closed__7; return x_1; } } @@ -51007,174 +52760,188 @@ return x_3; lean_object* l_Lean_Parser_Term_tacticStxQuot___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_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); -if (lean_obj_tag(x_39) == 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); -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 (x_44 == 0) -{ -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_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_39); -x_49 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__7; -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; +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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_7; lean_object* x_8; lean_object* x_9; -x_7 = 1; +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_41; lean_object* x_42; lean_object* x_43; +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_41 = lean_ctor_get(x_5, 1); +lean_inc(x_41); lean_inc(x_1); -x_8 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_nonEmptySeq___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) +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; -x_10 = lean_ctor_get(x_8, 1); +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); +lean_dec(x_45); +x_47 = l_Lean_Parser_Term_tacticStxQuot___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_tacticStxQuot___elambda__1___closed__7; +x_50 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_49, x_41); +x_9 = x_50; +goto block_40; +} +else +{ +lean_dec(x_41); +x_9 = x_42; +goto block_40; +} +} +else +{ +lean_object* x_51; lean_object* x_52; +lean_dec(x_45); +x_51 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__7; +x_52 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_51, x_41); +x_9 = x_52; +goto block_40; +} +} +else +{ +lean_object* x_53; lean_object* x_54; +lean_dec(x_43); +x_53 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__7; +x_54 = l_Lean_Parser_ParserState_mkErrorsAt(x_42, x_53, x_41); +x_9 = x_54; +goto block_40; +} +block_40: +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_9, 3); 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) +if (lean_obj_tag(x_10) == 0) { -lean_object* x_13; lean_object* x_14; -x_13 = lean_ctor_get(x_11, 0); +uint8_t x_11; lean_object* x_12; lean_object* x_13; +x_11 = 1; +lean_inc(x_1); +x_12 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_nonEmptySeq___elambda__1___spec__1(x_11, x_11, x_1, x_9); +x_13 = lean_ctor_get(x_12, 3); 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) +if (lean_obj_tag(x_13) == 0) { -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_Lean_Parser_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_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +x_15 = l_Lean_Parser_tokenFn(x_1, x_12); +x_16 = lean_ctor_get(x_15, 3); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) { -lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; -x_18 = l_Lean_Parser_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; +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); +lean_dec(x_18); +x_20 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; +x_21 = lean_string_dec_eq(x_19, x_20); +lean_dec(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_23 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_22, x_14); +x_24 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_25 = l_Lean_Parser_ParserState_mkNode(x_23, x_24, x_8); +return x_25; } else { -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_11, x_22, x_4); -return x_23; -} -} -else -{ -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_object* x_26; lean_object* x_27; lean_dec(x_14); -x_24 = l_Lean_Parser_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); +x_27 = l_Lean_Parser_ParserState_mkNode(x_15, x_26, x_8); return x_27; } } else { lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_12); +lean_dec(x_18); x_28 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_11, x_28, x_10); +x_29 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_28, x_14); x_30 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_4); +x_31 = l_Lean_Parser_ParserState_mkNode(x_29, x_30, x_8); 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_8, x_32, x_4); -return x_33; +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_dec(x_16); +x_32 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_33 = l_Lean_Parser_ParserState_mkErrorsAt(x_15, x_32, x_14); +x_34 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_35 = l_Lean_Parser_ParserState_mkNode(x_33, x_34, x_8); +return x_35; +} +} +else +{ +lean_object* x_36; lean_object* x_37; +lean_dec(x_13); +lean_dec(x_1); +x_36 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_37 = l_Lean_Parser_ParserState_mkNode(x_12, x_36, x_8); +return x_37; +} +} +else +{ +lean_object* x_38; lean_object* x_39; +lean_dec(x_10); +lean_dec(x_1); +x_38 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_39 = l_Lean_Parser_ParserState_mkNode(x_9, x_38, x_8); +return x_39; +} } } else { -lean_object* x_34; lean_object* x_35; 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_5, x_34, x_4); -return x_35; -} +return x_5; } } } lean_object* _init_l_Lean_Parser_Term_tacticStxQuot___closed__1() { _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_tacticStxQuot___elambda__1___closed__4; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_tacticStxQuot___closed__2() { @@ -51182,7 +52949,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Tactic_nonEmptySeq___closed__1; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__4; +x_2 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); return x_3; } @@ -51210,17 +52977,27 @@ return x_3; 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), 2, 0); -return x_1; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_tacticStxQuot___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_tacticStxQuot___closed__6() { _start: { +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_tacticStxQuot___elambda__1), 2, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Parser_Term_tacticStxQuot___closed__7() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_tacticStxQuot___closed__4; -x_2 = l_Lean_Parser_Term_tacticStxQuot___closed__5; +x_1 = l_Lean_Parser_Term_tacticStxQuot___closed__5; +x_2 = l_Lean_Parser_Term_tacticStxQuot___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); @@ -51231,7 +53008,7 @@ lean_object* _init_l_Lean_Parser_Term_tacticStxQuot() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_tacticStxQuot___closed__6; +x_1 = l_Lean_Parser_Term_tacticStxQuot___closed__7; return x_1; } } @@ -51317,175 +53094,189 @@ return x_3; lean_object* l_Lean_Parser_Term_levelStxQuot___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_38; lean_object* x_39; lean_object* x_40; -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_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_levelStxQuot___elambda__1___closed__2; -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_levelStxQuot___elambda__1___closed__5; -x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_46, x_38); -x_5 = x_47; -goto block_37; -} -else -{ -lean_dec(x_38); -x_5 = x_39; -goto block_37; -} -} -else -{ -lean_object* x_48; lean_object* x_49; -lean_dec(x_42); -x_48 = l_Lean_Parser_Term_levelStxQuot___elambda__1___closed__5; -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_48, x_38); -x_5 = x_49; -goto block_37; -} -} -else -{ -lean_object* x_50; lean_object* x_51; -lean_dec(x_40); -x_50 = l_Lean_Parser_Term_levelStxQuot___elambda__1___closed__5; -x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_39, x_50, x_38); -x_5 = x_51; -goto block_37; -} -block_37: -{ -lean_object* x_6; +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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) { -lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; -x_7 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_8 = lean_unsigned_to_nat(0u); +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_42; lean_object* x_43; lean_object* x_44; +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_42 = lean_ctor_get(x_5, 1); +lean_inc(x_42); lean_inc(x_1); -x_9 = l_Lean_Parser_categoryParser___elambda__1(x_7, x_8, x_1, x_5); +x_43 = l_Lean_Parser_tokenFn(x_1, x_5); +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_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_dec(x_46); +x_48 = l_Lean_Parser_Term_levelStxQuot___elambda__1___closed__2; +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 = l_Lean_Parser_Term_levelStxQuot___elambda__1___closed__5; +x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_50, x_42); +x_9 = x_51; +goto block_41; +} +else +{ +lean_dec(x_42); +x_9 = x_43; +goto block_41; +} +} +else +{ +lean_object* x_52; lean_object* x_53; +lean_dec(x_46); +x_52 = l_Lean_Parser_Term_levelStxQuot___elambda__1___closed__5; +x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_52, x_42); +x_9 = x_53; +goto block_41; +} +} +else +{ +lean_object* x_54; lean_object* x_55; +lean_dec(x_44); +x_54 = l_Lean_Parser_Term_levelStxQuot___elambda__1___closed__5; +x_55 = l_Lean_Parser_ParserState_mkErrorsAt(x_43, x_54, x_42); +x_9 = x_55; +goto block_41; +} +block_41: +{ +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_object* x_13; -x_11 = lean_ctor_get(x_9, 1); -lean_inc(x_11); -x_12 = l_Lean_Parser_tokenFn(x_1, x_9); -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; -x_14 = lean_ctor_get(x_12, 0); +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; +x_12 = lean_unsigned_to_nat(0u); +lean_inc(x_1); +x_13 = l_Lean_Parser_categoryParser___elambda__1(x_11, x_12, x_1, x_9); +x_14 = lean_ctor_get(x_13, 3); lean_inc(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) +if (lean_obj_tag(x_14) == 0) { -lean_object* x_16; lean_object* x_17; uint8_t x_18; -x_16 = lean_ctor_get(x_15, 1); -lean_inc(x_16); -lean_dec(x_15); -x_17 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -x_18 = lean_string_dec_eq(x_16, x_17); -lean_dec(x_16); -if (x_18 == 0) +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_13, 1); +lean_inc(x_15); +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_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; -x_19 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_20 = l_Lean_Parser_ParserState_mkErrorsAt(x_12, x_19, x_11); -x_21 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_4); -return x_22; +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_checkStackTopFn___spec__1(x_18); +lean_dec(x_18); +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_antiquotNestedExpr___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; +x_23 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_23, x_15); +x_25 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_8); +return x_26; } else { -lean_object* x_23; lean_object* x_24; -lean_dec(x_11); -x_23 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_24 = l_Lean_Parser_ParserState_mkNode(x_12, x_23, x_4); -return x_24; -} -} -else -{ -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +lean_object* x_27; lean_object* x_28; lean_dec(x_15); -x_25 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_26 = l_Lean_Parser_ParserState_mkErrorsAt(x_12, x_25, x_11); x_27 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_28 = l_Lean_Parser_ParserState_mkNode(x_26, x_27, x_4); +x_28 = l_Lean_Parser_ParserState_mkNode(x_16, x_27, x_8); return x_28; } } else { lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; -lean_dec(x_13); +lean_dec(x_19); x_29 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_12, x_29, x_11); +x_30 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_29, x_15); x_31 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_4); +x_32 = l_Lean_Parser_ParserState_mkNode(x_30, x_31, x_8); return x_32; } } else { -lean_object* x_33; lean_object* x_34; -lean_dec(x_10); -lean_dec(x_1); -x_33 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_9, x_33, x_4); -return x_34; +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +lean_dec(x_17); +x_33 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_34 = l_Lean_Parser_ParserState_mkErrorsAt(x_16, x_33, x_15); +x_35 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_36 = l_Lean_Parser_ParserState_mkNode(x_34, x_35, x_8); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; +lean_dec(x_14); +lean_dec(x_1); +x_37 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_38 = l_Lean_Parser_ParserState_mkNode(x_13, x_37, x_8); +return x_38; +} +} +else +{ +lean_object* x_39; lean_object* x_40; +lean_dec(x_10); +lean_dec(x_1); +x_39 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_40 = l_Lean_Parser_ParserState_mkNode(x_9, x_39, x_8); +return x_40; +} } } else { -lean_object* x_35; lean_object* x_36; lean_dec(x_6); lean_dec(x_1); -x_35 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_36 = l_Lean_Parser_ParserState_mkNode(x_5, x_35, x_4); -return x_36; -} +return x_5; } } } lean_object* _init_l_Lean_Parser_Term_levelStxQuot___closed__1() { _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_levelStxQuot___elambda__1___closed__2; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_levelStxQuot___closed__2() { @@ -51511,17 +53302,27 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_levelStxQuot___closed__4() { _start: { -lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_levelStxQuot___elambda__1), 2, 0); -return x_1; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_levelStxQuot___closed__3; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_levelStxQuot___closed__5() { _start: { +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_levelStxQuot___elambda__1), 2, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Parser_Term_levelStxQuot___closed__6() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_levelStxQuot___closed__3; -x_2 = l_Lean_Parser_Term_levelStxQuot___closed__4; +x_1 = l_Lean_Parser_Term_levelStxQuot___closed__4; +x_2 = l_Lean_Parser_Term_levelStxQuot___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); @@ -51532,7 +53333,7 @@ lean_object* _init_l_Lean_Parser_Term_levelStxQuot() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_levelStxQuot___closed__5; +x_1 = l_Lean_Parser_Term_levelStxQuot___closed__6; return x_1; } } @@ -51618,173 +53419,187 @@ return x_3; lean_object* l_Lean_Parser_Term_funBinderStxQuot___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_36; 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_36 = lean_ctor_get(x_2, 1); -lean_inc(x_36); -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); -lean_dec(x_40); -x_42 = l_Lean_Parser_Term_funBinderStxQuot___elambda__1___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_Lean_Parser_Term_funBinderStxQuot___elambda__1___closed__5; -x_45 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_44, x_36); -x_5 = x_45; -goto block_35; -} -else -{ -lean_dec(x_36); -x_5 = x_37; -goto block_35; -} -} -else -{ -lean_object* x_46; lean_object* x_47; -lean_dec(x_40); -x_46 = l_Lean_Parser_Term_funBinderStxQuot___elambda__1___closed__5; -x_47 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_46, x_36); -x_5 = x_47; -goto block_35; -} -} -else -{ -lean_object* x_48; lean_object* x_49; -lean_dec(x_38); -x_48 = l_Lean_Parser_Term_funBinderStxQuot___elambda__1___closed__5; -x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_37, x_48, x_36); -x_5 = x_49; -goto block_35; -} -block_35: -{ -lean_object* x_6; +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = l_Lean_Parser_Level_paren___elambda__1___closed__7; +x_4 = l___private_Lean_Parser_Parser_10__precErrorMsg; +x_5 = l_Lean_Parser_checkRbpLtFn(x_3, 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) { -lean_object* x_7; lean_object* x_8; +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_40; lean_object* x_41; lean_object* x_42; +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_40 = lean_ctor_get(x_5, 1); +lean_inc(x_40); lean_inc(x_1); -x_7 = l_Lean_Parser_Term_funBinder___elambda__1(x_1, x_5); -x_8 = lean_ctor_get(x_7, 3); -lean_inc(x_8); -if (lean_obj_tag(x_8) == 0) +x_41 = l_Lean_Parser_tokenFn(x_1, x_5); +x_42 = lean_ctor_get(x_41, 3); +lean_inc(x_42); +if (lean_obj_tag(x_42) == 0) { -lean_object* x_9; lean_object* x_10; lean_object* x_11; -x_9 = lean_ctor_get(x_7, 1); -lean_inc(x_9); -x_10 = l_Lean_Parser_tokenFn(x_1, x_7); -x_11 = lean_ctor_get(x_10, 3); -lean_inc(x_11); -if (lean_obj_tag(x_11) == 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_12; lean_object* x_13; -x_12 = lean_ctor_get(x_10, 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_Term_funBinderStxQuot___elambda__1___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_Lean_Parser_Term_funBinderStxQuot___elambda__1___closed__5; +x_49 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_48, x_40); +x_9 = x_49; +goto block_39; +} +else +{ +lean_dec(x_40); +x_9 = x_41; +goto block_39; +} +} +else +{ +lean_object* x_50; lean_object* x_51; +lean_dec(x_44); +x_50 = l_Lean_Parser_Term_funBinderStxQuot___elambda__1___closed__5; +x_51 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_50, x_40); +x_9 = x_51; +goto block_39; +} +} +else +{ +lean_object* x_52; lean_object* x_53; +lean_dec(x_42); +x_52 = l_Lean_Parser_Term_funBinderStxQuot___elambda__1___closed__5; +x_53 = l_Lean_Parser_ParserState_mkErrorsAt(x_41, x_52, x_40); +x_9 = x_53; +goto block_39; +} +block_39: +{ +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_inc(x_1); +x_11 = l_Lean_Parser_Term_funBinder___elambda__1(x_1, x_9); +x_12 = lean_ctor_get(x_11, 3); lean_inc(x_12); -x_13 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_12); -lean_dec(x_12); -if (lean_obj_tag(x_13) == 2) +if (lean_obj_tag(x_12) == 0) { -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_Lean_Parser_antiquotNestedExpr___elambda__1___closed__4; -x_16 = lean_string_dec_eq(x_14, x_15); -lean_dec(x_14); -if (x_16 == 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_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; -x_17 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_18 = l_Lean_Parser_ParserState_mkErrorsAt(x_10, x_17, x_9); -x_19 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_20 = l_Lean_Parser_ParserState_mkNode(x_18, x_19, x_4); -return x_20; +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_Lean_Parser_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_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_22 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_21, x_13); +x_23 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_24 = l_Lean_Parser_ParserState_mkNode(x_22, x_23, x_8); +return x_24; } else { -lean_object* x_21; lean_object* x_22; -lean_dec(x_9); -x_21 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_22 = l_Lean_Parser_ParserState_mkNode(x_10, x_21, x_4); -return x_22; -} -} -else -{ -lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +lean_object* x_25; lean_object* x_26; lean_dec(x_13); -x_23 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_24 = l_Lean_Parser_ParserState_mkErrorsAt(x_10, x_23, x_9); x_25 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_26 = l_Lean_Parser_ParserState_mkNode(x_24, x_25, x_4); +x_26 = l_Lean_Parser_ParserState_mkNode(x_14, x_25, x_8); return x_26; } } else { lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; -lean_dec(x_11); +lean_dec(x_17); x_27 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; -x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_10, x_27, x_9); +x_28 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_27, x_13); x_29 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_4); +x_30 = l_Lean_Parser_ParserState_mkNode(x_28, x_29, x_8); return x_30; } } else { -lean_object* x_31; lean_object* x_32; -lean_dec(x_8); -lean_dec(x_1); -x_31 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_32 = l_Lean_Parser_ParserState_mkNode(x_7, x_31, x_4); -return x_32; +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_15); +x_31 = l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__7; +x_32 = l_Lean_Parser_ParserState_mkErrorsAt(x_14, x_31, x_13); +x_33 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_34 = l_Lean_Parser_ParserState_mkNode(x_32, x_33, x_8); +return x_34; +} +} +else +{ +lean_object* x_35; lean_object* x_36; +lean_dec(x_12); +lean_dec(x_1); +x_35 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_36 = l_Lean_Parser_ParserState_mkNode(x_11, x_35, x_8); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; +lean_dec(x_10); +lean_dec(x_1); +x_37 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; +x_38 = l_Lean_Parser_ParserState_mkNode(x_9, x_37, x_8); +return x_38; +} } } else { -lean_object* x_33; lean_object* x_34; lean_dec(x_6); lean_dec(x_1); -x_33 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; -x_34 = l_Lean_Parser_ParserState_mkNode(x_5, x_33, x_4); -return x_34; -} +return x_5; } } } lean_object* _init_l_Lean_Parser_Term_funBinderStxQuot___closed__1() { _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_funBinderStxQuot___elambda__1___closed__2; -x_2 = l_Lean_Parser_antiquotNestedExpr___closed__1; -x_3 = l_Lean_Parser_symbolInfo(x_1, x_2); -return x_3; +x_2 = l_Lean_Parser_symbolInfo(x_1); +return x_2; } } lean_object* _init_l_Lean_Parser_Term_funBinderStxQuot___closed__2() { @@ -51794,7 +53609,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_funBinder; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_antiquotNestedExpr___closed__4; +x_3 = l_Lean_Parser_antiquotNestedExpr___closed__3; x_4 = l_Lean_Parser_andthenInfo(x_2, x_3); return x_4; } @@ -51822,17 +53637,27 @@ return x_3; lean_object* _init_l_Lean_Parser_Term_funBinderStxQuot___closed__5() { _start: { -lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_funBinderStxQuot___elambda__1), 2, 0); -return x_1; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_epsilonInfo; +x_2 = l_Lean_Parser_Term_funBinderStxQuot___closed__4; +x_3 = l_Lean_Parser_andthenInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Term_funBinderStxQuot___closed__6() { _start: { +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Parser_Term_funBinderStxQuot___elambda__1), 2, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Parser_Term_funBinderStxQuot___closed__7() { +_start: +{ lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Term_funBinderStxQuot___closed__4; -x_2 = l_Lean_Parser_Term_funBinderStxQuot___closed__5; +x_1 = l_Lean_Parser_Term_funBinderStxQuot___closed__5; +x_2 = l_Lean_Parser_Term_funBinderStxQuot___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); @@ -51843,7 +53668,7 @@ lean_object* _init_l_Lean_Parser_Term_funBinderStxQuot() { _start: { lean_object* x_1; -x_1 = l_Lean_Parser_Term_funBinderStxQuot___closed__6; +x_1 = l_Lean_Parser_Term_funBinderStxQuot___closed__7; return x_1; } } @@ -52086,6 +53911,8 @@ l_Lean_Parser_Term_id___closed__6 = _init_l_Lean_Parser_Term_id___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_id___closed__6); l_Lean_Parser_Term_id___closed__7 = _init_l_Lean_Parser_Term_id___closed__7(); lean_mark_persistent(l_Lean_Parser_Term_id___closed__7); +l_Lean_Parser_Term_id___closed__8 = _init_l_Lean_Parser_Term_id___closed__8(); +lean_mark_persistent(l_Lean_Parser_Term_id___closed__8); l_Lean_Parser_Term_id = _init_l_Lean_Parser_Term_id(); lean_mark_persistent(l_Lean_Parser_Term_id); res = l___regBuiltinParser_Lean_Parser_Term_id(lean_io_mk_world()); @@ -52103,6 +53930,8 @@ l_Lean_Parser_Term_num___closed__3 = _init_l_Lean_Parser_Term_num___closed__3(); lean_mark_persistent(l_Lean_Parser_Term_num___closed__3); l_Lean_Parser_Term_num___closed__4 = _init_l_Lean_Parser_Term_num___closed__4(); lean_mark_persistent(l_Lean_Parser_Term_num___closed__4); +l_Lean_Parser_Term_num___closed__5 = _init_l_Lean_Parser_Term_num___closed__5(); +lean_mark_persistent(l_Lean_Parser_Term_num___closed__5); l_Lean_Parser_Term_num = _init_l_Lean_Parser_Term_num(); lean_mark_persistent(l_Lean_Parser_Term_num); res = l___regBuiltinParser_Lean_Parser_Term_num(lean_io_mk_world()); @@ -52120,6 +53949,8 @@ l_Lean_Parser_Term_str___closed__3 = _init_l_Lean_Parser_Term_str___closed__3(); lean_mark_persistent(l_Lean_Parser_Term_str___closed__3); l_Lean_Parser_Term_str___closed__4 = _init_l_Lean_Parser_Term_str___closed__4(); lean_mark_persistent(l_Lean_Parser_Term_str___closed__4); +l_Lean_Parser_Term_str___closed__5 = _init_l_Lean_Parser_Term_str___closed__5(); +lean_mark_persistent(l_Lean_Parser_Term_str___closed__5); l_Lean_Parser_Term_str = _init_l_Lean_Parser_Term_str(); lean_mark_persistent(l_Lean_Parser_Term_str); res = l___regBuiltinParser_Lean_Parser_Term_str(lean_io_mk_world()); @@ -52141,6 +53972,8 @@ l_Lean_Parser_Term_char___closed__3 = _init_l_Lean_Parser_Term_char___closed__3( lean_mark_persistent(l_Lean_Parser_Term_char___closed__3); l_Lean_Parser_Term_char___closed__4 = _init_l_Lean_Parser_Term_char___closed__4(); lean_mark_persistent(l_Lean_Parser_Term_char___closed__4); +l_Lean_Parser_Term_char___closed__5 = _init_l_Lean_Parser_Term_char___closed__5(); +lean_mark_persistent(l_Lean_Parser_Term_char___closed__5); l_Lean_Parser_Term_char = _init_l_Lean_Parser_Term_char(); lean_mark_persistent(l_Lean_Parser_Term_char); res = l___regBuiltinParser_Lean_Parser_Term_char(lean_io_mk_world()); @@ -52180,6 +54013,8 @@ l_Lean_Parser_Term_type___closed__7 = _init_l_Lean_Parser_Term_type___closed__7( lean_mark_persistent(l_Lean_Parser_Term_type___closed__7); l_Lean_Parser_Term_type___closed__8 = _init_l_Lean_Parser_Term_type___closed__8(); lean_mark_persistent(l_Lean_Parser_Term_type___closed__8); +l_Lean_Parser_Term_type___closed__9 = _init_l_Lean_Parser_Term_type___closed__9(); +lean_mark_persistent(l_Lean_Parser_Term_type___closed__9); l_Lean_Parser_Term_type = _init_l_Lean_Parser_Term_type(); lean_mark_persistent(l_Lean_Parser_Term_type); res = l___regBuiltinParser_Lean_Parser_Term_type(lean_io_mk_world()); @@ -52215,6 +54050,8 @@ l_Lean_Parser_Term_sort___closed__5 = _init_l_Lean_Parser_Term_sort___closed__5( lean_mark_persistent(l_Lean_Parser_Term_sort___closed__5); l_Lean_Parser_Term_sort___closed__6 = _init_l_Lean_Parser_Term_sort___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_sort___closed__6); +l_Lean_Parser_Term_sort___closed__7 = _init_l_Lean_Parser_Term_sort___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_sort___closed__7); l_Lean_Parser_Term_sort = _init_l_Lean_Parser_Term_sort(); lean_mark_persistent(l_Lean_Parser_Term_sort); res = l___regBuiltinParser_Lean_Parser_Term_sort(lean_io_mk_world()); @@ -52248,6 +54085,8 @@ l_Lean_Parser_Term_prop___closed__4 = _init_l_Lean_Parser_Term_prop___closed__4( lean_mark_persistent(l_Lean_Parser_Term_prop___closed__4); l_Lean_Parser_Term_prop___closed__5 = _init_l_Lean_Parser_Term_prop___closed__5(); lean_mark_persistent(l_Lean_Parser_Term_prop___closed__5); +l_Lean_Parser_Term_prop___closed__6 = _init_l_Lean_Parser_Term_prop___closed__6(); +lean_mark_persistent(l_Lean_Parser_Term_prop___closed__6); l_Lean_Parser_Term_prop = _init_l_Lean_Parser_Term_prop(); lean_mark_persistent(l_Lean_Parser_Term_prop); res = l___regBuiltinParser_Lean_Parser_Term_prop(lean_io_mk_world()); @@ -52265,6 +54104,8 @@ l_Lean_Parser_Term_hole___closed__3 = _init_l_Lean_Parser_Term_hole___closed__3( lean_mark_persistent(l_Lean_Parser_Term_hole___closed__3); l_Lean_Parser_Term_hole___closed__4 = _init_l_Lean_Parser_Term_hole___closed__4(); lean_mark_persistent(l_Lean_Parser_Term_hole___closed__4); +l_Lean_Parser_Term_hole___closed__5 = _init_l_Lean_Parser_Term_hole___closed__5(); +lean_mark_persistent(l_Lean_Parser_Term_hole___closed__5); l_Lean_Parser_Term_hole = _init_l_Lean_Parser_Term_hole(); lean_mark_persistent(l_Lean_Parser_Term_hole); res = l___regBuiltinParser_Lean_Parser_Term_hole(lean_io_mk_world()); @@ -52298,6 +54139,8 @@ l_Lean_Parser_Term_namedHole___closed__5 = _init_l_Lean_Parser_Term_namedHole___ lean_mark_persistent(l_Lean_Parser_Term_namedHole___closed__5); l_Lean_Parser_Term_namedHole___closed__6 = _init_l_Lean_Parser_Term_namedHole___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_namedHole___closed__6); +l_Lean_Parser_Term_namedHole___closed__7 = _init_l_Lean_Parser_Term_namedHole___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_namedHole___closed__7); l_Lean_Parser_Term_namedHole = _init_l_Lean_Parser_Term_namedHole(); lean_mark_persistent(l_Lean_Parser_Term_namedHole); res = l___regBuiltinParser_Lean_Parser_Term_namedHole(lean_io_mk_world()); @@ -52329,6 +54172,8 @@ l_Lean_Parser_Term_sorry___closed__4 = _init_l_Lean_Parser_Term_sorry___closed__ lean_mark_persistent(l_Lean_Parser_Term_sorry___closed__4); l_Lean_Parser_Term_sorry___closed__5 = _init_l_Lean_Parser_Term_sorry___closed__5(); lean_mark_persistent(l_Lean_Parser_Term_sorry___closed__5); +l_Lean_Parser_Term_sorry___closed__6 = _init_l_Lean_Parser_Term_sorry___closed__6(); +lean_mark_persistent(l_Lean_Parser_Term_sorry___closed__6); l_Lean_Parser_Term_sorry = _init_l_Lean_Parser_Term_sorry(); lean_mark_persistent(l_Lean_Parser_Term_sorry); res = l___regBuiltinParser_Lean_Parser_Term_sorry(lean_io_mk_world()); @@ -52362,6 +54207,8 @@ l_Lean_Parser_Term_cdot___closed__4 = _init_l_Lean_Parser_Term_cdot___closed__4( lean_mark_persistent(l_Lean_Parser_Term_cdot___closed__4); l_Lean_Parser_Term_cdot___closed__5 = _init_l_Lean_Parser_Term_cdot___closed__5(); lean_mark_persistent(l_Lean_Parser_Term_cdot___closed__5); +l_Lean_Parser_Term_cdot___closed__6 = _init_l_Lean_Parser_Term_cdot___closed__6(); +lean_mark_persistent(l_Lean_Parser_Term_cdot___closed__6); l_Lean_Parser_Term_cdot = _init_l_Lean_Parser_Term_cdot(); lean_mark_persistent(l_Lean_Parser_Term_cdot); res = l___regBuiltinParser_Lean_Parser_Term_cdot(lean_io_mk_world()); @@ -52395,6 +54242,8 @@ l_Lean_Parser_Term_emptyC___closed__4 = _init_l_Lean_Parser_Term_emptyC___closed lean_mark_persistent(l_Lean_Parser_Term_emptyC___closed__4); l_Lean_Parser_Term_emptyC___closed__5 = _init_l_Lean_Parser_Term_emptyC___closed__5(); lean_mark_persistent(l_Lean_Parser_Term_emptyC___closed__5); +l_Lean_Parser_Term_emptyC___closed__6 = _init_l_Lean_Parser_Term_emptyC___closed__6(); +lean_mark_persistent(l_Lean_Parser_Term_emptyC___closed__6); l_Lean_Parser_Term_emptyC = _init_l_Lean_Parser_Term_emptyC(); lean_mark_persistent(l_Lean_Parser_Term_emptyC); res = l___regBuiltinParser_Lean_Parser_Term_emptyC(lean_io_mk_world()); @@ -52484,6 +54333,8 @@ l_Lean_Parser_Term_paren___closed__7 = _init_l_Lean_Parser_Term_paren___closed__ lean_mark_persistent(l_Lean_Parser_Term_paren___closed__7); l_Lean_Parser_Term_paren___closed__8 = _init_l_Lean_Parser_Term_paren___closed__8(); lean_mark_persistent(l_Lean_Parser_Term_paren___closed__8); +l_Lean_Parser_Term_paren___closed__9 = _init_l_Lean_Parser_Term_paren___closed__9(); +lean_mark_persistent(l_Lean_Parser_Term_paren___closed__9); l_Lean_Parser_Term_paren = _init_l_Lean_Parser_Term_paren(); lean_mark_persistent(l_Lean_Parser_Term_paren); res = l___regBuiltinParser_Lean_Parser_Term_paren(lean_io_mk_world()); @@ -52531,6 +54382,8 @@ l_Lean_Parser_Term_anonymousCtor___closed__8 = _init_l_Lean_Parser_Term_anonymou lean_mark_persistent(l_Lean_Parser_Term_anonymousCtor___closed__8); l_Lean_Parser_Term_anonymousCtor___closed__9 = _init_l_Lean_Parser_Term_anonymousCtor___closed__9(); lean_mark_persistent(l_Lean_Parser_Term_anonymousCtor___closed__9); +l_Lean_Parser_Term_anonymousCtor___closed__10 = _init_l_Lean_Parser_Term_anonymousCtor___closed__10(); +lean_mark_persistent(l_Lean_Parser_Term_anonymousCtor___closed__10); l_Lean_Parser_Term_anonymousCtor = _init_l_Lean_Parser_Term_anonymousCtor(); lean_mark_persistent(l_Lean_Parser_Term_anonymousCtor); res = l___regBuiltinParser_Lean_Parser_Term_anonymousCtor(lean_io_mk_world()); @@ -52721,6 +54574,8 @@ l_Lean_Parser_Term_have___closed__10 = _init_l_Lean_Parser_Term_have___closed__1 lean_mark_persistent(l_Lean_Parser_Term_have___closed__10); l_Lean_Parser_Term_have___closed__11 = _init_l_Lean_Parser_Term_have___closed__11(); lean_mark_persistent(l_Lean_Parser_Term_have___closed__11); +l_Lean_Parser_Term_have___closed__12 = _init_l_Lean_Parser_Term_have___closed__12(); +lean_mark_persistent(l_Lean_Parser_Term_have___closed__12); l_Lean_Parser_Term_have = _init_l_Lean_Parser_Term_have(); lean_mark_persistent(l_Lean_Parser_Term_have); res = l___regBuiltinParser_Lean_Parser_Term_have(lean_io_mk_world()); @@ -52762,6 +54617,8 @@ l_Lean_Parser_Term_suffices___closed__8 = _init_l_Lean_Parser_Term_suffices___cl lean_mark_persistent(l_Lean_Parser_Term_suffices___closed__8); l_Lean_Parser_Term_suffices___closed__9 = _init_l_Lean_Parser_Term_suffices___closed__9(); lean_mark_persistent(l_Lean_Parser_Term_suffices___closed__9); +l_Lean_Parser_Term_suffices___closed__10 = _init_l_Lean_Parser_Term_suffices___closed__10(); +lean_mark_persistent(l_Lean_Parser_Term_suffices___closed__10); l_Lean_Parser_Term_suffices = _init_l_Lean_Parser_Term_suffices(); lean_mark_persistent(l_Lean_Parser_Term_suffices); res = l___regBuiltinParser_Lean_Parser_Term_suffices(lean_io_mk_world()); @@ -52799,6 +54656,8 @@ l_Lean_Parser_Term_show___closed__6 = _init_l_Lean_Parser_Term_show___closed__6( lean_mark_persistent(l_Lean_Parser_Term_show___closed__6); l_Lean_Parser_Term_show___closed__7 = _init_l_Lean_Parser_Term_show___closed__7(); lean_mark_persistent(l_Lean_Parser_Term_show___closed__7); +l_Lean_Parser_Term_show___closed__8 = _init_l_Lean_Parser_Term_show___closed__8(); +lean_mark_persistent(l_Lean_Parser_Term_show___closed__8); l_Lean_Parser_Term_show = _init_l_Lean_Parser_Term_show(); lean_mark_persistent(l_Lean_Parser_Term_show); res = l___regBuiltinParser_Lean_Parser_Term_show(lean_io_mk_world()); @@ -52968,6 +54827,8 @@ l_Lean_Parser_Term_structInst___closed__17 = _init_l_Lean_Parser_Term_structInst lean_mark_persistent(l_Lean_Parser_Term_structInst___closed__17); l_Lean_Parser_Term_structInst___closed__18 = _init_l_Lean_Parser_Term_structInst___closed__18(); lean_mark_persistent(l_Lean_Parser_Term_structInst___closed__18); +l_Lean_Parser_Term_structInst___closed__19 = _init_l_Lean_Parser_Term_structInst___closed__19(); +lean_mark_persistent(l_Lean_Parser_Term_structInst___closed__19); l_Lean_Parser_Term_structInst = _init_l_Lean_Parser_Term_structInst(); lean_mark_persistent(l_Lean_Parser_Term_structInst); res = l___regBuiltinParser_Lean_Parser_Term_structInst(lean_io_mk_world()); @@ -53037,6 +54898,8 @@ l_Lean_Parser_Term_subtype___closed__9 = _init_l_Lean_Parser_Term_subtype___clos lean_mark_persistent(l_Lean_Parser_Term_subtype___closed__9); l_Lean_Parser_Term_subtype___closed__10 = _init_l_Lean_Parser_Term_subtype___closed__10(); lean_mark_persistent(l_Lean_Parser_Term_subtype___closed__10); +l_Lean_Parser_Term_subtype___closed__11 = _init_l_Lean_Parser_Term_subtype___closed__11(); +lean_mark_persistent(l_Lean_Parser_Term_subtype___closed__11); l_Lean_Parser_Term_subtype = _init_l_Lean_Parser_Term_subtype(); lean_mark_persistent(l_Lean_Parser_Term_subtype); res = l___regBuiltinParser_Lean_Parser_Term_subtype(lean_io_mk_world()); @@ -53074,6 +54937,8 @@ l_Lean_Parser_Term_listLit___closed__7 = _init_l_Lean_Parser_Term_listLit___clos lean_mark_persistent(l_Lean_Parser_Term_listLit___closed__7); l_Lean_Parser_Term_listLit___closed__8 = _init_l_Lean_Parser_Term_listLit___closed__8(); lean_mark_persistent(l_Lean_Parser_Term_listLit___closed__8); +l_Lean_Parser_Term_listLit___closed__9 = _init_l_Lean_Parser_Term_listLit___closed__9(); +lean_mark_persistent(l_Lean_Parser_Term_listLit___closed__9); l_Lean_Parser_Term_listLit = _init_l_Lean_Parser_Term_listLit(); lean_mark_persistent(l_Lean_Parser_Term_listLit); res = l___regBuiltinParser_Lean_Parser_Term_listLit(lean_io_mk_world()); @@ -53107,6 +54972,8 @@ l_Lean_Parser_Term_arrayLit___closed__5 = _init_l_Lean_Parser_Term_arrayLit___cl lean_mark_persistent(l_Lean_Parser_Term_arrayLit___closed__5); l_Lean_Parser_Term_arrayLit___closed__6 = _init_l_Lean_Parser_Term_arrayLit___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_arrayLit___closed__6); +l_Lean_Parser_Term_arrayLit___closed__7 = _init_l_Lean_Parser_Term_arrayLit___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_arrayLit___closed__7); l_Lean_Parser_Term_arrayLit = _init_l_Lean_Parser_Term_arrayLit(); lean_mark_persistent(l_Lean_Parser_Term_arrayLit); res = l___regBuiltinParser_Lean_Parser_Term_arrayLit(lean_io_mk_world()); @@ -53128,6 +54995,8 @@ l_Lean_Parser_Term_explicit___closed__3 = _init_l_Lean_Parser_Term_explicit___cl lean_mark_persistent(l_Lean_Parser_Term_explicit___closed__3); l_Lean_Parser_Term_explicit___closed__4 = _init_l_Lean_Parser_Term_explicit___closed__4(); lean_mark_persistent(l_Lean_Parser_Term_explicit___closed__4); +l_Lean_Parser_Term_explicit___closed__5 = _init_l_Lean_Parser_Term_explicit___closed__5(); +lean_mark_persistent(l_Lean_Parser_Term_explicit___closed__5); l_Lean_Parser_Term_explicit = _init_l_Lean_Parser_Term_explicit(); lean_mark_persistent(l_Lean_Parser_Term_explicit); res = l___regBuiltinParser_Lean_Parser_Term_explicit(lean_io_mk_world()); @@ -53163,6 +55032,8 @@ l_Lean_Parser_Term_inaccessible___closed__5 = _init_l_Lean_Parser_Term_inaccessi lean_mark_persistent(l_Lean_Parser_Term_inaccessible___closed__5); l_Lean_Parser_Term_inaccessible___closed__6 = _init_l_Lean_Parser_Term_inaccessible___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_inaccessible___closed__6); +l_Lean_Parser_Term_inaccessible___closed__7 = _init_l_Lean_Parser_Term_inaccessible___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_inaccessible___closed__7); l_Lean_Parser_Term_inaccessible = _init_l_Lean_Parser_Term_inaccessible(); lean_mark_persistent(l_Lean_Parser_Term_inaccessible); res = l___regBuiltinParser_Lean_Parser_Term_inaccessible(lean_io_mk_world()); @@ -53330,8 +55201,6 @@ l_Lean_Parser_Term_depArrow___elambda__1___closed__14 = _init_l_Lean_Parser_Term lean_mark_persistent(l_Lean_Parser_Term_depArrow___elambda__1___closed__14); l_Lean_Parser_Term_depArrow___elambda__1___closed__15 = _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__15(); lean_mark_persistent(l_Lean_Parser_Term_depArrow___elambda__1___closed__15); -l_Lean_Parser_Term_depArrow___elambda__1___closed__16 = _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__16(); -lean_mark_persistent(l_Lean_Parser_Term_depArrow___elambda__1___closed__16); l_Lean_Parser_Term_depArrow___closed__1 = _init_l_Lean_Parser_Term_depArrow___closed__1(); lean_mark_persistent(l_Lean_Parser_Term_depArrow___closed__1); l_Lean_Parser_Term_depArrow___closed__2 = _init_l_Lean_Parser_Term_depArrow___closed__2(); @@ -53348,6 +55217,8 @@ l_Lean_Parser_Term_depArrow___closed__7 = _init_l_Lean_Parser_Term_depArrow___cl lean_mark_persistent(l_Lean_Parser_Term_depArrow___closed__7); l_Lean_Parser_Term_depArrow___closed__8 = _init_l_Lean_Parser_Term_depArrow___closed__8(); lean_mark_persistent(l_Lean_Parser_Term_depArrow___closed__8); +l_Lean_Parser_Term_depArrow___closed__9 = _init_l_Lean_Parser_Term_depArrow___closed__9(); +lean_mark_persistent(l_Lean_Parser_Term_depArrow___closed__9); l_Lean_Parser_Term_depArrow = _init_l_Lean_Parser_Term_depArrow(); lean_mark_persistent(l_Lean_Parser_Term_depArrow); res = l___regBuiltinParser_Lean_Parser_Term_depArrow(lean_io_mk_world()); @@ -53397,8 +55268,6 @@ l_Lean_Parser_Term_forall___elambda__1___closed__11 = _init_l_Lean_Parser_Term_f lean_mark_persistent(l_Lean_Parser_Term_forall___elambda__1___closed__11); l_Lean_Parser_Term_forall___elambda__1___closed__12 = _init_l_Lean_Parser_Term_forall___elambda__1___closed__12(); lean_mark_persistent(l_Lean_Parser_Term_forall___elambda__1___closed__12); -l_Lean_Parser_Term_forall___elambda__1___closed__13 = _init_l_Lean_Parser_Term_forall___elambda__1___closed__13(); -lean_mark_persistent(l_Lean_Parser_Term_forall___elambda__1___closed__13); l_Lean_Parser_Term_forall___closed__1 = _init_l_Lean_Parser_Term_forall___closed__1(); lean_mark_persistent(l_Lean_Parser_Term_forall___closed__1); l_Lean_Parser_Term_forall___closed__2 = _init_l_Lean_Parser_Term_forall___closed__2(); @@ -53417,6 +55286,8 @@ l_Lean_Parser_Term_forall___closed__8 = _init_l_Lean_Parser_Term_forall___closed lean_mark_persistent(l_Lean_Parser_Term_forall___closed__8); l_Lean_Parser_Term_forall___closed__9 = _init_l_Lean_Parser_Term_forall___closed__9(); lean_mark_persistent(l_Lean_Parser_Term_forall___closed__9); +l_Lean_Parser_Term_forall___closed__10 = _init_l_Lean_Parser_Term_forall___closed__10(); +lean_mark_persistent(l_Lean_Parser_Term_forall___closed__10); l_Lean_Parser_Term_forall = _init_l_Lean_Parser_Term_forall(); lean_mark_persistent(l_Lean_Parser_Term_forall); res = l___regBuiltinParser_Lean_Parser_Term_forall(lean_io_mk_world()); @@ -53474,6 +55345,8 @@ l_Lean_Parser_Term_fun___closed__7 = _init_l_Lean_Parser_Term_fun___closed__7(); lean_mark_persistent(l_Lean_Parser_Term_fun___closed__7); l_Lean_Parser_Term_fun___closed__8 = _init_l_Lean_Parser_Term_fun___closed__8(); lean_mark_persistent(l_Lean_Parser_Term_fun___closed__8); +l_Lean_Parser_Term_fun___closed__9 = _init_l_Lean_Parser_Term_fun___closed__9(); +lean_mark_persistent(l_Lean_Parser_Term_fun___closed__9); l_Lean_Parser_Term_fun = _init_l_Lean_Parser_Term_fun(); lean_mark_persistent(l_Lean_Parser_Term_fun); res = l___regBuiltinParser_Lean_Parser_Term_fun(lean_io_mk_world()); @@ -53577,6 +55450,8 @@ l_Lean_Parser_Term_match___closed__9 = _init_l_Lean_Parser_Term_match___closed__ lean_mark_persistent(l_Lean_Parser_Term_match___closed__9); l_Lean_Parser_Term_match___closed__10 = _init_l_Lean_Parser_Term_match___closed__10(); lean_mark_persistent(l_Lean_Parser_Term_match___closed__10); +l_Lean_Parser_Term_match___closed__11 = _init_l_Lean_Parser_Term_match___closed__11(); +lean_mark_persistent(l_Lean_Parser_Term_match___closed__11); l_Lean_Parser_Term_match = _init_l_Lean_Parser_Term_match(); lean_mark_persistent(l_Lean_Parser_Term_match); res = l___regBuiltinParser_Lean_Parser_Term_match(lean_io_mk_world()); @@ -53612,6 +55487,8 @@ l_Lean_Parser_Term_nomatch___closed__5 = _init_l_Lean_Parser_Term_nomatch___clos lean_mark_persistent(l_Lean_Parser_Term_nomatch___closed__5); l_Lean_Parser_Term_nomatch___closed__6 = _init_l_Lean_Parser_Term_nomatch___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_nomatch___closed__6); +l_Lean_Parser_Term_nomatch___closed__7 = _init_l_Lean_Parser_Term_nomatch___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_nomatch___closed__7); l_Lean_Parser_Term_nomatch = _init_l_Lean_Parser_Term_nomatch(); lean_mark_persistent(l_Lean_Parser_Term_nomatch); res = l___regBuiltinParser_Lean_Parser_Term_nomatch(lean_io_mk_world()); @@ -53647,6 +55524,8 @@ l_Lean_Parser_Term_parser_x21___closed__5 = _init_l_Lean_Parser_Term_parser_x21_ lean_mark_persistent(l_Lean_Parser_Term_parser_x21___closed__5); l_Lean_Parser_Term_parser_x21___closed__6 = _init_l_Lean_Parser_Term_parser_x21___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_parser_x21___closed__6); +l_Lean_Parser_Term_parser_x21___closed__7 = _init_l_Lean_Parser_Term_parser_x21___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_parser_x21___closed__7); l_Lean_Parser_Term_parser_x21 = _init_l_Lean_Parser_Term_parser_x21(); lean_mark_persistent(l_Lean_Parser_Term_parser_x21); res = l___regBuiltinParser_Lean_Parser_Term_parser_x21(lean_io_mk_world()); @@ -53682,6 +55561,8 @@ l_Lean_Parser_Term_tparser_x21___closed__5 = _init_l_Lean_Parser_Term_tparser_x2 lean_mark_persistent(l_Lean_Parser_Term_tparser_x21___closed__5); l_Lean_Parser_Term_tparser_x21___closed__6 = _init_l_Lean_Parser_Term_tparser_x21___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_tparser_x21___closed__6); +l_Lean_Parser_Term_tparser_x21___closed__7 = _init_l_Lean_Parser_Term_tparser_x21___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_tparser_x21___closed__7); l_Lean_Parser_Term_tparser_x21 = _init_l_Lean_Parser_Term_tparser_x21(); lean_mark_persistent(l_Lean_Parser_Term_tparser_x21); res = l___regBuiltinParser_Lean_Parser_Term_tparser_x21(lean_io_mk_world()); @@ -53719,6 +55600,8 @@ l_Lean_Parser_Term_borrowed___closed__6 = _init_l_Lean_Parser_Term_borrowed___cl lean_mark_persistent(l_Lean_Parser_Term_borrowed___closed__6); l_Lean_Parser_Term_borrowed___closed__7 = _init_l_Lean_Parser_Term_borrowed___closed__7(); lean_mark_persistent(l_Lean_Parser_Term_borrowed___closed__7); +l_Lean_Parser_Term_borrowed___closed__8 = _init_l_Lean_Parser_Term_borrowed___closed__8(); +lean_mark_persistent(l_Lean_Parser_Term_borrowed___closed__8); l_Lean_Parser_Term_borrowed = _init_l_Lean_Parser_Term_borrowed(); lean_mark_persistent(l_Lean_Parser_Term_borrowed); res = l___regBuiltinParser_Lean_Parser_Term_borrowed(lean_io_mk_world()); @@ -53740,6 +55623,8 @@ l_Lean_Parser_Term_quotedName___closed__3 = _init_l_Lean_Parser_Term_quotedName_ lean_mark_persistent(l_Lean_Parser_Term_quotedName___closed__3); l_Lean_Parser_Term_quotedName___closed__4 = _init_l_Lean_Parser_Term_quotedName___closed__4(); lean_mark_persistent(l_Lean_Parser_Term_quotedName___closed__4); +l_Lean_Parser_Term_quotedName___closed__5 = _init_l_Lean_Parser_Term_quotedName___closed__5(); +lean_mark_persistent(l_Lean_Parser_Term_quotedName___closed__5); l_Lean_Parser_Term_quotedName = _init_l_Lean_Parser_Term_quotedName(); lean_mark_persistent(l_Lean_Parser_Term_quotedName); res = l___regBuiltinParser_Lean_Parser_Term_quotedName(lean_io_mk_world()); @@ -53775,6 +55660,8 @@ l_Lean_Parser_Term_match__syntax___closed__6 = _init_l_Lean_Parser_Term_match__s lean_mark_persistent(l_Lean_Parser_Term_match__syntax___closed__6); l_Lean_Parser_Term_match__syntax___closed__7 = _init_l_Lean_Parser_Term_match__syntax___closed__7(); lean_mark_persistent(l_Lean_Parser_Term_match__syntax___closed__7); +l_Lean_Parser_Term_match__syntax___closed__8 = _init_l_Lean_Parser_Term_match__syntax___closed__8(); +lean_mark_persistent(l_Lean_Parser_Term_match__syntax___closed__8); l_Lean_Parser_Term_match__syntax = _init_l_Lean_Parser_Term_match__syntax(); lean_mark_persistent(l_Lean_Parser_Term_match__syntax); res = l___regBuiltinParser_Lean_Parser_Term_match__syntax(lean_io_mk_world()); @@ -53890,6 +55777,8 @@ l_Lean_Parser_Term_let___closed__7 = _init_l_Lean_Parser_Term_let___closed__7(); lean_mark_persistent(l_Lean_Parser_Term_let___closed__7); l_Lean_Parser_Term_let___closed__8 = _init_l_Lean_Parser_Term_let___closed__8(); lean_mark_persistent(l_Lean_Parser_Term_let___closed__8); +l_Lean_Parser_Term_let___closed__9 = _init_l_Lean_Parser_Term_let___closed__9(); +lean_mark_persistent(l_Lean_Parser_Term_let___closed__9); l_Lean_Parser_Term_let = _init_l_Lean_Parser_Term_let(); lean_mark_persistent(l_Lean_Parser_Term_let); res = l___regBuiltinParser_Lean_Parser_Term_let(lean_io_mk_world()); @@ -53925,6 +55814,8 @@ l_Lean_Parser_Term_let_x21___closed__5 = _init_l_Lean_Parser_Term_let_x21___clos lean_mark_persistent(l_Lean_Parser_Term_let_x21___closed__5); l_Lean_Parser_Term_let_x21___closed__6 = _init_l_Lean_Parser_Term_let_x21___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_let_x21___closed__6); +l_Lean_Parser_Term_let_x21___closed__7 = _init_l_Lean_Parser_Term_let_x21___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_let_x21___closed__7); l_Lean_Parser_Term_let_x21 = _init_l_Lean_Parser_Term_let_x21(); lean_mark_persistent(l_Lean_Parser_Term_let_x21); res = l___regBuiltinParser_Lean_Parser_Term_let_x21(lean_io_mk_world()); @@ -54098,6 +55989,8 @@ l_Lean_Parser_Term_bracketedDoSeq___closed__5 = _init_l_Lean_Parser_Term_bracket lean_mark_persistent(l_Lean_Parser_Term_bracketedDoSeq___closed__5); l_Lean_Parser_Term_bracketedDoSeq___closed__6 = _init_l_Lean_Parser_Term_bracketedDoSeq___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_bracketedDoSeq___closed__6); +l_Lean_Parser_Term_bracketedDoSeq___closed__7 = _init_l_Lean_Parser_Term_bracketedDoSeq___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_bracketedDoSeq___closed__7); l_Lean_Parser_Term_bracketedDoSeq = _init_l_Lean_Parser_Term_bracketedDoSeq(); lean_mark_persistent(l_Lean_Parser_Term_bracketedDoSeq); l_Lean_Parser_Term_liftMethod___elambda__1___closed__1 = _init_l_Lean_Parser_Term_liftMethod___elambda__1___closed__1(); @@ -54118,6 +56011,8 @@ l_Lean_Parser_Term_liftMethod___closed__4 = _init_l_Lean_Parser_Term_liftMethod_ lean_mark_persistent(l_Lean_Parser_Term_liftMethod___closed__4); l_Lean_Parser_Term_liftMethod___closed__5 = _init_l_Lean_Parser_Term_liftMethod___closed__5(); lean_mark_persistent(l_Lean_Parser_Term_liftMethod___closed__5); +l_Lean_Parser_Term_liftMethod___closed__6 = _init_l_Lean_Parser_Term_liftMethod___closed__6(); +lean_mark_persistent(l_Lean_Parser_Term_liftMethod___closed__6); l_Lean_Parser_Term_liftMethod = _init_l_Lean_Parser_Term_liftMethod(); lean_mark_persistent(l_Lean_Parser_Term_liftMethod); res = l___regBuiltinParser_Lean_Parser_Term_liftMethod(lean_io_mk_world()); @@ -54155,6 +56050,8 @@ l_Lean_Parser_Term_do___closed__6 = _init_l_Lean_Parser_Term_do___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_do___closed__6); l_Lean_Parser_Term_do___closed__7 = _init_l_Lean_Parser_Term_do___closed__7(); lean_mark_persistent(l_Lean_Parser_Term_do___closed__7); +l_Lean_Parser_Term_do___closed__8 = _init_l_Lean_Parser_Term_do___closed__8(); +lean_mark_persistent(l_Lean_Parser_Term_do___closed__8); l_Lean_Parser_Term_do = _init_l_Lean_Parser_Term_do(); lean_mark_persistent(l_Lean_Parser_Term_do); res = l___regBuiltinParser_Lean_Parser_Term_do(lean_io_mk_world()); @@ -54297,6 +56194,8 @@ l_Lean_Parser_Term_not___closed__6 = _init_l_Lean_Parser_Term_not___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_not___closed__6); l_Lean_Parser_Term_not___closed__7 = _init_l_Lean_Parser_Term_not___closed__7(); lean_mark_persistent(l_Lean_Parser_Term_not___closed__7); +l_Lean_Parser_Term_not___closed__8 = _init_l_Lean_Parser_Term_not___closed__8(); +lean_mark_persistent(l_Lean_Parser_Term_not___closed__8); l_Lean_Parser_Term_not = _init_l_Lean_Parser_Term_not(); lean_mark_persistent(l_Lean_Parser_Term_not); res = l___regBuiltinParser_Lean_Parser_Term_not(lean_io_mk_world()); @@ -54332,6 +56231,8 @@ l_Lean_Parser_Term_bnot___closed__5 = _init_l_Lean_Parser_Term_bnot___closed__5( lean_mark_persistent(l_Lean_Parser_Term_bnot___closed__5); l_Lean_Parser_Term_bnot___closed__6 = _init_l_Lean_Parser_Term_bnot___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_bnot___closed__6); +l_Lean_Parser_Term_bnot___closed__7 = _init_l_Lean_Parser_Term_bnot___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_bnot___closed__7); l_Lean_Parser_Term_bnot = _init_l_Lean_Parser_Term_bnot(); lean_mark_persistent(l_Lean_Parser_Term_bnot); res = l___regBuiltinParser_Lean_Parser_Term_bnot(lean_io_mk_world()); @@ -54367,6 +56268,8 @@ l_Lean_Parser_Term_uminus___closed__6 = _init_l_Lean_Parser_Term_uminus___closed lean_mark_persistent(l_Lean_Parser_Term_uminus___closed__6); l_Lean_Parser_Term_uminus___closed__7 = _init_l_Lean_Parser_Term_uminus___closed__7(); lean_mark_persistent(l_Lean_Parser_Term_uminus___closed__7); +l_Lean_Parser_Term_uminus___closed__8 = _init_l_Lean_Parser_Term_uminus___closed__8(); +lean_mark_persistent(l_Lean_Parser_Term_uminus___closed__8); l_Lean_Parser_Term_uminus = _init_l_Lean_Parser_Term_uminus(); lean_mark_persistent(l_Lean_Parser_Term_uminus); res = l___regBuiltinParser_Lean_Parser_Term_uminus(lean_io_mk_world()); @@ -54404,6 +56307,8 @@ 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()); @@ -54437,8 +56342,6 @@ l_Lean_Parser_Term_proj___closed__6 = _init_l_Lean_Parser_Term_proj___closed__6( lean_mark_persistent(l_Lean_Parser_Term_proj___closed__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 = _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()); @@ -54479,6 +56382,8 @@ 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 = _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()); @@ -54500,6 +56405,8 @@ 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()); @@ -54529,6 +56436,8 @@ l_Lean_Parser_Term_dollarProj___closed__4 = _init_l_Lean_Parser_Term_dollarProj_ lean_mark_persistent(l_Lean_Parser_Term_dollarProj___closed__4); l_Lean_Parser_Term_dollarProj___closed__5 = _init_l_Lean_Parser_Term_dollarProj___closed__5(); lean_mark_persistent(l_Lean_Parser_Term_dollarProj___closed__5); +l_Lean_Parser_Term_dollarProj___closed__6 = _init_l_Lean_Parser_Term_dollarProj___closed__6(); +lean_mark_persistent(l_Lean_Parser_Term_dollarProj___closed__6); l_Lean_Parser_Term_dollarProj = _init_l_Lean_Parser_Term_dollarProj(); lean_mark_persistent(l_Lean_Parser_Term_dollarProj); res = l___regBuiltinParser_Lean_Parser_Term_dollarProj(lean_io_mk_world()); @@ -54564,6 +56473,8 @@ l_Lean_Parser_Term_where___closed__7 = _init_l_Lean_Parser_Term_where___closed__ lean_mark_persistent(l_Lean_Parser_Term_where___closed__7); l_Lean_Parser_Term_where___closed__8 = _init_l_Lean_Parser_Term_where___closed__8(); lean_mark_persistent(l_Lean_Parser_Term_where___closed__8); +l_Lean_Parser_Term_where___closed__9 = _init_l_Lean_Parser_Term_where___closed__9(); +lean_mark_persistent(l_Lean_Parser_Term_where___closed__9); l_Lean_Parser_Term_where = _init_l_Lean_Parser_Term_where(); lean_mark_persistent(l_Lean_Parser_Term_where); res = l___regBuiltinParser_Lean_Parser_Term_where(lean_io_mk_world()); @@ -55378,6 +57289,8 @@ l_Lean_Parser_Term_tacticBlock___closed__7 = _init_l_Lean_Parser_Term_tacticBloc lean_mark_persistent(l_Lean_Parser_Term_tacticBlock___closed__7); l_Lean_Parser_Term_tacticBlock___closed__8 = _init_l_Lean_Parser_Term_tacticBlock___closed__8(); lean_mark_persistent(l_Lean_Parser_Term_tacticBlock___closed__8); +l_Lean_Parser_Term_tacticBlock___closed__9 = _init_l_Lean_Parser_Term_tacticBlock___closed__9(); +lean_mark_persistent(l_Lean_Parser_Term_tacticBlock___closed__9); l_Lean_Parser_Term_tacticBlock = _init_l_Lean_Parser_Term_tacticBlock(); lean_mark_persistent(l_Lean_Parser_Term_tacticBlock); res = l___regBuiltinParser_Lean_Parser_Term_tacticBlock(lean_io_mk_world()); @@ -55413,6 +57326,8 @@ l_Lean_Parser_Term_byTactic___closed__5 = _init_l_Lean_Parser_Term_byTactic___cl lean_mark_persistent(l_Lean_Parser_Term_byTactic___closed__5); l_Lean_Parser_Term_byTactic___closed__6 = _init_l_Lean_Parser_Term_byTactic___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_byTactic___closed__6); +l_Lean_Parser_Term_byTactic___closed__7 = _init_l_Lean_Parser_Term_byTactic___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_byTactic___closed__7); l_Lean_Parser_Term_byTactic = _init_l_Lean_Parser_Term_byTactic(); lean_mark_persistent(l_Lean_Parser_Term_byTactic); res = l___regBuiltinParser_Lean_Parser_Term_byTactic(lean_io_mk_world()); @@ -55444,6 +57359,8 @@ l_Lean_Parser_Term_tacticStxQuot___closed__5 = _init_l_Lean_Parser_Term_tacticSt lean_mark_persistent(l_Lean_Parser_Term_tacticStxQuot___closed__5); l_Lean_Parser_Term_tacticStxQuot___closed__6 = _init_l_Lean_Parser_Term_tacticStxQuot___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_tacticStxQuot___closed__6); +l_Lean_Parser_Term_tacticStxQuot___closed__7 = _init_l_Lean_Parser_Term_tacticStxQuot___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_tacticStxQuot___closed__7); l_Lean_Parser_Term_tacticStxQuot = _init_l_Lean_Parser_Term_tacticStxQuot(); lean_mark_persistent(l_Lean_Parser_Term_tacticStxQuot); l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot___closed__1 = _init_l___regBuiltinParser_Lean_Parser_Term_tacticStxQuot___closed__1(); @@ -55473,6 +57390,8 @@ l_Lean_Parser_Term_levelStxQuot___closed__4 = _init_l_Lean_Parser_Term_levelStxQ lean_mark_persistent(l_Lean_Parser_Term_levelStxQuot___closed__4); l_Lean_Parser_Term_levelStxQuot___closed__5 = _init_l_Lean_Parser_Term_levelStxQuot___closed__5(); lean_mark_persistent(l_Lean_Parser_Term_levelStxQuot___closed__5); +l_Lean_Parser_Term_levelStxQuot___closed__6 = _init_l_Lean_Parser_Term_levelStxQuot___closed__6(); +lean_mark_persistent(l_Lean_Parser_Term_levelStxQuot___closed__6); l_Lean_Parser_Term_levelStxQuot = _init_l_Lean_Parser_Term_levelStxQuot(); lean_mark_persistent(l_Lean_Parser_Term_levelStxQuot); l___regBuiltinParser_Lean_Parser_Term_levelStxQuot___closed__1 = _init_l___regBuiltinParser_Lean_Parser_Term_levelStxQuot___closed__1(); @@ -55504,6 +57423,8 @@ l_Lean_Parser_Term_funBinderStxQuot___closed__5 = _init_l_Lean_Parser_Term_funBi lean_mark_persistent(l_Lean_Parser_Term_funBinderStxQuot___closed__5); l_Lean_Parser_Term_funBinderStxQuot___closed__6 = _init_l_Lean_Parser_Term_funBinderStxQuot___closed__6(); lean_mark_persistent(l_Lean_Parser_Term_funBinderStxQuot___closed__6); +l_Lean_Parser_Term_funBinderStxQuot___closed__7 = _init_l_Lean_Parser_Term_funBinderStxQuot___closed__7(); +lean_mark_persistent(l_Lean_Parser_Term_funBinderStxQuot___closed__7); l_Lean_Parser_Term_funBinderStxQuot = _init_l_Lean_Parser_Term_funBinderStxQuot(); lean_mark_persistent(l_Lean_Parser_Term_funBinderStxQuot); l___regBuiltinParser_Lean_Parser_Term_funBinderStxQuot___closed__1 = _init_l___regBuiltinParser_Lean_Parser_Term_funBinderStxQuot___closed__1(); diff --git a/stage0/stdlib/Lean/PrettyPrinter/Parenthesizer.c b/stage0/stdlib/Lean/PrettyPrinter/Parenthesizer.c index 449f9d46df..8f10a12404 100644 --- a/stage0/stdlib/Lean/PrettyPrinter/Parenthesizer.c +++ b/stage0/stdlib/Lean/PrettyPrinter/Parenthesizer.c @@ -70,6 +70,7 @@ lean_object* l_Lean_PrettyPrinter_Parenthesizer_identNoAntiquot_parenthesizer___ lean_object* l___regBuiltin_Lean_PrettyPrinter_Parenthesizer_strLitNoAntiquot_parenthesizer___closed__1; lean_object* l___regBuiltin_Lean_PrettyPrinter_Parenthesizer_andthen_parenthesizer(lean_object*); lean_object* l_Lean_PrettyPrinter_Parenthesizer_withPosition_parenthesizer___closed__1; +extern lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__9; uint8_t lean_name_eq(lean_object*, lean_object*); lean_object* l_Lean_PrettyPrinter_Parenthesizer_evalNat(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_Traverser_up(lean_object*); @@ -262,8 +263,8 @@ lean_object* lean_nat_sub(lean_object*, lean_object*); lean_object* l_Lean_PrettyPrinter_Parenthesizer_visit___main___closed__6; lean_object* l_Lean_PrettyPrinter_Parenthesizer_checkWsBefore_parenthesizer___rarg___boxed(lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_PrettyPrinter_Parenthesizer_symbolAux_parenthesizer(lean_object*); -extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__1; extern lean_object* l_Lean_choiceKind___closed__2; +extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__2; lean_object* l___regBuiltin_Lean_PrettyPrinter_Parenthesizer_fieldIdx_parenthesizer___closed__1; lean_object* l_Lean_Syntax_MonadTraverser_getIdx(lean_object*); lean_object* l_Lean_PrettyPrinter_Parenthesizer_numLitNoAntiquot_parenthesizer___rarg(lean_object*, lean_object*, lean_object*, lean_object*); @@ -392,7 +393,6 @@ lean_object* l___regBuiltin_Lean_PrettyPrinter_Parenthesizer_numLitNoAntiquot_pa lean_object* l_Lean_Meta_whnf(lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_PrettyPrinter_Parenthesizer_optional_parenthesizer___closed__1; lean_object* l_Lean_PrettyPrinter_Parenthesizer_visit___main___closed__9; -extern lean_object* l_Lean_Parser_antiquotNestedExpr___closed__3; uint8_t l_Lean_Elab_Term_Quotation_isAntiquot(lean_object*); lean_object* l___regBuiltin_Lean_PrettyPrinter_Parenthesizer_many_parenthesizer___closed__1; lean_object* l_Lean_PrettyPrinter_Parenthesizer_ParenthesizerM_monadTraverser___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -453,6 +453,7 @@ lean_object* l_Lean_PrettyPrinter_Parenthesizer_node_parenthesizer___closed__8; extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__3; lean_object* l___regBuiltin_Lean_PrettyPrinter_Parenthesizer_nonReservedSymbol_parenthesizer___closed__1; lean_object* l_Lean_PrettyPrinter_Parenthesizer_unquotedSymbol_parenthesizer___rarg___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; lean_object* l_Lean_PrettyPrinter_Parenthesizer_ParenthesizerM_monadTraverser___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_whnfCore___main___at_Lean_Meta_whnfCore___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_PrettyPrinter_Parenthesizer_trailingNode_parenthesizer(lean_object*); @@ -595,7 +596,7 @@ lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_objec extern lean_object* l_Nat_Inhabited; lean_object* l_Lean_PrettyPrinter_Parenthesizer_checkColGe_parenthesizer___boxed(lean_object*, lean_object*); lean_object* l_Lean_PrettyPrinter_Parenthesizer_trailingNode_parenthesizer(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Parser_unicodeSymbolInfo(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Parser_unicodeSymbolInfo(lean_object*, lean_object*); lean_object* l_PersistentHashMap_findAtAux___main___at_Lean_PrettyPrinter_Parenthesizer_visit___main___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_ReaderT_lift___at_Lean_PrettyPrinter_Parenthesizer_ParenthesizerM_monadTraverser___spec__2(lean_object*); lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*); @@ -614,7 +615,6 @@ lean_object* l_Lean_PrettyPrinter_Parenthesizer_symbolNoWsAux_parenthesizer___bo lean_object* l_Lean_PrettyPrinter_mkParenthesizerAttribute___closed__6; lean_object* l_Nat_forMAux___main___at_Lean_PrettyPrinter_Parenthesizer_visit___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_PrettyPrinter_Parenthesizer_checkRbpLt_parenthesizer___rarg___boxed(lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__11; extern lean_object* l___private_Lean_Meta_Tactic_Util_1__regTraceClasses___closed__1; extern lean_object* l_Lean_mkAppStx___closed__2; lean_object* l___private_Lean_PrettyPrinter_Parenthesizer_1__regTraceClasses(lean_object*); @@ -3963,6 +3963,16 @@ lean_dec(x_2); return x_6; } } +lean_object* _init_l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Parser_appPrec; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} lean_object* l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { @@ -4021,7 +4031,7 @@ x_26 = lean_ctor_get(x_21, 2); lean_dec(x_26); x_27 = lean_ctor_get(x_21, 1); lean_dec(x_27); -x_28 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_28 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; lean_ctor_set(x_21, 2, x_28); lean_ctor_set(x_21, 1, x_28); x_29 = lean_box(0); @@ -4036,7 +4046,7 @@ x_31 = lean_ctor_get(x_21, 3); lean_inc(x_31); lean_inc(x_30); lean_dec(x_21); -x_32 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_32 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; x_33 = lean_alloc_ctor(0, 4, 0); lean_ctor_set(x_33, 0, x_30); lean_ctor_set(x_33, 1, x_32); @@ -4068,7 +4078,7 @@ if (lean_is_exclusive(x_21)) { lean_dec_ref(x_21); x_38 = lean_box(0); } -x_39 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_39 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; if (lean_is_scalar(x_38)) { x_40 = lean_alloc_ctor(0, 4, 0); } else { @@ -4117,7 +4127,7 @@ if (lean_is_exclusive(x_43)) { lean_dec_ref(x_43); x_48 = lean_box(0); } -x_49 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_49 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; if (lean_is_scalar(x_48)) { x_50 = lean_alloc_ctor(0, 4, 0); } else { @@ -4929,7 +4939,7 @@ x_87 = lean_ctor_get(x_82, 2); lean_dec(x_87); x_88 = lean_ctor_get(x_82, 1); lean_dec(x_88); -x_89 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_89 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; lean_ctor_set(x_82, 3, x_43); lean_ctor_set(x_82, 2, x_89); lean_ctor_set(x_82, 1, x_89); @@ -4945,7 +4955,7 @@ lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; x_91 = lean_ctor_get(x_82, 0); lean_inc(x_91); lean_dec(x_82); -x_92 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_92 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; x_93 = lean_alloc_ctor(0, 4, 0); lean_ctor_set(x_93, 0, x_91); lean_ctor_set(x_93, 1, x_92); @@ -4980,7 +4990,7 @@ if (lean_is_exclusive(x_95)) { lean_dec_ref(x_95); x_98 = lean_box(0); } -x_99 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_99 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; if (lean_is_scalar(x_98)) { x_100 = lean_alloc_ctor(0, 4, 0); } else { @@ -5049,7 +5059,7 @@ x_123 = lean_ctor_get(x_118, 2); lean_dec(x_123); x_124 = lean_ctor_get(x_118, 1); lean_dec(x_124); -x_125 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_125 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; lean_ctor_set(x_118, 3, x_43); lean_ctor_set(x_118, 2, x_125); lean_ctor_set(x_118, 1, x_125); @@ -5065,7 +5075,7 @@ lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; x_127 = lean_ctor_get(x_118, 0); lean_inc(x_127); lean_dec(x_118); -x_128 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_128 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; x_129 = lean_alloc_ctor(0, 4, 0); lean_ctor_set(x_129, 0, x_127); lean_ctor_set(x_129, 1, x_128); @@ -5100,7 +5110,7 @@ if (lean_is_exclusive(x_131)) { lean_dec_ref(x_131); x_134 = lean_box(0); } -x_135 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_135 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; if (lean_is_scalar(x_134)) { x_136 = lean_alloc_ctor(0, 4, 0); } else { @@ -5206,7 +5216,7 @@ if (lean_is_exclusive(x_157)) { lean_dec_ref(x_157); x_161 = lean_box(0); } -x_162 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_162 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; if (lean_is_scalar(x_161)) { x_163 = lean_alloc_ctor(0, 4, 0); } else { @@ -5283,7 +5293,7 @@ if (lean_is_exclusive(x_180)) { lean_dec_ref(x_180); x_184 = lean_box(0); } -x_185 = l_Lean_Parser_antiquotNestedExpr___closed__1; +x_185 = l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1; if (lean_is_scalar(x_184)) { x_186 = lean_alloc_ctor(0, 4, 0); } else { @@ -12588,7 +12598,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_PrettyPrinter_Parenthesizer_depArrow_x27___elambda__1___closed__3; -x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__11; +x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9; x_3 = lean_string_append(x_1, x_2); return x_3; } @@ -12634,7 +12644,7 @@ 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 = l_Lean_PrettyPrinter_Parenthesizer_depArrow_x27___elambda__1___closed__1; -x_10 = l_Lean_Parser_Term_depArrow___elambda__1___closed__11; +x_10 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9; x_11 = l_Lean_PrettyPrinter_Parenthesizer_depArrow_x27___elambda__1___closed__6; lean_inc(x_1); x_12 = l_Lean_Parser_unicodeSymbolFnAux(x_9, x_10, x_11, x_1, x_7); @@ -12674,19 +12684,18 @@ return x_22; lean_object* _init_l_Lean_PrettyPrinter_Parenthesizer_depArrow_x27___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_PrettyPrinter_Parenthesizer_depArrow_x27___elambda__1___closed__1; -x_3 = l_Lean_Parser_Term_depArrow___elambda__1___closed__11; -x_4 = l_Lean_Parser_unicodeSymbolInfo(x_2, x_3, x_1); -return x_4; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_PrettyPrinter_Parenthesizer_depArrow_x27___elambda__1___closed__1; +x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__9; +x_3 = l_Lean_Parser_unicodeSymbolInfo(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_PrettyPrinter_Parenthesizer_depArrow_x27___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_antiquotNestedExpr___closed__3; +x_1 = l_Lean_Parser_antiquotNestedExpr___closed__2; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); x_3 = l_Lean_PrettyPrinter_Parenthesizer_depArrow_x27___closed__1; @@ -13322,6 +13331,8 @@ l_Lean_PrettyPrinter_Parenthesizer_monadQuotation___closed__4 = _init_l_Lean_Pre lean_mark_persistent(l_Lean_PrettyPrinter_Parenthesizer_monadQuotation___closed__4); l_Lean_PrettyPrinter_Parenthesizer_monadQuotation = _init_l_Lean_PrettyPrinter_Parenthesizer_monadQuotation(); lean_mark_persistent(l_Lean_PrettyPrinter_Parenthesizer_monadQuotation); +l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1 = _init_l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1(); +lean_mark_persistent(l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___lambda__1___closed__1); l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___closed__1 = _init_l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___closed__1(); lean_mark_persistent(l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___closed__1); l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___closed__2 = _init_l_Lean_PrettyPrinter_Parenthesizer_visitAntiquot___closed__2();