From 95c5ccc97da43451a71439f71bb07385f6fdb79f Mon Sep 17 00:00:00 2001 From: Leonardo de Moura Date: Mon, 23 Mar 2020 11:58:58 -0700 Subject: [PATCH] chore: update stage0 --- stage0/src/Init/Data/List/Basic.lean | 21 + stage0/src/Init/Data/Option/Basic.lean | 8 + stage0/src/Init/Lean/Data/Position.lean | 8 +- stage0/src/Init/Lean/Declaration.lean | 10 + stage0/src/Init/Lean/Delaborator.lean | 362 +- stage0/src/Init/Lean/Elab/Quotation.lean | 37 - stage0/src/Init/Lean/Elab/Term.lean | 4 +- stage0/src/Init/Lean/Environment.lean | 12 +- stage0/src/Init/Lean/Eval.lean | 10 +- stage0/src/Init/Lean/Expr.lean | 4 +- stage0/src/Init/Lean/LocalContext.lean | 12 +- stage0/src/Init/Lean/Message.lean | 37 + stage0/src/Init/Lean/Meta/Basic.lean | 25 + stage0/src/Init/Lean/Meta/Exception.lean | 3 + stage0/src/Init/Lean/Meta/Message.lean | 41 +- stage0/src/Init/Lean/Parser/Parser.lean | 5 +- stage0/src/Init/Lean/Syntax.lean | 59 +- stage0/src/Init/Lean/Util/Closure.lean | 194 + stage0/src/Init/System/IO.lean | 17 +- stage0/src/Init/System/IOError.lean | 2 +- stage0/src/frontends/lean/builtin_cmds.cpp | 10 +- stage0/stdlib/CMakeLists.txt | 2 +- stage0/stdlib/Init/Data/List/Basic.c | 497 + stage0/stdlib/Init/Data/Option/Basic.c | 64 + stage0/stdlib/Init/Lean/Compiler/IR/Borrow.c | 17 +- .../stdlib/Init/Lean/Compiler/IR/CtorLayout.c | 17 +- stage0/stdlib/Init/Lean/Data/Position.c | 71 +- stage0/stdlib/Init/Lean/Declaration.c | 69 +- stage0/stdlib/Init/Lean/Delaborator.c | 13646 +++++++++++++++- stage0/stdlib/Init/Lean/Elab/App.c | 137 +- stage0/stdlib/Init/Lean/Elab/Binders.c | 170 +- .../stdlib/Init/Lean/Elab/BuiltinNotation.c | 136 +- stage0/stdlib/Init/Lean/Elab/Command.c | 148 +- stage0/stdlib/Init/Lean/Elab/DeclModifiers.c | 248 +- stage0/stdlib/Init/Lean/Elab/Declaration.c | 8 +- stage0/stdlib/Init/Lean/Elab/Definition.c | 10 +- stage0/stdlib/Init/Lean/Elab/DoNotation.c | 55 +- stage0/stdlib/Init/Lean/Elab/Exception.c | 2 - stage0/stdlib/Init/Lean/Elab/Import.c | 14 +- stage0/stdlib/Init/Lean/Elab/Level.c | 68 +- stage0/stdlib/Init/Lean/Elab/Log.c | 10 +- stage0/stdlib/Init/Lean/Elab/Quotation.c | 4380 +++-- stage0/stdlib/Init/Lean/Elab/StructInst.c | 57 +- stage0/stdlib/Init/Lean/Elab/Syntax.c | 88 +- stage0/stdlib/Init/Lean/Elab/SyntheticMVars.c | 6 +- stage0/stdlib/Init/Lean/Elab/Tactic/Basic.c | 13 +- .../stdlib/Init/Lean/Elab/Tactic/Generalize.c | 2 +- stage0/stdlib/Init/Lean/Elab/Term.c | 728 +- stage0/stdlib/Init/Lean/Elab/Util.c | 25 +- stage0/stdlib/Init/Lean/Environment.c | 638 +- stage0/stdlib/Init/Lean/Eval.c | 104 +- stage0/stdlib/Init/Lean/Expr.c | 4 +- stage0/stdlib/Init/Lean/KeyedDeclsAttribute.c | 21 +- stage0/stdlib/Init/Lean/LocalContext.c | 327 +- stage0/stdlib/Init/Lean/Message.c | 1587 +- stage0/stdlib/Init/Lean/Meta/Basic.c | 229 +- stage0/stdlib/Init/Lean/Meta/Exception.c | 80 +- stage0/stdlib/Init/Lean/Meta/ExprDefEq.c | 458 +- stage0/stdlib/Init/Lean/Meta/Message.c | 1334 +- stage0/stdlib/Init/Lean/Meta/RecursorInfo.c | 112 +- stage0/stdlib/Init/Lean/Meta/SynthInstance.c | 2 +- .../stdlib/Init/Lean/Meta/Tactic/Induction.c | 26 +- stage0/stdlib/Init/Lean/Meta/Tactic/Revert.c | 52 +- stage0/stdlib/Init/Lean/Meta/WHNF.c | 2 +- stage0/stdlib/Init/Lean/Parser/Level.c | 42 +- stage0/stdlib/Init/Lean/Parser/Module.c | 23 +- stage0/stdlib/Init/Lean/Parser/Parser.c | 417 +- stage0/stdlib/Init/Lean/Parser/Syntax.c | 16 +- stage0/stdlib/Init/Lean/Parser/Tactic.c | 37 +- stage0/stdlib/Init/Lean/Parser/Term.c | 140 +- stage0/stdlib/Init/Lean/Syntax.c | 1902 ++- stage0/stdlib/Init/Lean/Util/Closure.c | 6829 ++++++++ stage0/stdlib/Init/Lean/Util/FoldConsts.c | 19 +- stage0/stdlib/Init/Lean/Util/WHNF.c | 51 +- stage0/stdlib/Init/System/IO.c | 188 +- stage0/stdlib/Init/System/IOError.c | 13 +- 76 files changed, 29851 insertions(+), 6371 deletions(-) create mode 100644 stage0/src/Init/Lean/Util/Closure.lean create mode 100644 stage0/stdlib/Init/Lean/Util/Closure.c diff --git a/stage0/src/Init/Data/List/Basic.lean b/stage0/src/Init/Data/List/Basic.lean index 0a71a5396b..0d7ddb1645 100644 --- a/stage0/src/Init/Data/List/Basic.lean +++ b/stage0/src/Init/Data/List/Basic.lean @@ -192,6 +192,17 @@ def eraseDupsAux {α} [HasBeq α] : List α → List α → List α def eraseDups {α} [HasBeq α] (as : List α) : List α := eraseDupsAux as [] +def eraseRepsAux {α} [HasBeq α] : α → List α → List α → List α +| a, [], rs => (a::rs).reverse +| a, a'::as, rs => match a == a' with + | true => eraseRepsAux a as rs + | false => eraseRepsAux a' as (a::rs) + +/-- Erase repeated adjacent elements. -/ +def eraseReps {α} [HasBeq α] : List α → List α +| [] => [] +| a::as => eraseRepsAux a as [] + @[specialize] def spanAux (p : α → Bool) : List α → List α → List α × List α | [], rs => (rs.reverse, []) | a::as, rs => match p a with @@ -201,6 +212,16 @@ eraseDupsAux as [] @[inline] def span (p : α → Bool) (as : List α) : List α × List α := spanAux p as [] +@[specialize] def groupByAux (eq : α → α → Bool) : List α → List (List α) → List (List α) +| a::as, (ag::g)::gs => match eq a ag with + | true => groupByAux as ((a::ag::g)::gs) + | false => groupByAux as ([a]::(ag::g).reverse::gs) +| _, gs => gs.reverse + +@[specialize] def groupBy (p : α → α → Bool) : List α → List (List α) +| [] => [] +| a::as => groupByAux p as [[a]] + def lookup [HasBeq α] : α → List (α × β) → Option β | _, [] => none | a, (k,b)::es => match a == k with diff --git a/stage0/src/Init/Data/Option/Basic.lean b/stage0/src/Init/Data/Option/Basic.lean index b1c2f156e1..5a9c67694b 100644 --- a/stage0/src/Init/Data/Option/Basic.lean +++ b/stage0/src/Init/Data/Option/Basic.lean @@ -51,6 +51,14 @@ instance : Monad Option := | some a => if p a then some a else none | none => none +@[inline] protected def all {α} (p : α → Bool) : Option α → Bool +| some a => p a +| none => true + +@[inline] protected def any {α} (p : α → Bool) : Option α → Bool +| some a => p a +| none => false + @[macroInline] protected def orelse {α : Type u} : Option α → Option α → Option α | some a, _ => some a | none, b => b diff --git a/stage0/src/Init/Lean/Data/Position.lean b/stage0/src/Init/Lean/Data/Position.lean index f0d0746d0f..04a8b82024 100644 --- a/stage0/src/Init/Lean/Data/Position.lean +++ b/stage0/src/Init/Lean/Data/Position.lean @@ -74,7 +74,13 @@ private partial def toPositionAux (str : String) (ps : Array Nat) (lines : Array else toPositionAux b m def toPosition : FileMap → String.Pos → Position -| { source := str, positions := ps, lines := lines }, pos => toPositionAux str ps lines pos 0 (ps.size-1) +| { source := str, positions := ps, lines := lines }, pos => + if ps.size >= 2 && pos <= ps.back then + toPositionAux str ps lines pos 0 (ps.size-1) + else + -- Some systems like the delaborator use synthetic positions without an input file, + -- which would violate `toPositionAux`'s invariant + ⟨1, pos⟩ end FileMap end Lean diff --git a/stage0/src/Init/Lean/Declaration.lean b/stage0/src/Init/Lean/Declaration.lean index 58b5938f6c..50771041c4 100644 --- a/stage0/src/Init/Lean/Declaration.lean +++ b/stage0/src/Init/Lean/Declaration.lean @@ -233,6 +233,16 @@ def toConstantVal : ConstantInfo → ConstantVal | ctorInfo {toConstantVal := d, ..} => d | recInfo {toConstantVal := d, ..} => d +def isUnsafe : ConstantInfo → Bool +| defnInfo v => v.isUnsafe +| axiomInfo v => v.isUnsafe +| thmInfo v => false +| opaqueInfo v => v.isUnsafe +| quotInfo v => false +| inductInfo v => v.isUnsafe +| ctorInfo v => v.isUnsafe +| recInfo v => v.isUnsafe + def name (d : ConstantInfo) : Name := d.toConstantVal.name diff --git a/stage0/src/Init/Lean/Delaborator.lean b/stage0/src/Init/Lean/Delaborator.lean index 0ad4ab1f7e..1b12b95279 100644 --- a/stage0/src/Init/Lean/Delaborator.lean +++ b/stage0/src/Init/Lean/Delaborator.lean @@ -3,22 +3,376 @@ Copyright (c) 2020 Microsoft Corporation. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Sebastian Ullrich -/ + +/-! +The delaborator is the first stage of the pretty printer, and the inverse of the +elaborator: it turns fully elaborated `Expr` core terms back into surface-level +`Syntax`, omitting some implicit information again and using higher-level syntax +abstractions like notations where possible. The exact behavior can be customized +using pretty printer options; activating `pp.all` should guarantee that the +delaborator is injective and that re-elaborating the resulting `Syntax` +round-trips. + +Pretty printer options can be given not only for the whole term, but also +specific subterms. This is used both when automatically refining pp options +until round-trip and when interactively selecting pp options for a subterm (both +TBD). The association of options to subterms is done by assigning a unique, +synthetic Nat position to each subterm derived from its position in the full +term. This position is added to the corresponding Syntax object so that +elaboration errors and interactions with the pretty printer output can be traced +back to the subterm. + +The delaborator is extensible via the `[delab]` attribute. +-/ + prelude import Init.Lean.KeyedDeclsAttribute +import Init.Lean.Parser.Level -- for level quotations +import Init.Lean.Elab namespace Lean + +-- TODO: move, maybe +namespace Level +protected partial def quote : Level → Syntax +| zero _ => Unhygienic.run `(level|0) +| l@(succ _ _) => match l.toNat with + | some n => Unhygienic.run `(level|$(mkStxNumLitAux n):numLit) + | none => Unhygienic.run `(level|$(quote l.getLevelOffset) + $(mkStxNumLitAux l.getOffset):numLit) +| max l1 l2 _ => match_syntax quote l2 with + | `(level|max $ls*) => Unhygienic.run `(level|max $(quote l1) $ls*) + | l2 => Unhygienic.run `(level|max $(quote l1) $l2) +| imax l1 l2 _ => match_syntax quote l2 with + | `(level|imax $ls*) => Unhygienic.run `(level|imax $(quote l1) $ls*) + | l2 => Unhygienic.run `(level|imax $(quote l1) $l2) +| param n _ => Unhygienic.run `(level|$(mkIdent n):ident) +-- HACK: approximation +| mvar n _ => Unhygienic.run `(level|_) + +instance HasQuote : HasQuote Level := ⟨Level.quote⟩ +end Level + +def getPPBinderTypes (o : Options) : Bool := o.get `pp.binder_types true +def getPPExplicit (o : Options) : Bool := o.get `pp.explicit false +def getPPUniverses (o : Options) : Bool := o.get `pp.universes false +def getPPAll (o : Options) : Bool := o.get `pp.all false + +@[init] def ppOptions : IO Unit := do +registerOption `pp.explicit { defValue := false, group := "pp", descr := "(pretty printer) display implicit arguments" }; +-- TODO: register other options when old pretty printer is removed +--registerOption `pp.universes { defValue := false, group := "pp", descr := "(pretty printer) display universes" }; +pure () + +/-- Associate pretty printer options to a specific subterm using a synthetic position. -/ +abbrev OptionsPerPos := RBMap Nat Options (fun a b => a < b) + namespace Delaborator +open Lean.Meta -abbrev Delab := Unit -- TODO +structure Context := +-- In contrast to other systems like the elaborator, we do not pass the current term explicitly as a +-- parameter, but store it in the monad so that we can keep it in sync with `pos`. +(expr : Expr) +(pos : Nat := 1) +(defaultOptions : Options) +(optionsPerPos : OptionsPerPos) -unsafe def mkDelabAttribute : IO (KeyedDeclsAttribute Macro) := +-- Exceptions from delaborators are not expected, so use a simple `OptionT` to signal whether +-- the delaborator was able to produce a Syntax object. +abbrev DelabM := ReaderT Context $ OptionT MetaM +abbrev Delab := DelabM Syntax + +instance DelabM.inhabited {α} : Inhabited (DelabM α) := ⟨failure⟩ + +-- Macro scopes in the delaborator output are ultimately ignored by the pretty printer, +-- so give a trivial implementation. +instance DelabM.monadQuotation : MonadQuotation DelabM := { + getCurrMacroScope := pure $ arbitrary _, + getMainModule := pure $ arbitrary _, + withFreshMacroScope := fun α x => x, +} + +unsafe def mkDelabAttribute : IO (KeyedDeclsAttribute Delab) := KeyedDeclsAttribute.init { builtinName := `builtinDelab, name := `delab, - descr := "delaborator", + descr := "Register a delaborator. + +[delab k] registers a declaration of type `Lean.Delaborator.Delab` for the `Lean.Expr` +constructor `k`. Multiple delaborators for a single constructor are tried in turn until +the first success. If the term to be delaborated is an application of a constant `c`, +elaborators for `app.c` are tried first; this is also done for `Expr.const`s (\"nullary applications\") +to reduce special casing. If the term is an `Expr.mdata` with a single key `k`, `mdata.k` +is tried first.", valueTypeName := `Lean.Delaborator.Delab } `Lean.Delaborator.delabAttribute -@[init mkDelabAttribute] constant delabAttribute : KeyedDeclsAttribute Macro := arbitrary _ +@[init mkDelabAttribute] constant delabAttribute : KeyedDeclsAttribute Delab := arbitrary _ + +def getExpr : DelabM Expr := do +ctx ← read; +pure ctx.expr + +def getExprKind : DelabM Name := do +e ← getExpr; +pure $ match e with +| Expr.bvar _ _ => `bvar +| Expr.fvar _ _ => `fvar +| Expr.mvar _ _ => `mvar +| Expr.sort _ _ => `sort +| Expr.const c _ _ => + -- we identify constants as "nullary applications" to reduce special casing + `app ++ c +| Expr.app fn _ _ => match fn.getAppFn with + | Expr.const c _ _ => `app ++ c + | _ => `app +| Expr.lam _ _ _ _ => `lam +| Expr.forallE _ _ _ _ => `forallE +| Expr.letE _ _ _ _ _ => `letE +| Expr.lit _ _ => `lit +| Expr.mdata m _ _ => match m.entries with + | [(key, _)] => `mdata ++ key + | _ => `mdata +| Expr.proj _ _ _ _ => `proj +| Expr.localE _ _ _ _ => `localE + +/-- Evaluate option accessor, using subterm-specific options if set. Default to `true` if `pp.all` is set. -/ +def getPPOption (opt : Options → Bool) : DelabM Bool := do +ctx ← read; +let opt := fun opts => opt opts || getPPAll opts; +let val := opt ctx.defaultOptions; +match ctx.optionsPerPos.find? ctx.pos with +| some opts => pure $ opt opts +| none => pure val + +def whenPPOption (opt : Options → Bool) (d : Delab) : Delab := do +b ← getPPOption opt; +if b then d else failure + +def whenNotPPOption (opt : Options → Bool) (d : Delab) : Delab := do +b ← getPPOption opt; +if b then failure else d + +/-- +Descend into `child`, the `childIdx`-th subterm of the current term, and update position. + +Because `childIdx < 3` in the case of `Expr`, we can injectively map a path +`childIdxs` to a natural number by computing the value of the 3-ary representation +`1 :: childIdxs`, since n-ary representations without leading zeros are unique. +Note that `pos` is initialized to `1` (case `childIdxs == []`). +-/ +def descend {α} (child : Expr) (childIdx : Nat) (d : DelabM α) : DelabM α := +adaptReader (fun (cfg : Context) => { cfg with expr := child, pos := cfg.pos * 3 + childIdx }) d + +def withAppFn {α} (d : DelabM α) : DelabM α := do +Expr.app fn _ _ ← getExpr | unreachable!; +descend fn 0 d + +def withAppArg {α} (d : DelabM α) : DelabM α := do +Expr.app _ arg _ ← getExpr | unreachable!; +descend arg 1 d + +partial def withAppFnArgs {α} : DelabM α → (α → DelabM α) → DelabM α +| fnD, argD => do + Expr.app fn arg _ ← getExpr | fnD; + a ← withAppFn (withAppFnArgs fnD argD); + withAppArg (argD a) + +def withBindingDomain {α} (d : DelabM α) : DelabM α := do +e ← getExpr; +descend e.bindingDomain! 0 d + +def withBindingBody {α} (n : Name) (d : DelabM α) : DelabM α := do +e ← getExpr; +fun ctx => withLocalDecl n e.bindingDomain! e.binderInfo $ fun fvar => + let b := e.bindingBody!.instantiate1 fvar; + descend b 1 d ctx + +def infoForPos (pos : Nat) : SourceInfo := +{ leading := " ".toSubstring, pos := pos, trailing := " ".toSubstring } + +partial def annotatePos (pos : Nat) : Syntax → Syntax +| stx@(Syntax.ident _ _ _ _) => stx.setInfo (infoForPos pos) +-- Term.ids => annotate ident +-- TODO: universes? +| stx@(Syntax.node `Lean.Parser.Term.id args) => stx.modifyArg 0 annotatePos +-- app => annotate function +| stx@(Syntax.node `Lean.Parser.Term.app args) => stx.modifyArg 0 annotatePos +-- otherwise, annotate first direct child token if any +| stx => match stx.getArgs.findIdx? Syntax.isAtom with + | some idx => stx.modifyArg idx (Syntax.setInfo (infoForPos pos)) + | none => stx + +def annotateCurPos (stx : Syntax) : Delab := do +ctx ← read; +pure $ annotatePos ctx.pos stx + +partial def delabFor : Name → Delab +| k => do + env ← liftM getEnv; + (match (delabAttribute.ext.getState env).table.find? k with + | some delabs => delabs.firstM id >>= annotateCurPos + | none => failure) <|> + (match k with + | Name.str Name.anonymous _ _ => failure + | Name.str n _ _ => delabFor n.getRoot -- have `app.Option.some` fall back to `app` etc. + | _ => failure) + +def delab : Delab := do +k ← getExprKind; +delabFor k <|> (liftM $ show MetaM Syntax from throw $ Meta.Exception.other $ "don't know how to delaborate '" ++ toString k ++ "'") + +@[builtinDelab fvar] +def delabFVar : Delab := do +Expr.fvar id _ ← getExpr | unreachable!; +l ← liftM $ getLocalDecl id; +pure $ mkTermId l.userName + +@[builtinDelab mvar] +def delabMVar : Delab := do +Expr.mvar n _ ← getExpr | unreachable!; +`(?$(mkIdent n)) + +@[builtinDelab sort] +def delabSort : Delab := do +expr ← getExpr; +match expr with +| Expr.sort (Level.zero _) _ => `(Prop) +| Expr.sort (Level.succ (Level.zero _) _) _ => `(Type) +| Expr.sort l _ => match l.dec with + | some l' => `(Type $(quote l')) + | none => `(Sort $(quote l)) +| _ => unreachable! + +-- NOTE: not a registered delaborator, as `const` is never called (see [delab] description) +def delabConst : Delab := do +Expr.const c ls _ ← getExpr | unreachable!; +ppUnivs ← getPPOption getPPUniverses; +if ls.isEmpty || !ppUnivs then + `($(mkIdent c):ident) +else + `($(mkIdent c):ident.{$(ls.toArray.map quote)*}) + +/-- Return array with n-th element set to `true` iff n-th parameter of `e` is implicit. -/ +def getImplicitParams (e : Expr) : MetaM (Array Bool) := do +t ← inferType e; +forallTelescopeReducing t $ fun params _ => + params.mapM $ fun param => do + l ← getLocalDecl param.fvarId!; + pure (!l.binderInfo.isExplicit) + +@[builtinDelab app] +def delabAppExplicit : Delab := do +(fnStx, argStxs) ← withAppFnArgs + (do + fn ← getExpr; + stx ← if fn.isConst then delabConst else delab; + implicitParams ← liftM $ getImplicitParams fn; + stx ← if implicitParams.any id then `(@$stx) else pure stx; + pure (stx, #[])) + (fun ⟨fnStx, argStxs⟩ => do + argStx ← delab; + pure (fnStx, argStxs.push argStx)); +-- avoid degenerate `app` node +if argStxs.isEmpty then pure fnStx else `($fnStx $argStxs*) + +@[builtinDelab app] +def delabAppImplicit : Delab := whenNotPPOption getPPExplicit $ do +(fnStx, _, argStxs) ← withAppFnArgs + (do + fn ← getExpr; + stx ← if fn.isConst then delabConst else delab; + implicitParams ← liftM $ getImplicitParams fn; + pure (stx, implicitParams.toList, #[])) + (fun ⟨fnStx, implicitParams, argStxs⟩ => match implicitParams with + | true :: implicitParams => pure (fnStx, implicitParams, argStxs) + | _ => do + argStx ← delab; + pure (fnStx, implicitParams.tailD [], argStxs.push argStx)); +-- avoid degenerate `app` node +if argStxs.isEmpty then pure fnStx else `($fnStx $argStxs*) + +/-- +Return `true` iff current binder should be merged with the nested +binder, if any, into a single binder group: +* both binders must have same binder info and domain +* they cannot be inst-implicit (`[a b : A]` is not valid syntax) +* `pp.binder_types` must be the same value for both terms +* prefer `fun a b` over `fun (a b)` +-/ +private def shouldGroupWithNext : DelabM Bool := do +e ← getExpr; +ppEType ← getPPOption getPPBinderTypes; +let go (e' : Expr) := do { + ppE'Type ← withBindingBody `_ $ getPPOption getPPBinderTypes; + pure $ e.binderInfo == e'.binderInfo && + e.bindingDomain! == e'.bindingDomain! && + e'.binderInfo != BinderInfo.instImplicit && + ppEType == ppE'Type && + (e'.binderInfo != BinderInfo.default || ppE'Type) +}; +match e with +| Expr.lam _ _ e'@(Expr.lam _ _ _ _) _ => go e' +| Expr.forallE _ _ e'@(Expr.forallE _ _ _ _) _ => go e' +| _ => pure false + +private partial def delabLamAux : Array Syntax → Array Syntax → Delab +-- Accumulate finished binder groups `(a b : Nat) (c : Bool) ...` and names +-- (`Syntax.ident`s with position information) of the current, unfinished +-- binder group `(d e ...)`. +| binderGroups, curNames => do + ppTypes ← getPPOption getPPBinderTypes; + e@(Expr.lam n t body _) ← getExpr | unreachable!; + lctx ← liftM $ getLCtx; + let n := lctx.getUnusedName n; + stxN ← annotateCurPos (mkIdent n); + let curNames := curNames.push stxN; + condM shouldGroupWithNext + -- group with nested binder => recurse immediately + (withBindingBody n $ delabLamAux binderGroups curNames) $ + -- don't group => finish current binder group + do + stxT ← withBindingDomain delab; + group ← match e.binderInfo, ppTypes with + | BinderInfo.default, true => do + -- "default" binder group is the only one that expects binder names + -- as a term, i.e. a single `Term.id` or an application thereof + let curNames := curNames.map mkTermIdFromIdent; + stxCurNames ← if curNames.size > 1 then `($(curNames.get! 0) $(curNames.eraseIdx 0)*) + else pure $ curNames.get! 0; + `(funBinder| ($stxCurNames : $stxT)) + | BinderInfo.default, false => pure $ mkTermIdFromIdent stxN -- here `curNames == #[stxN]` + | BinderInfo.implicit, true => `(funBinder| {$curNames* : $stxT}) + | BinderInfo.implicit, false => `(funBinder| {$curNames*}) + -- here `curNames == #[stxN]` + | BinderInfo.instImplicit, _ => `(funBinder| [$stxN : $stxT]) + | _ , _ => unreachable!; + let binderGroups := binderGroups.push group; + withBindingBody n $ + if body.isLambda then + delabLamAux binderGroups #[] + else do + stxBody ← delab; + `(@(fun $binderGroups* => $stxBody)) + +@[builtinDelab lam] +def delabExplicitLam : Delab := +delabLamAux #[] #[] + +-- TODO: implicit lambdas + +@[builtinDelab lit] +def delabLit : Delab := do +Expr.lit l _ ← getExpr | unreachable!; +match l with +| Literal.natVal n => pure $ quote n +| Literal.strVal s => pure $ quote s end Delaborator + +/-- "Delaborate" the given term into surface-level syntax using the given general and subterm-specific options. -/ +def delab (e : Expr) (defaultOptions : Options) (optionsPerPos : OptionsPerPos := {}) : MetaM Syntax := do +some stx ← Delaborator.delab { expr := e, defaultOptions := defaultOptions, optionsPerPos := optionsPerPos } + | unreachable!; +pure stx + end Lean diff --git a/stage0/src/Init/Lean/Elab/Quotation.lean b/stage0/src/Init/Lean/Elab/Quotation.lean index 26d0d9491d..426a1c549a 100644 --- a/stage0/src/Init/Lean/Elab/Quotation.lean +++ b/stage0/src/Init/Lean/Elab/Quotation.lean @@ -23,43 +23,6 @@ After removing the old frontend, quotations in this and other files should be cl -/ namespace Lean - -/-- Reflect a runtime datum back to surface syntax (best-effort). -/ -class HasQuote (α : Type) := -(quote : α → Syntax) - -export HasQuote (quote) - -instance Syntax.HasQuote : HasQuote Syntax := ⟨id⟩ -instance String.HasQuote : HasQuote String := ⟨fun s => Syntax.node `Lean.Parser.Term.str #[mkStxStrLit s]⟩ -instance Nat.HasQuote : HasQuote Nat := ⟨fun n => Syntax.node `Lean.Parser.Term.num #[mkStxNumLit $ toString n]⟩ -instance Substring.HasQuote : HasQuote Substring := ⟨fun s => mkCAppStx `String.toSubstring #[quote s.toString]⟩ - -private def quoteName : Name → Syntax -| Name.anonymous => mkCTermId `Lean.Name.anonymous -| Name.str n s _ => mkCAppStx `Lean.mkNameStr #[quoteName n, quote s] -| Name.num n i _ => mkCAppStx `Lean.mkNameNum #[quoteName n, quote i] - -instance Name.hasQuote : HasQuote Name := ⟨quoteName⟩ - -instance Prod.hasQuote {α β : Type} [HasQuote α] [HasQuote β] : HasQuote (α × β) := -⟨fun ⟨a, b⟩ => mkCAppStx `Prod.mk #[quote a, quote b]⟩ - -private def quoteList {α : Type} [HasQuote α] : List α → Syntax -| [] => mkCTermId `List.nil -| (x::xs) => mkCAppStx `List.cons #[quote x, quoteList xs] - -instance List.hasQuote {α : Type} [HasQuote α] : HasQuote (List α) := ⟨quoteList⟩ - -instance Array.hasQuote {α : Type} [HasQuote α] : HasQuote (Array α) := -⟨fun xs => mkCAppStx `List.toArray #[quote xs.toList]⟩ - -private def quoteOption {α : Type} [HasQuote α] : Option α → Syntax -| none => mkTermId `Option.none -| (some x) => mkCAppStx `Option.some #[quote x] - -instance Option.hasQuote {α : Type} [HasQuote α] : HasQuote (Option α) := ⟨quoteOption⟩ - namespace Elab namespace Term namespace Quotation diff --git a/stage0/src/Init/Lean/Elab/Term.lean b/stage0/src/Init/Lean/Elab/Term.lean index 2032351026..f35c18a14a 100644 --- a/stage0/src/Init/Lean/Elab/Term.lean +++ b/stage0/src/Init/Lean/Elab/Term.lean @@ -1152,7 +1152,7 @@ fun stx _ => | none => throwError stx "ill-formed syntax" instance MetaHasEval {α} [MetaHasEval α] : MetaHasEval (TermElabM α) := -⟨fun env opts x => do +⟨fun env opts x _ => do let ctx : Context := { config := { opts := opts }, fileName := "", @@ -1177,7 +1177,7 @@ instance MetaHasEval {α} [MetaHasEval α] : MetaHasEval (TermElabM α) := throw (IO.userError "error: unsupported syntax") | EStateM.Result.error Exception.postpone s => do showMessages s; - throw (IO.userError "error: elaborator posponed")⟩ + throw (IO.userError "error: elaborator postponed")⟩ end Term diff --git a/stage0/src/Init/Lean/Environment.lean b/stage0/src/Init/Lean/Environment.lean index 07e442a2a2..8e08a933bc 100644 --- a/stage0/src/Init/Lean/Environment.lean +++ b/stage0/src/Init/Lean/Environment.lean @@ -8,9 +8,10 @@ import Init.System.IO import Init.Util import Init.Data.ByteArray import Init.Lean.Data.SMap -import Init.Lean.Util.Path import Init.Lean.Declaration import Init.Lean.LocalContext +import Init.Lean.Util.Path +import Init.Lean.Util.FindExpr namespace Lean /- Opaque environment extension state. It is essentially the Lean version of a C `void *` @@ -617,6 +618,15 @@ match env.find? constName with else env.evalConst α constName | _ => throwUnexpectedType typeName constName +def hasUnsafe (env : Environment) (e : Expr) : Bool := +let c? := e.find? $ fun e => match e with + | Expr.const c _ _ => + match env.find? c with + | some cinfo => cinfo.isUnsafe + | none => false + | _ => false; +c?.isSome + end Environment /- Helper functions for accessing environment -/ diff --git a/stage0/src/Init/Lean/Eval.lean b/stage0/src/Init/Lean/Eval.lean index a58779b2d8..508d9c52a6 100644 --- a/stage0/src/Init/Lean/Eval.lean +++ b/stage0/src/Init/Lean/Eval.lean @@ -16,10 +16,10 @@ universe u The basic `HasEval` class is in the prelude and should not depend on these types. -/ class MetaHasEval (α : Type u) := -(eval : Environment → Options → α → IO Unit) +(eval : Environment → Options → α → forall (hideUnit : optParam Bool true), IO Unit) -instance MetaHasEvalOfHasEval {α : Type u} [HasEval α] : MetaHasEval α := -⟨fun env opts a => HasEval.eval a⟩ +instance metaHasEvalOfHasEval {α : Type u} [HasEval α] : MetaHasEval α := +⟨fun env opts a hideUnit => HasEval.eval a hideUnit⟩ abbrev MetaIO := ReaderT (Environment × Options) IO @@ -29,8 +29,8 @@ ctx ← read; pure ctx.1 def MetaIO.getOptions : MetaIO Options := do ctx ← read; pure ctx.2 -instance MetaIO.metaHasEval : MetaHasEval (MetaIO Unit) := -⟨fun env opts x => x (env, opts)⟩ +instance MetaIO.metaHasEval {α} [MetaHasEval α] : MetaHasEval (MetaIO α) := +⟨fun env opts x _ => x (env, opts) >>= MetaHasEval.eval env opts⟩ instance MetaIO.monadIO : MonadIO MetaIO := ⟨fun _ x _ => x⟩ diff --git a/stage0/src/Init/Lean/Expr.lean b/stage0/src/Init/Lean/Expr.lean index 324f4c92ae..3cdaad2ae2 100644 --- a/stage0/src/Init/Lean/Expr.lean +++ b/stage0/src/Init/Lean/Expr.lean @@ -543,8 +543,8 @@ def bindingName! : Expr → Name | _ => panic! "binding expected" def bindingDomain! : Expr → Expr -| forallE _ _ d _ => d -| lam _ _ d _ => d +| forallE _ d _ _ => d +| lam _ d _ _ => d | _ => panic! "binding expected" def bindingBody! : Expr → Expr diff --git a/stage0/src/Init/Lean/LocalContext.lean b/stage0/src/Init/Lean/LocalContext.lean index 40099452dd..07010d2687 100644 --- a/stage0/src/Init/Lean/LocalContext.lean +++ b/stage0/src/Init/Lean/LocalContext.lean @@ -131,6 +131,16 @@ lctx.fvarIdToDecl.contains fvarId def containsFVar (lctx : LocalContext) (e : Expr) : Bool := lctx.contains e.fvarId! +def getFVarIds (lctx : LocalContext) : Array FVarId := +lctx.decls.foldl + (fun (r : Array FVarId) decl? => match decl? with + | some decl => r.push decl.fvarId + | none => r) + #[] + +def getFVars (lctx : LocalContext) : Array Expr := +lctx.getFVarIds.map mkFVar + private partial def popTailNoneAux : PArray (Option LocalDecl) → PArray (Option LocalDecl) | a => if a.size == 0 then a @@ -285,7 +295,7 @@ xs.size.foldRev (fun i b => let val := val.abstractRange i xs; mkLet n ty val b else - b + b.lowerLooseBVars 1 1 | none => panic! "unknown free variable") b def mkLambda (lctx : LocalContext) (xs : Array Expr) (b : Expr) : Expr := diff --git a/stage0/src/Init/Lean/Message.lean b/stage0/src/Init/Lean/Message.lean index 264440e025..fbf056bb6a 100644 --- a/stage0/src/Init/Lean/Message.lean +++ b/stage0/src/Init/Lean/Message.lean @@ -178,4 +178,41 @@ def toList (log : MessageLog) : List Message := (log.msgs.foldl (fun acc msg => msg :: acc) []).reverse end MessageLog + +def indentExpr (msg : MessageData) : MessageData := +MessageData.nest 2 (Format.line ++ msg) + +namespace KernelException + +private def mkCtx (env : Environment) (lctx : LocalContext) (opts : Options) (msg : MessageData) : MessageData := +MessageData.withContext { env := env, mctx := {}, lctx := lctx, opts := opts } msg + +def toMessageData (e : KernelException) (opts : Options) : MessageData := +match e with +| unknownConstant env constName => mkCtx env {} opts $ "(kernel) unknown constant " ++ constName +| alreadyDeclared env constName => mkCtx env {} opts $ "(kernel) constant has already been declared " ++ constName +| declTypeMismatch env decl givenType => + let process (n : Name) (expectedType : Expr) : MessageData := + "(kernel) declaration type mismatch " ++ n + ++ Format.line ++ "has type" ++ indentExpr givenType + ++ Format.line ++ "but it is expected to have type" ++ indentExpr expectedType; + match decl with + | Declaration.defnDecl { name := n, type := type, .. } => process n type + | Declaration.thmDecl { name := n, type := type, .. } => process n type + | _ => "(kernel) declaration type mismatch" -- TODO fix type checker, type mismatch for mutual decls does not have enough information +| declHasMVars env constName _ => mkCtx env {} opts $ "(kernel) declaration has metavariables " ++ constName +| declHasFVars env constName _ => mkCtx env {} opts $ "(kernel) declaration has free variables " ++ constName +| funExpected env lctx e => mkCtx env lctx opts $ "(kernel) function expected" ++ indentExpr e +| typeExpected env lctx e => mkCtx env lctx opts $ "(kernel) type expected" ++ indentExpr e +| letTypeMismatch env lctx n _ _ => mkCtx env lctx opts $ "(kernel) let-declaration type mismatch " ++ n +| exprTypeMismatch env lctx e _ => mkCtx env lctx opts $ "(kernel) type mismatch at " ++ indentExpr e +| appTypeMismatch env lctx e fnType argType => + mkCtx env lctx opts $ + "application type mismatch" ++ indentExpr e + ++ "argument has type" ++ indentExpr argType + ++ "but function has type" ++ indentExpr fnType +| invalidProj env lctx e => mkCtx env lctx opts $ "(kernel) invalid projection" ++ indentExpr e +| other msg => "(kernel) " ++ msg + +end KernelException end Lean diff --git a/stage0/src/Init/Lean/Meta/Basic.lean b/stage0/src/Init/Lean/Meta/Basic.lean index e1946f6420..96fa45cb92 100644 --- a/stage0/src/Init/Lean/Meta/Basic.lean +++ b/stage0/src/Init/Lean/Meta/Basic.lean @@ -11,6 +11,7 @@ import Init.Lean.Class import Init.Lean.ReducibilityAttrs import Init.Lean.Util.Trace import Init.Lean.Util.RecDepth +import Init.Lean.Util.Closure import Init.Lean.Meta.Exception import Init.Lean.Meta.DiscrTreeTypes import Init.Lean.Eval @@ -154,6 +155,9 @@ s ← get; pure s.mctx @[inline] def getEnv : MetaM Environment := do s ← get; pure s.env +@[inline] def setEnv (env : Environment) : MetaM Unit := do +modify $ fun s => { env := env, .. s } + def mkWHNFRef : IO (IO.Ref (Expr → MetaM Expr)) := IO.mkRef $ fun _ => throw $ Exception.other "whnf implementation was not set" @@ -811,6 +815,27 @@ mctx' ← getMCtx; modify $ fun s => { mctx := mctx, .. s }; finally x (modify $ fun s => { mctx := mctx', .. s }) +/-- + Create an auxiliary definition with the given name, type and value. + The parameters `type` and `value` may contain free and meta variables. + A "closure" is computed, and a term of the form `name.{u_1 ... u_n} t_1 ... t_m` is + returned where `u_i`s are universe parameters and metavariables `type` and `value` depend on, + and `t_j`s are free and meta variables `type` and `value` depend on. -/ +def mkAuxDefinition (name : Name) (type : Expr) (value : Expr) : MetaM Expr := do +env ← getEnv; +opts ← getOptions; +mctx ← getMCtx; +lctx ← getLCtx; +match Lean.mkAuxDefinition env opts mctx lctx name type value with +| Except.error ex => throw $ Exception.kernel ex opts +| Except.ok (e, env) => do setEnv env; pure e + +/-- Similar to `mkAuxDefinition`, but infers the type of `value`. -/ +def mkAuxDefinitionFor (name : Name) (value : Expr) : MetaM Expr := do +type ← inferType value; +let type := type.headBeta; +mkAuxDefinition name type value + @[init] private def regTraceClasses : IO Unit := do registerTraceClass `Meta; registerTraceClass `Meta.debug diff --git a/stage0/src/Init/Lean/Meta/Exception.lean b/stage0/src/Init/Lean/Meta/Exception.lean index 715be79fb7..5701cee854 100644 --- a/stage0/src/Init/Lean/Meta/Exception.lean +++ b/stage0/src/Init/Lean/Meta/Exception.lean @@ -37,6 +37,7 @@ inductive Exception | appBuilder (op : Name) (msg : String) (args : Array Expr) (ctx : ExceptionContext) | synthInstance (inst : Expr) (ctx : ExceptionContext) | tactic (tacticName : Name) (mvarId : MVarId) (msg : MessageData) (ctx : ExceptionContext) +| kernel (ex : KernelException) (opts : Options) | bug (b : Bug) (ctx : ExceptionContext) | other (msg : String) @@ -64,6 +65,7 @@ def toStr : Exception → String | appBuilder _ _ _ _ => "application builder failure" | synthInstance _ _ => "type class instance synthesis failed" | tactic tacName _ _ _ => "tactic '" ++ toString tacName ++ "' failed" +| kernel _ _ => "kernel exception" | bug _ _ => "bug" | other s => s @@ -93,6 +95,7 @@ def toTraceMessageData : Exception → MessageData | appBuilder op msg args ctx => mkCtx ctx $ `appBuilder ++ " " ++ op ++ " " ++ args ++ " " ++ msg | synthInstance inst ctx => mkCtx ctx $ `synthInstance ++ " " ++ inst | tactic tacName mvarId msg ctx => mkCtx ctx $ `tacticFailure ++ " " ++ tacName ++ " " ++ msg +| kernel ex opts => ex.toMessageData opts | bug _ _ => "internal bug" -- TODO improve | other s => s diff --git a/stage0/src/Init/Lean/Meta/Message.lean b/stage0/src/Init/Lean/Meta/Message.lean index fde90ecc32..7cc26d0fa3 100644 --- a/stage0/src/Init/Lean/Meta/Message.lean +++ b/stage0/src/Init/Lean/Meta/Message.lean @@ -7,10 +7,6 @@ prelude import Init.Lean.Meta.Basic namespace Lean - -def indentExpr (msg : MessageData) : MessageData := -MessageData.nest 2 (Format.line ++ msg) - namespace Meta namespace Exception @@ -79,13 +75,14 @@ def toMessageData : Exception → MessageData | appBuilder op msg args ctx => mkCtx ctx $ "application builder failure " ++ op ++ " " ++ args ++ " " ++ msg | synthInstance inst ctx => mkCtx ctx $ "failed to synthesize" ++ indentExpr inst | tactic tacName mvarId msg ctx => mkCtx ctx $ "tactic '" ++ tacName ++ "' failed, " ++ msg ++ Format.line ++ MessageData.ofGoal mvarId +| kernel ex opts => ex.toMessageData opts | bug _ _ => "internal bug" -- TODO improve | other s => s end Exception instance MetaHasEval {α} [MetaHasEval α] : MetaHasEval (MetaM α) := -⟨fun env opts x => do +⟨fun env opts x _ => do match x { config := { opts := opts }, currRecDepth := 0, maxRecDepth := getMaxRecDepth opts } { env := env } with | EStateM.Result.ok a s => do s.traceState.traces.forM $ fun m => IO.println $ format m; @@ -95,38 +92,4 @@ instance MetaHasEval {α} [MetaHasEval α] : MetaHasEval (MetaM α) := throw (IO.userError (toString (format err.toMessageData)))⟩ end Meta - -namespace KernelException - -private def mkCtx (env : Environment) (lctx : LocalContext) (opts : Options) (msg : MessageData) : MessageData := -MessageData.withContext { env := env, mctx := {}, lctx := lctx, opts := opts } msg - -def toMessageData (e : KernelException) (opts : Options) : MessageData := -match e with -| unknownConstant env constName => mkCtx env {} opts $ "(kernel) unknown constant " ++ constName -| alreadyDeclared env constName => mkCtx env {} opts $ "(kernel) constant has already been declared " ++ constName -| declTypeMismatch env decl givenType => - let process (n : Name) (expectedType : Expr) : MessageData := - "(kernel) declaration type mismatch " ++ n - ++ Format.line ++ "has type" ++ indentExpr givenType - ++ Format.line ++ "but it is expected to have type" ++ indentExpr expectedType; - match decl with - | Declaration.defnDecl { name := n, type := type, .. } => process n type - | Declaration.thmDecl { name := n, type := type, .. } => process n type - | _ => "(kernel) declaration type mismatch" -- TODO fix type checker, type mismatch for mutual decls does not have enough information -| declHasMVars env constName _ => mkCtx env {} opts $ "(kernel) declaration has metavariables " ++ constName -| declHasFVars env constName _ => mkCtx env {} opts $ "(kernel) declaration has free variables " ++ constName -| funExpected env lctx e => mkCtx env lctx opts $ "(kernel) function expected" ++ indentExpr e -| typeExpected env lctx e => mkCtx env lctx opts $ "(kernel) type expected" ++ indentExpr e -| letTypeMismatch env lctx n _ _ => mkCtx env lctx opts $ "(kernel) let-declaration type mismatch " ++ n -| exprTypeMismatch env lctx e _ => mkCtx env lctx opts $ "(kernel) type mismatch at " ++ indentExpr e -| appTypeMismatch env lctx e _ _ => - match e with - | Expr.app f a _ => "(kernel) " ++ Meta.Exception.mkAppTypeMismatchMessage f a { env := env, lctx := lctx, mctx := {}, opts := opts } - | _ => "(kernel) application type mismatch at" ++ indentExpr e -| invalidProj env lctx e => mkCtx env lctx opts $ "(kernel) invalid projection" ++ indentExpr e -| other msg => "(kernel) " ++ msg - -end KernelException - end Lean diff --git a/stage0/src/Init/Lean/Parser/Parser.lean b/stage0/src/Init/Lean/Parser/Parser.lean index 7fd57d4cbd..c8d57d0e05 100644 --- a/stage0/src/Init/Lean/Parser/Parser.lean +++ b/stage0/src/Init/Lean/Parser/Parser.lean @@ -110,7 +110,10 @@ private def expectedToString : List String → String protected def toString (e : Error) : String := let unexpected := if e.unexpected == "" then [] else [e.unexpected]; -let expected := if e.expected == [] then [] else ["expected " ++ expectedToString e.expected]; +let expected := if e.expected == [] then [] else + let expected := e.expected.toArray.qsort (fun e e' => e < e'); + let expected := expected.toList.eraseReps; + ["expected " ++ expectedToString expected]; "; ".intercalate $ unexpected ++ expected instance : HasToString Error := ⟨Error.toString⟩ diff --git a/stage0/src/Init/Lean/Syntax.lean b/stage0/src/Init/Lean/Syntax.lean index 1658f2f37d..a2dd0f8f36 100644 --- a/stage0/src/Init/Lean/Syntax.lean +++ b/stage0/src/Init/Lean/Syntax.lean @@ -253,12 +253,15 @@ match setHeadInfoAux info stx with | some stx => stx | none => stx -partial def replaceInfo (info : SourceInfo) : Syntax → Syntax +def setInfo (info : SourceInfo) : Syntax → Syntax | atom _ val => atom info val | ident _ rawVal val pre => ident info rawVal val pre -| node k args => node k $ args.map replaceInfo | stx => stx +partial def replaceInfo (info : SourceInfo) : Syntax → Syntax +| node k args => node k $ args.map replaceInfo +| stx => setInfo info stx + private def reprintLeaf : Option SourceInfo → String → String -- no source info => add gracious amounts of whitespace to definitely separate tokens -- Note that the proper pretty printer does not use this function. @@ -281,9 +284,14 @@ partial def reprint : Syntax → Option String open Lean.Format -partial def formatStxAux (maxDepth : Option Nat) : Nat → Syntax → Format -| _, atom info val => format $ repr val -| _, ident _ _ val pre => format "`" ++ format val +private def formatInfo (showPos : Bool) (info : Option SourceInfo) : Format := +match info, showPos with +| some info, true => ":" ++ toString info.pos +| _, _ => "" + +partial def formatStxAux (maxDepth : Option Nat) (showPos : Bool) : Nat → Syntax → Format +| _, atom info val => format (repr val) ++ formatInfo showPos info +| _, ident info _ val pre => format "`" ++ format val ++ formatInfo showPos info | _, missing => "" | depth, node kind args => let depth := depth + 1; @@ -300,8 +308,8 @@ partial def formatStxAux (maxDepth : Option Nat) : Nat → Syntax → Format if depth > maxDepth.getD depth then [".."] else args.toList.map (formatStxAux depth); paren $ joinSep (header :: body) line -def formatStx (stx : Syntax) (maxDepth : Option Nat := none) : Format := -formatStxAux maxDepth 0 stx +def formatStx (stx : Syntax) (maxDepth : Option Nat := none) (showPos := false) : Format := +formatStxAux maxDepth showPos 0 stx instance : HasFormat (Syntax) := ⟨formatStx⟩ instance : HasToString (Syntax) := ⟨toString ∘ format⟩ @@ -339,4 +347,41 @@ mkStxStrLit val def mkStxNumLitAux (val : Nat) : Syntax := mkStxNumLit (toString val) + +/-- Reflect a runtime datum back to surface syntax (best-effort). -/ +class HasQuote (α : Type) := +(quote : α → Syntax) + +export HasQuote (quote) + +instance Syntax.HasQuote : HasQuote Syntax := ⟨id⟩ +instance String.HasQuote : HasQuote String := ⟨fun s => Syntax.node `Lean.Parser.Term.str #[mkStxStrLit s]⟩ +instance Nat.HasQuote : HasQuote Nat := ⟨fun n => Syntax.node `Lean.Parser.Term.num #[mkStxNumLit $ toString n]⟩ +instance Substring.HasQuote : HasQuote Substring := ⟨fun s => mkCAppStx `String.toSubstring #[quote s.toString]⟩ + +private def quoteName : Name → Syntax +| Name.anonymous => mkCTermId `Lean.Name.anonymous +| Name.str n s _ => mkCAppStx `Lean.mkNameStr #[quoteName n, quote s] +| Name.num n i _ => mkCAppStx `Lean.mkNameNum #[quoteName n, quote i] + +instance Name.hasQuote : HasQuote Name := ⟨quoteName⟩ + +instance Prod.hasQuote {α β : Type} [HasQuote α] [HasQuote β] : HasQuote (α × β) := +⟨fun ⟨a, b⟩ => mkCAppStx `Prod.mk #[quote a, quote b]⟩ + +private def quoteList {α : Type} [HasQuote α] : List α → Syntax +| [] => mkCTermId `List.nil +| (x::xs) => mkCAppStx `List.cons #[quote x, quoteList xs] + +instance List.hasQuote {α : Type} [HasQuote α] : HasQuote (List α) := ⟨quoteList⟩ + +instance Array.hasQuote {α : Type} [HasQuote α] : HasQuote (Array α) := +⟨fun xs => mkCAppStx `List.toArray #[quote xs.toList]⟩ + +private def quoteOption {α : Type} [HasQuote α] : Option α → Syntax +| none => mkTermId `Option.none +| (some x) => mkCAppStx `Option.some #[quote x] + +instance Option.hasQuote {α : Type} [HasQuote α] : HasQuote (Option α) := ⟨quoteOption⟩ + end Lean diff --git a/stage0/src/Init/Lean/Util/Closure.lean b/stage0/src/Init/Lean/Util/Closure.lean new file mode 100644 index 0000000000..9d23965d42 --- /dev/null +++ b/stage0/src/Init/Lean/Util/Closure.lean @@ -0,0 +1,194 @@ +/- +Copyright (c) 2020 Microsoft Corporation. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Leonardo de Moura +-/ +import Init.Lean.MetavarContext +import Init.Lean.Environment +import Init.Lean.Util.FoldConsts + +namespace Lean +namespace Closure + +structure Context := +(mctx : MetavarContext) +(lctxInput : LocalContext) + +structure State := +(lctxOutput : LocalContext := {}) +(ngen : NameGenerator := { namePrefix := `_closure }) +(visitedLevel : LevelMap Level := {}) +(visitedExpr : ExprStructMap Expr := {}) +(levelParams : Array Name := #[]) +(nextLevelIdx : Nat := 1) +(levelClosure : Array Level := #[]) +(nextExprIdx : Nat := 1) +(exprClosure : Array Expr := #[]) + +def Exception := String + +abbrev ClosureM := ReaderT Context (EStateM Exception State) + +@[inline] def visitLevel (f : Level → ClosureM Level) (u : Level) : ClosureM Level := +if !u.hasMVar && !u.hasParam then pure u +else do + s ← get; + match s.visitedLevel.find? u with + | some v => pure v + | none => do + v ← f u; + modify $ fun s => { visitedLevel := s.visitedLevel.insert u v, .. s }; + pure v + +def mkNewLevelParam (u : Level) : ClosureM Level := do +s ← get; +let p := (`u).appendIndexAfter s.nextLevelIdx; +modify $ fun s => { levelParams := s.levelParams.push p, nextLevelIdx := s.nextLevelIdx + 1, levelClosure := s.levelClosure.push u, .. s }; +pure $ mkLevelParam p + +partial def collectLevelAux : Level → ClosureM Level +| u@(Level.succ v _) => do v ← visitLevel collectLevelAux v; pure $ u.updateSucc! v +| u@(Level.max v w _) => do v ← visitLevel collectLevelAux v; w ← visitLevel collectLevelAux w; pure $ u.updateMax! v w +| u@(Level.imax v w _) => do v ← visitLevel collectLevelAux v; w ← visitLevel collectLevelAux w; pure $ u.updateIMax! v w +| u@(Level.mvar _ _) => mkNewLevelParam u +| u@(Level.param _ _) => mkNewLevelParam u +| u@(Level.zero _) => pure u + +def collectLevel (u : Level) : ClosureM Level := +visitLevel collectLevelAux u + +def mkFreshFVarId : ClosureM FVarId := do +s ← get; +let id := s.ngen.curr; +modify $ fun s => { ngen := s.ngen.next, .. s }; +pure id + +/-- + Remark: This method does not guarantee unique user names. + The correctness of the procedure does not rely on unique user names. + Recall that the pretty printer takes care of unintended collisions. -/ +def mkNextUserName : ClosureM Name := do +s ← get; +let n := (`_x).appendIndexAfter s.nextExprIdx; +modify $ fun s => { nextExprIdx := s.nextExprIdx + 1, .. s }; +pure n + +def getUserName (userName? : Option Name) : ClosureM Name := +match userName? with +| some userName => pure userName +| none => mkNextUserName + +def mkLocalDecl (userName? : Option Name) (type : Expr) : ClosureM Expr := do +userName ← getUserName userName?; +fvarId ← mkFreshFVarId; +modify $ fun s => { lctxOutput := s.lctxOutput.mkLocalDecl fvarId userName type, .. s }; +pure $ mkFVar fvarId + +def mkLetDecl (userName : Name) (type : Expr) (value : Expr) : ClosureM Expr := do +fvarId ← mkFreshFVarId; +modify $ fun s => { lctxOutput := s.lctxOutput.mkLetDecl fvarId userName type value, .. s }; +pure $ mkFVar fvarId + +@[inline] def visitExpr (f : Expr → ClosureM Expr) (e : Expr) : ClosureM Expr := +if !e.hasLevelParam && !e.hasFVar && !e.hasMVar then pure e +else do + s ← get; + match s.visitedExpr.find? e with + | some r => pure r + | none => do + r ← f e; + modify $ fun s => { visitedExpr := s.visitedExpr.insert e r, .. s }; + pure r + +partial def collectExprAux : Expr → ClosureM Expr +| e => + let collect (e : Expr) := visitExpr collectExprAux e; + match e with + | Expr.proj _ _ s _ => do s ← collect s; pure (e.updateProj! s) + | Expr.forallE _ d b _ => do d ← collect d; b ← collect b; pure (e.updateForallE! d b) + | Expr.lam _ d b _ => do d ← collect d; b ← collect b; pure (e.updateLambdaE! d b) + | Expr.letE _ t v b _ => do t ← collect t; v ← collect v; b ← collect b; pure (e.updateLet! t v b) + | Expr.app f a _ => do f ← collect f; a ← collect a; pure (e.updateApp! f a) + | Expr.mdata _ b _ => do b ← collect b; pure (e.updateMData! b) + | Expr.sort u _ => do u ← collectLevel u; pure (e.updateSort! u) + | Expr.const c us _ => do us ← us.mapM collectLevel; pure (e.updateConst! us) + | Expr.mvar mvarId _ => do + ctx ← read; + match ctx.mctx.findDecl? mvarId with + | none => throw "unknown metavariable" + | some mvarDecl => do + type ← collect mvarDecl.type; + x ← mkLocalDecl none type; + modify $ fun s => { exprClosure := s.exprClosure.push e, .. s }; + pure x + | Expr.fvar fvarId _ => do + ctx ← read; + match ctx.lctxInput.find? fvarId with + | none => throw "unknown free variable" + | some (LocalDecl.cdecl _ _ userName type _) => do + type ← collect type; + x ← mkLocalDecl userName type; + modify $ fun s => { exprClosure := s.exprClosure.push e, .. s }; + pure x + | some (LocalDecl.ldecl _ _ userName type value) => do + type ← collect type; + value ← collect value; + -- Note that let-declarations do not need to be provided to the closure being constructed. + mkLetDecl userName type value + | e => pure e + +def collectExpr (e : Expr) : ClosureM Expr := +visitExpr collectExprAux e + +structure MkClosureResult := +(levelParams : Array Name) +(type : Expr) +(value : Expr) +(levelClosure : Array Level) +(exprClosure : Array Expr) + +def mkClosure (mctx : MetavarContext) (lctx : LocalContext) (type : Expr) (value : Expr) : Except String MkClosureResult := +let shareCommonTypeValue : ShareCommonM (Expr × Expr) := do { + type ← withShareCommon type; + value ← withShareCommon value; + pure (type, value) +}; +let (type, value) := shareCommonTypeValue.run; +let mkTypeValue : ClosureM (Expr × Expr) := do { + type ← collectExpr type; + value ← collectExpr value; + pure (type, value) +}; +match (mkTypeValue { mctx := mctx, lctxInput := lctx }).run {} with +| EStateM.Result.ok (type, value) s => + let fvars := s.lctxOutput.getFVars; + let type := s.lctxOutput.mkForall fvars type; + let value := s.lctxOutput.mkLambda fvars value; + Except.ok { + levelParams := s.levelParams, + type := type, + value := value, + levelClosure := s.levelClosure, + exprClosure := s.exprClosure } +| EStateM.Result.error ex s => Except.error ex + +end Closure + +def mkAuxDefinition (env : Environment) (opts : Options) (mctx : MetavarContext) (lctx : LocalContext) (name : Name) (type : Expr) (value : Expr) + : Except KernelException (Expr × Environment) := +match Closure.mkClosure mctx lctx type value with +| Except.error ex => throw $ KernelException.other ex +| Except.ok result => do + let decl := Declaration.defnDecl { + name := name, + lparams := result.levelParams.toList, + type := result.type, + value := result.value, + hints := ReducibilityHints.regular (getMaxHeight env result.value + 1), + isUnsafe := env.hasUnsafe result.type || env.hasUnsafe result.value + }; + env ← env.addAndCompile opts decl; + let c := mkAppN (mkConst name result.levelClosure.toList) result.exprClosure; + pure (c, env) + +end Lean diff --git a/stage0/src/Init/System/IO.lean b/stage0/src/Init/System/IO.lean index 92dffbaa5c..903be6b018 100644 --- a/stage0/src/Init/System/IO.lean +++ b/stage0/src/Init/System/IO.lean @@ -308,16 +308,17 @@ namespace Lean /-- Typeclass used for presenting the output of an `#eval` command. -/ class HasEval (α : Type u) := -(eval : α → IO Unit) +-- We default `hideUnit` to `true`, but set it to `false` in the direct call from `#eval` +-- so that `()` output is hidden in chained instances such as for some `m Unit`. +(eval : α → forall (hideUnit : optParam Bool true), IO Unit) -instance HasRepr.HasEval {α : Type u} [HasRepr α] : HasEval α := -⟨fun a => IO.println (repr a)⟩ +instance HasRepr.hasEval {α : Type u} [HasRepr α] : HasEval α := +⟨fun a _ => IO.println (repr a)⟩ + +instance Unit.hasEval : HasEval Unit := +⟨fun u hideUnit => if hideUnit then pure () else IO.println (repr u)⟩ instance IO.HasEval {α : Type} [HasEval α] : HasEval (IO α) := -⟨fun x => do a ← x; HasEval.eval a⟩ - --- special case: do not print `()` -instance IOUnit.HasEval : HasEval (IO Unit) := -⟨fun x => x⟩ +⟨fun x _ => do a ← x; HasEval.eval a⟩ end Lean diff --git a/stage0/src/Init/System/IOError.lean b/stage0/src/Init/System/IOError.lean index e97905f1d8..9696c4e412 100644 --- a/stage0/src/Init/System/IOError.lean +++ b/stage0/src/Init/System/IOError.lean @@ -59,7 +59,7 @@ IO.Error.userError s namespace IO.Error @[export lean_mk_io_error_eof] -def mkEofError : IO.Error := unexpectedEof +def mkEofError : Unit → IO.Error := fun _ => unexpectedEof @[export lean_mk_io_error_inappropriate_type_file] def mkInappropriateTypeFile : String → UInt32 → String → IO.Error := diff --git a/stage0/src/frontends/lean/builtin_cmds.cpp b/stage0/src/frontends/lean/builtin_cmds.cpp index 3b31593497..0b39432212 100644 --- a/stage0/src/frontends/lean/builtin_cmds.cpp +++ b/stage0/src/frontends/lean/builtin_cmds.cpp @@ -349,12 +349,12 @@ static environment eval_cmd(parser & p) { } catch (exception &) {} if (meta_eval_instance) { - /* Modify the 'program' to (fun env opts => MetaHasEval.eval env opts e) */ + /* Modify the 'program' to (fun env opts => MetaHasEval.eval (hideUnit := false) env opts e) */ expr env = tc.push_local("env", mk_const({"Lean", "Environment"})); expr opts = tc.push_local("opts", mk_const({"Lean", "Options"})); e = tc.mk_lambda(env, tc.mk_lambda(opts, - mk_app(tc, {"Lean", "MetaHasEval", "eval"}, 5, - {type, *meta_eval_instance, env, opts, e}))); + mk_app(tc, {"Lean", "MetaHasEval", "eval"}, 6, + {type, *meta_eval_instance, env, opts, e, mk_bool_false()}))); // run `Environment -> Options -> IO Unit` args = { p.env().to_obj_arg(), p.get_options().to_obj_arg(), io_mk_world() }; } else { @@ -365,8 +365,8 @@ static environment eval_cmd(parser & p) { } catch (exception &) {} if (eval_instance) { - /* Modify the 'program' to (HasEval.eval e) */ - e = mk_app(tc, {"Lean", "HasEval", "eval"}, 3, type, *eval_instance, e); + /* Modify the 'program' to (HasEval.eval (hideUnit := false) e) */ + e = mk_app(tc, {"Lean", "HasEval", "eval"}, 4, {type, *eval_instance, e, mk_bool_false()}); // run `IO Unit` args = { io_mk_world() }; } else { diff --git a/stage0/stdlib/CMakeLists.txt b/stage0/stdlib/CMakeLists.txt index b804ceb4ef..b074773794 100644 --- a/stage0/stdlib/CMakeLists.txt +++ b/stage0/stdlib/CMakeLists.txt @@ -1 +1 @@ -add_library (stage0 OBJECT Init/./Coe.c Init/./Control.c Init/./Control/Alternative.c Init/./Control/Applicative.c Init/./Control/Conditional.c Init/./Control/EState.c Init/./Control/Except.c Init/./Control/Functor.c Init/./Control/Id.c Init/./Control/Lift.c Init/./Control/Monad.c Init/./Control/Option.c Init/./Control/Reader.c Init/./Control/State.c Init/./Core.c Init/./Data.c Init/./Data/Array.c Init/./Data/Array/Basic.c Init/./Data/Array/BinSearch.c Init/./Data/Array/QSort.c Init/./Data/AssocList.c Init/./Data/Basic.c Init/./Data/BinomialHeap.c Init/./Data/BinomialHeap/Basic.c Init/./Data/ByteArray.c Init/./Data/ByteArray/Basic.c Init/./Data/Char.c Init/./Data/Char/Basic.c Init/./Data/DList.c Init/./Data/Fin.c Init/./Data/Fin/Basic.c Init/./Data/HashMap.c Init/./Data/HashMap/Basic.c Init/./Data/HashSet.c Init/./Data/Hashable.c Init/./Data/Int.c Init/./Data/Int/Basic.c Init/./Data/List.c Init/./Data/List/Basic.c Init/./Data/List/BasicAux.c Init/./Data/List/Control.c Init/./Data/List/Instances.c Init/./Data/Nat.c Init/./Data/Nat/Basic.c Init/./Data/Nat/Bitwise.c Init/./Data/Nat/Control.c Init/./Data/Nat/Div.c Init/./Data/Option.c Init/./Data/Option/Basic.c Init/./Data/Option/BasicAux.c Init/./Data/Option/Instances.c Init/./Data/PersistentArray.c Init/./Data/PersistentArray/Basic.c Init/./Data/PersistentHashMap.c Init/./Data/PersistentHashMap/Basic.c Init/./Data/PersistentHashSet.c Init/./Data/Queue.c Init/./Data/Queue/Basic.c Init/./Data/RBMap.c Init/./Data/RBMap/Basic.c Init/./Data/RBMap/BasicAux.c Init/./Data/RBTree.c Init/./Data/RBTree/Basic.c Init/./Data/Random.c Init/./Data/Repr.c Init/./Data/Stack.c Init/./Data/Stack/Basic.c Init/./Data/String.c Init/./Data/String/Basic.c Init/./Data/ToString.c Init/./Data/UInt.c Init/./Default.c Init/./Fix.c Init/./HasCoe.c Init/./Lean.c Init/./Lean/Attributes.c Init/./Lean/AuxRecursor.c Init/./Lean/Class.c Init/./Lean/Compiler.c Init/./Lean/Compiler/ClosedTermCache.c Init/./Lean/Compiler/ConstFolding.c Init/./Lean/Compiler/ExportAttr.c Init/./Lean/Compiler/ExternAttr.c Init/./Lean/Compiler/IR.c Init/./Lean/Compiler/IR/Basic.c Init/./Lean/Compiler/IR/Borrow.c Init/./Lean/Compiler/IR/Boxing.c Init/./Lean/Compiler/IR/Checker.c Init/./Lean/Compiler/IR/CompilerM.c Init/./Lean/Compiler/IR/CtorLayout.c Init/./Lean/Compiler/IR/ElimDeadBranches.c Init/./Lean/Compiler/IR/ElimDeadVars.c Init/./Lean/Compiler/IR/EmitC.c Init/./Lean/Compiler/IR/EmitUtil.c Init/./Lean/Compiler/IR/ExpandResetReuse.c Init/./Lean/Compiler/IR/Format.c Init/./Lean/Compiler/IR/FreeVars.c Init/./Lean/Compiler/IR/LiveVars.c Init/./Lean/Compiler/IR/NormIds.c Init/./Lean/Compiler/IR/PushProj.c Init/./Lean/Compiler/IR/RC.c Init/./Lean/Compiler/IR/ResetReuse.c Init/./Lean/Compiler/IR/SimpCase.c Init/./Lean/Compiler/IR/UnboxResult.c Init/./Lean/Compiler/ImplementedByAttr.c Init/./Lean/Compiler/InitAttr.c Init/./Lean/Compiler/InlineAttrs.c Init/./Lean/Compiler/NameMangling.c Init/./Lean/Compiler/NeverExtractAttr.c Init/./Lean/Compiler/Specialize.c Init/./Lean/Compiler/Util.c Init/./Lean/Data/Format.c Init/./Lean/Data/KVMap.c Init/./Lean/Data/LBool.c Init/./Lean/Data/LOption.c Init/./Lean/Data/Name.c Init/./Lean/Data/Occurrences.c Init/./Lean/Data/Options.c Init/./Lean/Data/Position.c Init/./Lean/Data/SMap.c Init/./Lean/Data/Trie.c Init/./Lean/Declaration.c Init/./Lean/Delaborator.c Init/./Lean/Elab.c Init/./Lean/Elab/Alias.c Init/./Lean/Elab/App.c Init/./Lean/Elab/Binders.c Init/./Lean/Elab/BuiltinNotation.c Init/./Lean/Elab/Command.c Init/./Lean/Elab/DeclModifiers.c Init/./Lean/Elab/Declaration.c Init/./Lean/Elab/Definition.c Init/./Lean/Elab/DoNotation.c Init/./Lean/Elab/Exception.c Init/./Lean/Elab/Frontend.c Init/./Lean/Elab/Import.c Init/./Lean/Elab/Level.c Init/./Lean/Elab/Log.c Init/./Lean/Elab/Match.c Init/./Lean/Elab/Quotation.c Init/./Lean/Elab/ResolveName.c Init/./Lean/Elab/StrategyAttrs.c Init/./Lean/Elab/StructInst.c Init/./Lean/Elab/Syntax.c Init/./Lean/Elab/SyntheticMVars.c Init/./Lean/Elab/Tactic.c Init/./Lean/Elab/Tactic/Basic.c Init/./Lean/Elab/Tactic/ElabTerm.c Init/./Lean/Elab/Tactic/Generalize.c Init/./Lean/Elab/Tactic/Induction.c Init/./Lean/Elab/Tactic/Injection.c Init/./Lean/Elab/Term.c Init/./Lean/Elab/Util.c Init/./Lean/Environment.c Init/./Lean/EqnCompiler.c Init/./Lean/EqnCompiler/MatchPattern.c Init/./Lean/Eval.c Init/./Lean/Expr.c Init/./Lean/HeadIndex.c Init/./Lean/Hygiene.c Init/./Lean/KeyedDeclsAttribute.c Init/./Lean/Level.c Init/./Lean/Linter.c Init/./Lean/LocalContext.c Init/./Lean/Message.c Init/./Lean/Meta.c Init/./Lean/Meta/AbstractMVars.c Init/./Lean/Meta/AppBuilder.c Init/./Lean/Meta/Basic.c Init/./Lean/Meta/Check.c Init/./Lean/Meta/DiscrTree.c Init/./Lean/Meta/DiscrTreeTypes.c Init/./Lean/Meta/Exception.c Init/./Lean/Meta/ExprDefEq.c Init/./Lean/Meta/FunInfo.c Init/./Lean/Meta/InferType.c Init/./Lean/Meta/Instances.c Init/./Lean/Meta/KAbstract.c Init/./Lean/Meta/LevelDefEq.c Init/./Lean/Meta/Message.c Init/./Lean/Meta/Offset.c Init/./Lean/Meta/RecursorInfo.c Init/./Lean/Meta/Reduce.c Init/./Lean/Meta/SynthInstance.c Init/./Lean/Meta/Tactic.c Init/./Lean/Meta/Tactic/Apply.c Init/./Lean/Meta/Tactic/Assert.c Init/./Lean/Meta/Tactic/Assumption.c Init/./Lean/Meta/Tactic/Cases.c Init/./Lean/Meta/Tactic/Clear.c Init/./Lean/Meta/Tactic/FVarSubst.c Init/./Lean/Meta/Tactic/Generalize.c Init/./Lean/Meta/Tactic/Induction.c Init/./Lean/Meta/Tactic/Injection.c Init/./Lean/Meta/Tactic/Intro.c Init/./Lean/Meta/Tactic/LocalDecl.c Init/./Lean/Meta/Tactic/Revert.c Init/./Lean/Meta/Tactic/Rewrite.c Init/./Lean/Meta/Tactic/Subst.c Init/./Lean/Meta/Tactic/Target.c Init/./Lean/Meta/Tactic/Util.c Init/./Lean/Meta/WHNF.c Init/./Lean/MetavarContext.c Init/./Lean/Modifiers.c Init/./Lean/Parser.c Init/./Lean/Parser/Command.c Init/./Lean/Parser/Level.c Init/./Lean/Parser/Module.c Init/./Lean/Parser/Parser.c Init/./Lean/Parser/Syntax.c Init/./Lean/Parser/Tactic.c Init/./Lean/Parser/Term.c Init/./Lean/Parser/Transform.c Init/./Lean/ProjFns.c Init/./Lean/ReducibilityAttrs.c Init/./Lean/Runtime.c Init/./Lean/Scopes.c Init/./Lean/Structure.c Init/./Lean/Syntax.c Init/./Lean/ToExpr.c Init/./Lean/Util.c Init/./Lean/Util/CollectFVars.c Init/./Lean/Util/CollectLevelParams.c Init/./Lean/Util/CollectMVars.c Init/./Lean/Util/FindExpr.c Init/./Lean/Util/FindMVar.c Init/./Lean/Util/FoldConsts.c Init/./Lean/Util/MonadCache.c Init/./Lean/Util/PPExt.c Init/./Lean/Util/PPGoal.c Init/./Lean/Util/Path.c Init/./Lean/Util/Profile.c Init/./Lean/Util/RecDepth.c Init/./Lean/Util/Recognizers.c Init/./Lean/Util/ReplaceExpr.c Init/./Lean/Util/Sorry.c Init/./Lean/Util/Trace.c Init/./Lean/Util/WHNF.c Init/./LeanInit.c Init/./ShareCommon.c Init/./System.c Init/./System/FilePath.c Init/./System/IO.c Init/./System/IOError.c Init/./System/Platform.c Init/./Util.c Init/./WF.c) +add_library (stage0 OBJECT Init/./Coe.c Init/./Control.c Init/./Control/Alternative.c Init/./Control/Applicative.c Init/./Control/Conditional.c Init/./Control/EState.c Init/./Control/Except.c Init/./Control/Functor.c Init/./Control/Id.c Init/./Control/Lift.c Init/./Control/Monad.c Init/./Control/Option.c Init/./Control/Reader.c Init/./Control/State.c Init/./Core.c Init/./Data.c Init/./Data/Array.c Init/./Data/Array/Basic.c Init/./Data/Array/BinSearch.c Init/./Data/Array/QSort.c Init/./Data/AssocList.c Init/./Data/Basic.c Init/./Data/BinomialHeap.c Init/./Data/BinomialHeap/Basic.c Init/./Data/ByteArray.c Init/./Data/ByteArray/Basic.c Init/./Data/Char.c Init/./Data/Char/Basic.c Init/./Data/DList.c Init/./Data/Fin.c Init/./Data/Fin/Basic.c Init/./Data/HashMap.c Init/./Data/HashMap/Basic.c Init/./Data/HashSet.c Init/./Data/Hashable.c Init/./Data/Int.c Init/./Data/Int/Basic.c Init/./Data/List.c Init/./Data/List/Basic.c Init/./Data/List/BasicAux.c Init/./Data/List/Control.c Init/./Data/List/Instances.c Init/./Data/Nat.c Init/./Data/Nat/Basic.c Init/./Data/Nat/Bitwise.c Init/./Data/Nat/Control.c Init/./Data/Nat/Div.c Init/./Data/Option.c Init/./Data/Option/Basic.c Init/./Data/Option/BasicAux.c Init/./Data/Option/Instances.c Init/./Data/PersistentArray.c Init/./Data/PersistentArray/Basic.c Init/./Data/PersistentHashMap.c Init/./Data/PersistentHashMap/Basic.c Init/./Data/PersistentHashSet.c Init/./Data/Queue.c Init/./Data/Queue/Basic.c Init/./Data/RBMap.c Init/./Data/RBMap/Basic.c Init/./Data/RBMap/BasicAux.c Init/./Data/RBTree.c Init/./Data/RBTree/Basic.c Init/./Data/Random.c Init/./Data/Repr.c Init/./Data/Stack.c Init/./Data/Stack/Basic.c Init/./Data/String.c Init/./Data/String/Basic.c Init/./Data/ToString.c Init/./Data/UInt.c Init/./Default.c Init/./Fix.c Init/./HasCoe.c Init/./Lean.c Init/./Lean/Attributes.c Init/./Lean/AuxRecursor.c Init/./Lean/Class.c Init/./Lean/Compiler.c Init/./Lean/Compiler/ClosedTermCache.c Init/./Lean/Compiler/ConstFolding.c Init/./Lean/Compiler/ExportAttr.c Init/./Lean/Compiler/ExternAttr.c Init/./Lean/Compiler/IR.c Init/./Lean/Compiler/IR/Basic.c Init/./Lean/Compiler/IR/Borrow.c Init/./Lean/Compiler/IR/Boxing.c Init/./Lean/Compiler/IR/Checker.c Init/./Lean/Compiler/IR/CompilerM.c Init/./Lean/Compiler/IR/CtorLayout.c Init/./Lean/Compiler/IR/ElimDeadBranches.c Init/./Lean/Compiler/IR/ElimDeadVars.c Init/./Lean/Compiler/IR/EmitC.c Init/./Lean/Compiler/IR/EmitUtil.c Init/./Lean/Compiler/IR/ExpandResetReuse.c Init/./Lean/Compiler/IR/Format.c Init/./Lean/Compiler/IR/FreeVars.c Init/./Lean/Compiler/IR/LiveVars.c Init/./Lean/Compiler/IR/NormIds.c Init/./Lean/Compiler/IR/PushProj.c Init/./Lean/Compiler/IR/RC.c Init/./Lean/Compiler/IR/ResetReuse.c Init/./Lean/Compiler/IR/SimpCase.c Init/./Lean/Compiler/IR/UnboxResult.c Init/./Lean/Compiler/ImplementedByAttr.c Init/./Lean/Compiler/InitAttr.c Init/./Lean/Compiler/InlineAttrs.c Init/./Lean/Compiler/NameMangling.c Init/./Lean/Compiler/NeverExtractAttr.c Init/./Lean/Compiler/Specialize.c Init/./Lean/Compiler/Util.c Init/./Lean/Data/Format.c Init/./Lean/Data/KVMap.c Init/./Lean/Data/LBool.c Init/./Lean/Data/LOption.c Init/./Lean/Data/Name.c Init/./Lean/Data/Occurrences.c Init/./Lean/Data/Options.c Init/./Lean/Data/Position.c Init/./Lean/Data/SMap.c Init/./Lean/Data/Trie.c Init/./Lean/Declaration.c Init/./Lean/Delaborator.c Init/./Lean/Elab.c Init/./Lean/Elab/Alias.c Init/./Lean/Elab/App.c Init/./Lean/Elab/Binders.c Init/./Lean/Elab/BuiltinNotation.c Init/./Lean/Elab/Command.c Init/./Lean/Elab/DeclModifiers.c Init/./Lean/Elab/Declaration.c Init/./Lean/Elab/Definition.c Init/./Lean/Elab/DoNotation.c Init/./Lean/Elab/Exception.c Init/./Lean/Elab/Frontend.c Init/./Lean/Elab/Import.c Init/./Lean/Elab/Level.c Init/./Lean/Elab/Log.c Init/./Lean/Elab/Match.c Init/./Lean/Elab/Quotation.c Init/./Lean/Elab/ResolveName.c Init/./Lean/Elab/StrategyAttrs.c Init/./Lean/Elab/StructInst.c Init/./Lean/Elab/Syntax.c Init/./Lean/Elab/SyntheticMVars.c Init/./Lean/Elab/Tactic.c Init/./Lean/Elab/Tactic/Basic.c Init/./Lean/Elab/Tactic/ElabTerm.c Init/./Lean/Elab/Tactic/Generalize.c Init/./Lean/Elab/Tactic/Induction.c Init/./Lean/Elab/Tactic/Injection.c Init/./Lean/Elab/Term.c Init/./Lean/Elab/Util.c Init/./Lean/Environment.c Init/./Lean/EqnCompiler.c Init/./Lean/EqnCompiler/MatchPattern.c Init/./Lean/Eval.c Init/./Lean/Expr.c Init/./Lean/HeadIndex.c Init/./Lean/Hygiene.c Init/./Lean/KeyedDeclsAttribute.c Init/./Lean/Level.c Init/./Lean/Linter.c Init/./Lean/LocalContext.c Init/./Lean/Message.c Init/./Lean/Meta.c Init/./Lean/Meta/AbstractMVars.c Init/./Lean/Meta/AppBuilder.c Init/./Lean/Meta/Basic.c Init/./Lean/Meta/Check.c Init/./Lean/Meta/DiscrTree.c Init/./Lean/Meta/DiscrTreeTypes.c Init/./Lean/Meta/Exception.c Init/./Lean/Meta/ExprDefEq.c Init/./Lean/Meta/FunInfo.c Init/./Lean/Meta/InferType.c Init/./Lean/Meta/Instances.c Init/./Lean/Meta/KAbstract.c Init/./Lean/Meta/LevelDefEq.c Init/./Lean/Meta/Message.c Init/./Lean/Meta/Offset.c Init/./Lean/Meta/RecursorInfo.c Init/./Lean/Meta/Reduce.c Init/./Lean/Meta/SynthInstance.c Init/./Lean/Meta/Tactic.c Init/./Lean/Meta/Tactic/Apply.c Init/./Lean/Meta/Tactic/Assert.c Init/./Lean/Meta/Tactic/Assumption.c Init/./Lean/Meta/Tactic/Cases.c Init/./Lean/Meta/Tactic/Clear.c Init/./Lean/Meta/Tactic/FVarSubst.c Init/./Lean/Meta/Tactic/Generalize.c Init/./Lean/Meta/Tactic/Induction.c Init/./Lean/Meta/Tactic/Injection.c Init/./Lean/Meta/Tactic/Intro.c Init/./Lean/Meta/Tactic/LocalDecl.c Init/./Lean/Meta/Tactic/Revert.c Init/./Lean/Meta/Tactic/Rewrite.c Init/./Lean/Meta/Tactic/Subst.c Init/./Lean/Meta/Tactic/Target.c Init/./Lean/Meta/Tactic/Util.c Init/./Lean/Meta/WHNF.c Init/./Lean/MetavarContext.c Init/./Lean/Modifiers.c Init/./Lean/Parser.c Init/./Lean/Parser/Command.c Init/./Lean/Parser/Level.c Init/./Lean/Parser/Module.c Init/./Lean/Parser/Parser.c Init/./Lean/Parser/Syntax.c Init/./Lean/Parser/Tactic.c Init/./Lean/Parser/Term.c Init/./Lean/Parser/Transform.c Init/./Lean/ProjFns.c Init/./Lean/ReducibilityAttrs.c Init/./Lean/Runtime.c Init/./Lean/Scopes.c Init/./Lean/Structure.c Init/./Lean/Syntax.c Init/./Lean/ToExpr.c Init/./Lean/Util.c Init/./Lean/Util/Closure.c Init/./Lean/Util/CollectFVars.c Init/./Lean/Util/CollectLevelParams.c Init/./Lean/Util/CollectMVars.c Init/./Lean/Util/FindExpr.c Init/./Lean/Util/FindMVar.c Init/./Lean/Util/FoldConsts.c Init/./Lean/Util/MonadCache.c Init/./Lean/Util/PPExt.c Init/./Lean/Util/PPGoal.c Init/./Lean/Util/Path.c Init/./Lean/Util/Profile.c Init/./Lean/Util/RecDepth.c Init/./Lean/Util/Recognizers.c Init/./Lean/Util/ReplaceExpr.c Init/./Lean/Util/Sorry.c Init/./Lean/Util/Trace.c Init/./Lean/Util/WHNF.c Init/./LeanInit.c Init/./ShareCommon.c Init/./System.c Init/./System/FilePath.c Init/./System/IO.c Init/./System/IOError.c Init/./System/Platform.c Init/./Util.c Init/./WF.c) diff --git a/stage0/stdlib/Init/Data/List/Basic.c b/stage0/stdlib/Init/Data/List/Basic.c index 73b2440a65..bd05ff9893 100644 --- a/stage0/stdlib/Init/Data/List/Basic.c +++ b/stage0/stdlib/Init/Data/List/Basic.c @@ -68,6 +68,7 @@ lean_object* l_List_isEqv___rarg___boxed(lean_object*, lean_object*, lean_object lean_object* l_List_set___main___rarg___boxed(lean_object*, lean_object*, lean_object*); uint8_t l_List_isEqv___main___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_List_intersperse___main___rarg(lean_object*, lean_object*); +lean_object* l_List_groupByAux(lean_object*); lean_object* l_List_partition(lean_object*); uint8_t l_List_isEqv___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_List_init___main(lean_object*); @@ -78,6 +79,7 @@ lean_object* l_List_zipWith___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_List_filter___rarg(lean_object*, lean_object*); lean_object* l_List_foldr___rarg___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_List_dropWhile(lean_object*); +lean_object* l_List_groupBy___rarg(lean_object*, lean_object*); lean_object* l_List_reverseAux___main(lean_object*); uint8_t l_List_hasDecidableLe___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_List_join___rarg(lean_object*); @@ -112,6 +114,7 @@ lean_object* l_List_enum(lean_object*); lean_object* l_List_notElem(lean_object*); lean_object* l_List_pure(lean_object*); lean_object* l_List_eraseIdx(lean_object*); +lean_object* l_List_groupByAux___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_List_hasDecidableLt___main(lean_object*); lean_object* lean_nat_sub(lean_object*, lean_object*); uint8_t l_List_all___rarg(lean_object*, lean_object*); @@ -164,6 +167,7 @@ lean_object* l_List_take___main(lean_object*); lean_object* l_List_unzip(lean_object*, lean_object*); lean_object* l_List_map(lean_object*, lean_object*); lean_object* l_List_foldr___main___at_List_any___spec__1(lean_object*); +lean_object* l_List_eraseReps___rarg(lean_object*, lean_object*); lean_object* l_List_length(lean_object*); lean_object* l_List_removeAll(lean_object*); lean_object* l_List_map_u2082___rarg(lean_object*, lean_object*, lean_object*); @@ -177,6 +181,7 @@ lean_object* l_List_join___main___rarg(lean_object*); lean_object* l_List_find_x3f___main(lean_object*); lean_object* l_List_HasAppend___closed__1; lean_object* l_List_partitionAux(lean_object*); +lean_object* l_List_groupByAux___main(lean_object*); lean_object* l_List_isEmpty(lean_object*); lean_object* l_List_drop___rarg(lean_object*, lean_object*); lean_object* l_List_take___rarg___boxed(lean_object*, lean_object*); @@ -186,6 +191,7 @@ lean_object* l_List_hasDecEq___main(lean_object*); lean_object* l_List_erase(lean_object*); uint8_t l_List_beq___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_List_drop___rarg___boxed(lean_object*, lean_object*); +lean_object* l_List_groupByAux___main___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_List_dropWhile___main___rarg(lean_object*, lean_object*); lean_object* l_List_drop___main___rarg(lean_object*, lean_object*); lean_object* l_List_partition___rarg___closed__1; @@ -205,11 +211,13 @@ lean_object* l_List_eraseIdx___rarg(lean_object*, lean_object*); lean_object* l_List_dropWhile___rarg(lean_object*, lean_object*); lean_object* l_List_reverseAux___main___rarg(lean_object*, lean_object*); uint8_t l_List_hasDecEq___main___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_List_eraseRepsAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_List_and(lean_object*); lean_object* l_List_init___main___rarg(lean_object*); lean_object* l_List_intersperse___rarg(lean_object*, lean_object*); lean_object* l_List_enumFrom___main___rarg(lean_object*, lean_object*); lean_object* l_List_spanAux___main___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_List_eraseRepsAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_List_filter(lean_object*); lean_object* l_List_span(lean_object*); lean_object* l_List_enumFrom___main(lean_object*); @@ -241,12 +249,14 @@ lean_object* l_List_take___rarg(lean_object*, lean_object*); uint8_t l_List_hasDecEq___main___at_List_DecidableEq___spec__1___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_List_take(lean_object*); lean_object* l_List_drop___main(lean_object*); +lean_object* l_List_eraseReps(lean_object*); uint8_t l_List_DecidableEq___rarg(lean_object*, lean_object*, lean_object*); uint8_t l_List_foldr___main___at_List_all___spec__1___rarg(lean_object*, uint8_t, lean_object*); lean_object* l_List_DecidableEq(lean_object*); uint8_t l_List_isEmpty___rarg(lean_object*); lean_object* l_List_lengthAux___rarg(lean_object*, lean_object*); lean_object* l_List_filterMap___rarg(lean_object*, lean_object*); +lean_object* l_List_groupBy(lean_object*); lean_object* l_List_iota___boxed(lean_object*); lean_object* l_List_reverseAux___rarg(lean_object*, lean_object*); lean_object* l_List_hasDecEq___main___at_List_DecidableEq___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*); @@ -258,6 +268,7 @@ uint8_t l_List_beq___main___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_List_intercalate(lean_object*); lean_object* l_List_beq___main___rarg___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_List_beq(lean_object*); +lean_object* l_List_eraseRepsAux(lean_object*); lean_object* l_List_zip___rarg___closed__1; lean_object* l_List_intersperse(lean_object*); lean_object* l_List_foldr1(lean_object*); @@ -276,6 +287,7 @@ lean_object* l_List_length___rarg(lean_object*); lean_object* l_List_foldl(lean_object*, lean_object*); lean_object* l_List_partition___rarg(lean_object*, lean_object*); lean_object* l_List_foldr1Opt(lean_object*); +lean_object* l_List_eraseRepsAux___main(lean_object*); lean_object* l_List_Inhabited(lean_object* x_1) { _start: { @@ -2246,6 +2258,145 @@ x_2 = lean_alloc_closure((void*)(l_List_eraseDups___rarg), 2, 0); return x_2; } } +lean_object* l_List_eraseRepsAux___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; lean_object* x_6; +lean_dec(x_1); +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 = l_List_reverse___rarg(x_5); +return x_6; +} +else +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_3); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; +x_8 = lean_ctor_get(x_3, 0); +x_9 = lean_ctor_get(x_3, 1); +lean_inc(x_1); +lean_inc(x_8); +lean_inc(x_2); +x_10 = lean_apply_2(x_1, x_2, x_8); +x_11 = lean_unbox(x_10); +lean_dec(x_10); +if (x_11 == 0) +{ +lean_ctor_set(x_3, 1, x_4); +lean_ctor_set(x_3, 0, x_2); +{ +lean_object* _tmp_1 = x_8; +lean_object* _tmp_2 = x_9; +lean_object* _tmp_3 = x_3; +x_2 = _tmp_1; +x_3 = _tmp_2; +x_4 = _tmp_3; +} +goto _start; +} +else +{ +lean_free_object(x_3); +lean_dec(x_8); +x_3 = x_9; +goto _start; +} +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; +x_14 = lean_ctor_get(x_3, 0); +x_15 = lean_ctor_get(x_3, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_3); +lean_inc(x_1); +lean_inc(x_14); +lean_inc(x_2); +x_16 = lean_apply_2(x_1, x_2, x_14); +x_17 = lean_unbox(x_16); +lean_dec(x_16); +if (x_17 == 0) +{ +lean_object* x_18; +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_2); +lean_ctor_set(x_18, 1, x_4); +x_2 = x_14; +x_3 = x_15; +x_4 = x_18; +goto _start; +} +else +{ +lean_dec(x_14); +x_3 = x_15; +goto _start; +} +} +} +} +} +lean_object* l_List_eraseRepsAux___main(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_List_eraseRepsAux___main___rarg), 4, 0); +return x_2; +} +} +lean_object* l_List_eraseRepsAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_List_eraseRepsAux___main___rarg(x_1, x_2, x_3, x_4); +return x_5; +} +} +lean_object* l_List_eraseRepsAux(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_List_eraseRepsAux___rarg), 4, 0); +return x_2; +} +} +lean_object* l_List_eraseReps___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = lean_ctor_get(x_2, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_2, 1); +lean_inc(x_4); +lean_dec(x_2); +x_5 = lean_box(0); +x_6 = l_List_eraseRepsAux___main___rarg(x_1, x_3, x_4, x_5); +return x_6; +} +} +} +lean_object* l_List_eraseReps(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_List_eraseReps___rarg), 2, 0); +return x_2; +} +} lean_object* l_List_spanAux___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { @@ -2359,6 +2510,352 @@ x_2 = lean_alloc_closure((void*)(l_List_span___rarg), 2, 0); return x_2; } } +lean_object* l_List_groupByAux___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; +lean_dec(x_1); +x_4 = l_List_reverse___rarg(x_3); +return x_4; +} +else +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; +lean_dec(x_2); +lean_dec(x_1); +x_5 = l_List_reverse___rarg(x_3); +return x_5; +} +else +{ +lean_object* x_6; +x_6 = lean_ctor_get(x_3, 0); +lean_inc(x_6); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +lean_dec(x_2); +lean_dec(x_1); +x_7 = l_List_reverse___rarg(x_3); +return x_7; +} +else +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_2); +if (x_8 == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_3); +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; uint8_t x_16; +x_10 = lean_ctor_get(x_2, 0); +x_11 = lean_ctor_get(x_2, 1); +x_12 = lean_ctor_get(x_3, 1); +x_13 = lean_ctor_get(x_3, 0); +lean_dec(x_13); +x_14 = lean_ctor_get(x_6, 0); +lean_inc(x_14); +lean_inc(x_1); +lean_inc(x_10); +x_15 = lean_apply_2(x_1, x_10, x_14); +x_16 = lean_unbox(x_15); +lean_dec(x_15); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; uint8_t x_19; +x_17 = lean_box(0); +lean_ctor_set(x_3, 1, x_17); +lean_ctor_set(x_3, 0, x_10); +lean_inc(x_6); +x_18 = l_List_reverse___rarg(x_6); +x_19 = !lean_is_exclusive(x_6); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_6, 1); +lean_dec(x_20); +x_21 = lean_ctor_get(x_6, 0); +lean_dec(x_21); +lean_ctor_set(x_6, 1, x_12); +lean_ctor_set(x_6, 0, x_18); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_3); +{ +lean_object* _tmp_1 = x_11; +lean_object* _tmp_2 = x_2; +x_2 = _tmp_1; +x_3 = _tmp_2; +} +goto _start; +} +else +{ +lean_object* x_23; +lean_dec(x_6); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_18); +lean_ctor_set(x_23, 1, x_12); +lean_ctor_set(x_2, 1, x_23); +lean_ctor_set(x_2, 0, x_3); +{ +lean_object* _tmp_1 = x_11; +lean_object* _tmp_2 = x_2; +x_2 = _tmp_1; +x_3 = _tmp_2; +} +goto _start; +} +} +else +{ +lean_ctor_set(x_3, 1, x_6); +lean_ctor_set(x_3, 0, x_10); +lean_ctor_set(x_2, 1, x_12); +lean_ctor_set(x_2, 0, x_3); +{ +lean_object* _tmp_1 = x_11; +lean_object* _tmp_2 = x_2; +x_2 = _tmp_1; +x_3 = _tmp_2; +} +goto _start; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_26 = lean_ctor_get(x_2, 0); +x_27 = lean_ctor_get(x_2, 1); +x_28 = lean_ctor_get(x_3, 1); +lean_inc(x_28); +lean_dec(x_3); +x_29 = lean_ctor_get(x_6, 0); +lean_inc(x_29); +lean_inc(x_1); +lean_inc(x_26); +x_30 = lean_apply_2(x_1, x_26, x_29); +x_31 = lean_unbox(x_30); +lean_dec(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_32 = lean_box(0); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_26); +lean_ctor_set(x_33, 1, x_32); +lean_inc(x_6); +x_34 = l_List_reverse___rarg(x_6); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + lean_ctor_release(x_6, 1); + x_35 = x_6; +} else { + lean_dec_ref(x_6); + x_35 = lean_box(0); +} +if (lean_is_scalar(x_35)) { + x_36 = lean_alloc_ctor(1, 2, 0); +} else { + x_36 = x_35; +} +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_28); +lean_ctor_set(x_2, 1, x_36); +lean_ctor_set(x_2, 0, x_33); +{ +lean_object* _tmp_1 = x_27; +lean_object* _tmp_2 = x_2; +x_2 = _tmp_1; +x_3 = _tmp_2; +} +goto _start; +} +else +{ +lean_object* x_38; +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_26); +lean_ctor_set(x_38, 1, x_6); +lean_ctor_set(x_2, 1, x_28); +lean_ctor_set(x_2, 0, x_38); +{ +lean_object* _tmp_1 = x_27; +lean_object* _tmp_2 = x_2; +x_2 = _tmp_1; +x_3 = _tmp_2; +} +goto _start; +} +} +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint8_t x_46; +x_40 = lean_ctor_get(x_2, 0); +x_41 = lean_ctor_get(x_2, 1); +lean_inc(x_41); +lean_inc(x_40); +lean_dec(x_2); +x_42 = lean_ctor_get(x_3, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_3)) { + lean_ctor_release(x_3, 0); + lean_ctor_release(x_3, 1); + x_43 = x_3; +} else { + lean_dec_ref(x_3); + x_43 = lean_box(0); +} +x_44 = lean_ctor_get(x_6, 0); +lean_inc(x_44); +lean_inc(x_1); +lean_inc(x_40); +x_45 = lean_apply_2(x_1, x_40, x_44); +x_46 = lean_unbox(x_45); +lean_dec(x_45); +if (x_46 == 0) +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_47 = lean_box(0); +if (lean_is_scalar(x_43)) { + x_48 = lean_alloc_ctor(1, 2, 0); +} else { + x_48 = x_43; +} +lean_ctor_set(x_48, 0, x_40); +lean_ctor_set(x_48, 1, x_47); +lean_inc(x_6); +x_49 = l_List_reverse___rarg(x_6); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + lean_ctor_release(x_6, 1); + x_50 = x_6; +} else { + lean_dec_ref(x_6); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_42); +x_52 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_52, 0, x_48); +lean_ctor_set(x_52, 1, x_51); +x_2 = x_41; +x_3 = x_52; +goto _start; +} +else +{ +lean_object* x_54; lean_object* x_55; +if (lean_is_scalar(x_43)) { + x_54 = lean_alloc_ctor(1, 2, 0); +} else { + x_54 = x_43; +} +lean_ctor_set(x_54, 0, x_40); +lean_ctor_set(x_54, 1, x_6); +x_55 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_42); +x_2 = x_41; +x_3 = x_55; +goto _start; +} +} +} +} +} +} +} +lean_object* l_List_groupByAux___main(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_List_groupByAux___main___rarg), 3, 0); +return x_2; +} +} +lean_object* l_List_groupByAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_List_groupByAux___main___rarg(x_1, x_2, x_3); +return x_4; +} +} +lean_object* l_List_groupByAux(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_List_groupByAux___rarg), 3, 0); +return x_2; +} +} +lean_object* l_List_groupBy___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; +lean_dec(x_1); +x_3 = lean_box(0); +return x_3; +} +else +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_2); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_box(0); +lean_ctor_set(x_2, 1, x_6); +x_7 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_7, 0, x_2); +lean_ctor_set(x_7, 1, x_6); +x_8 = l_List_groupByAux___main___rarg(x_1, x_5, x_7); +return x_8; +} +else +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_9 = lean_ctor_get(x_2, 0); +x_10 = lean_ctor_get(x_2, 1); +lean_inc(x_10); +lean_inc(x_9); +lean_dec(x_2); +x_11 = lean_box(0); +x_12 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_12, 0, x_9); +lean_ctor_set(x_12, 1, x_11); +x_13 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +x_14 = l_List_groupByAux___main___rarg(x_1, x_10, x_13); +return x_14; +} +} +} +} +lean_object* l_List_groupBy(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_List_groupBy___rarg), 2, 0); +return x_2; +} +} lean_object* l_List_lookup___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { diff --git a/stage0/stdlib/Init/Data/Option/Basic.c b/stage0/stdlib/Init/Data/Option/Basic.c index 6a2927060c..a238a3eccd 100644 --- a/stage0/stdlib/Init/Data/Option/Basic.c +++ b/stage0/stdlib/Init/Data/Option/Basic.c @@ -14,6 +14,7 @@ extern "C" { #endif lean_object* l_Option_getD___rarg___boxed(lean_object*, lean_object*); +lean_object* l_Option_all___rarg(lean_object*, lean_object*); lean_object* l_Option_Monad___closed__10; lean_object* l_Option_Alternative___lambda__1(lean_object*); lean_object* l_Option_bind(lean_object*, lean_object*); @@ -31,6 +32,7 @@ lean_object* l_Option_bind___rarg(lean_object*, lean_object*); lean_object* l_Option_Monad___closed__3; lean_object* l_Option_toBool(lean_object*); lean_object* l_Option_Monad___closed__5; +lean_object* l_Option_all(lean_object*); lean_object* l_Option_Monad___closed__2; uint8_t l_Option_isSome___rarg(lean_object*); lean_object* l_Option_isSome(lean_object*); @@ -47,8 +49,10 @@ lean_object* l_Option_toMonad___boxed(lean_object*, lean_object*); lean_object* l_Option_Monad; lean_object* l_Option_HasLess___boxed(lean_object*, lean_object*); lean_object* l_Option_HasLess(lean_object*, lean_object*); +lean_object* l_Option_any(lean_object*); lean_object* l_Option_Alternative___closed__2; lean_object* l_Option_isNone(lean_object*); +lean_object* l_Option_any___rarg(lean_object*, lean_object*); lean_object* l_Option_orelse___rarg___boxed(lean_object*, lean_object*); lean_object* l_Option_Monad___lambda__2(lean_object*, lean_object*); lean_object* l_Option_Alternative___closed__1; @@ -646,6 +650,66 @@ x_2 = lean_alloc_closure((void*)(l_Option_filter___rarg), 2, 0); return x_2; } } +lean_object* l_Option_all___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; lean_object* x_4; +lean_dec(x_1); +x_3 = 1; +x_4 = lean_box(x_3); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +lean_dec(x_2); +x_6 = lean_apply_1(x_1, x_5); +return x_6; +} +} +} +lean_object* l_Option_all(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Option_all___rarg), 2, 0); +return x_2; +} +} +lean_object* l_Option_any___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; lean_object* x_4; +lean_dec(x_1); +x_3 = 0; +x_4 = lean_box(x_3); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +lean_dec(x_2); +x_6 = lean_apply_1(x_1, x_5); +return x_6; +} +} +} +lean_object* l_Option_any(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Option_any___rarg), 2, 0); +return x_2; +} +} lean_object* l_Option_orelse___rarg(lean_object* x_1, lean_object* x_2) { _start: { diff --git a/stage0/stdlib/Init/Lean/Compiler/IR/Borrow.c b/stage0/stdlib/Init/Lean/Compiler/IR/Borrow.c index 3a3a7c580a..378a7f49cb 100644 --- a/stage0/stdlib/Init/Lean/Compiler/IR/Borrow.c +++ b/stage0/stdlib/Init/Lean/Compiler/IR/Borrow.c @@ -146,7 +146,6 @@ lean_object* l_Lean_IR_Borrow_getParamInfo___closed__2; lean_object* l_Lean_IR_Borrow_markModified___rarg(lean_object*); lean_object* l_StateT_Monad___rarg(lean_object*); lean_object* l_Lean_IR_Borrow_ApplyParamMap_visitFnBody___main___boxed(lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Util_1__mkPanicMessage___closed__2; extern lean_object* l_Lean_IR_JoinPointId_HasToString___closed__1; lean_object* l_Array_forMAux___main___at_Lean_IR_Borrow_ownArgs___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_IR_inferBorrow(lean_object*, lean_object*, lean_object*); @@ -193,6 +192,7 @@ lean_object* l_Lean_IR_Borrow_ParamMap_Hashable___closed__1; lean_object* l_Lean_IR_Decl_params(lean_object*); uint8_t l_HashMapImp_contains___at_Lean_IR_Borrow_OwnedSet_contains___spec__1(lean_object*, lean_object*); lean_object* l_Lean_IR_Borrow_applyParamMap___boxed(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Syntax_6__formatInfo___closed__1; lean_object* l_Lean_IR_Borrow_OwnedSet_getHash___boxed(lean_object*); lean_object* l_Lean_IR_Borrow_collectDecls(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_IR_Borrow_getParamInfo(lean_object*, lean_object*, lean_object*); @@ -204,7 +204,6 @@ lean_object* l_Array_umapMAux___main___at_Lean_IR_Borrow_InitParamMap_initBorrow uint8_t lean_nat_dec_lt(lean_object*, lean_object*); lean_object* l_Lean_IR_Borrow_infer___boxed(lean_object*, lean_object*); lean_object* l_monadInhabited___rarg(lean_object*, lean_object*); -lean_object* l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__3; uint8_t l_Lean_IR_Borrow_OwnedSet_beq(lean_object* x_1, lean_object* x_2) { _start: { @@ -813,16 +812,6 @@ lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__3() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Util_1__mkPanicMessage___closed__2; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} lean_object* l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1(lean_object* x_1, lean_object* x_2) { _start: { @@ -889,7 +878,7 @@ x_23 = l_Lean_Name_toString___closed__1; x_24 = l_Lean_Name_toStringWithSep___main(x_23, x_21); x_25 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_25, 0, x_24); -x_26 = l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__3; +x_26 = l___private_Init_Lean_Syntax_6__formatInfo___closed__1; x_27 = lean_alloc_ctor(4, 2, 1); lean_ctor_set(x_27, 0, x_25); lean_ctor_set(x_27, 1, x_26); @@ -4554,8 +4543,6 @@ l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__1 lean_mark_persistent(l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__1); l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__2 = _init_l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__2(); lean_mark_persistent(l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__2); -l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__3 = _init_l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__3(); -lean_mark_persistent(l_AssocList_foldlM___main___at_Lean_IR_Borrow_ParamMap_fmt___spec__1___closed__3); l_Lean_IR_Borrow_Lean_HasFormat___closed__1 = _init_l_Lean_IR_Borrow_Lean_HasFormat___closed__1(); lean_mark_persistent(l_Lean_IR_Borrow_Lean_HasFormat___closed__1); l_Lean_IR_Borrow_Lean_HasFormat = _init_l_Lean_IR_Borrow_Lean_HasFormat(); diff --git a/stage0/stdlib/Init/Lean/Compiler/IR/CtorLayout.c b/stage0/stdlib/Init/Lean/Compiler/IR/CtorLayout.c index 3cdeff6776..c1b38e2fcb 100644 --- a/stage0/stdlib/Init/Lean/Compiler/IR/CtorLayout.c +++ b/stage0/stdlib/Init/Lean/Compiler/IR/CtorLayout.c @@ -23,15 +23,14 @@ lean_object* l_Lean_IR_CtorFieldInfo_format(lean_object*); lean_object* l_Lean_IR_CtorFieldInfo_format___closed__3; lean_object* l_Lean_IR_CtorFieldInfo_format___closed__1; lean_object* l_Lean_IR_CtorFieldInfo_format___closed__8; -lean_object* l_Lean_IR_CtorFieldInfo_format___closed__9; lean_object* l_Lean_fmt___at_Lean_IR_CtorFieldInfo_format___spec__1___boxed(lean_object*); lean_object* l_Lean_IR_CtorFieldInfo_format___closed__4; -extern lean_object* l___private_Init_Util_1__mkPanicMessage___closed__2; lean_object* l_Lean_IR_CtorFieldInfo_format___closed__2; lean_object* l___private_Init_Lean_Compiler_IR_Format_5__formatIRType___main(lean_object*); lean_object* l_Lean_IR_getCtorLayout___boxed(lean_object*, lean_object*); lean_object* lean_ir_get_ctor_layout(lean_object*, lean_object*); lean_object* l_Lean_IR_CtorFieldInfo_Lean_HasFormat; +extern lean_object* l___private_Init_Lean_Syntax_6__formatInfo___closed__1; extern lean_object* l___private_Init_Lean_Compiler_IR_Format_1__formatArg___closed__2; lean_object* l_Lean_fmt___at_Lean_IR_CtorFieldInfo_format___spec__1(lean_object* x_1) { _start: @@ -113,16 +112,6 @@ lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l_Lean_IR_CtorFieldInfo_format___closed__9() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Util_1__mkPanicMessage___closed__2; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} lean_object* l_Lean_IR_CtorFieldInfo_format(lean_object* x_1) { _start: { @@ -190,7 +179,7 @@ x_23 = lean_alloc_ctor(4, 2, 1); lean_ctor_set(x_23, 0, x_21); lean_ctor_set(x_23, 1, x_22); lean_ctor_set_uint8(x_23, sizeof(void*)*2, x_17); -x_24 = l_Lean_IR_CtorFieldInfo_format___closed__9; +x_24 = l___private_Init_Lean_Syntax_6__formatInfo___closed__1; x_25 = lean_alloc_ctor(4, 2, 1); lean_ctor_set(x_25, 0, x_23); lean_ctor_set(x_25, 1, x_24); @@ -270,8 +259,6 @@ l_Lean_IR_CtorFieldInfo_format___closed__7 = _init_l_Lean_IR_CtorFieldInfo_forma lean_mark_persistent(l_Lean_IR_CtorFieldInfo_format___closed__7); l_Lean_IR_CtorFieldInfo_format___closed__8 = _init_l_Lean_IR_CtorFieldInfo_format___closed__8(); lean_mark_persistent(l_Lean_IR_CtorFieldInfo_format___closed__8); -l_Lean_IR_CtorFieldInfo_format___closed__9 = _init_l_Lean_IR_CtorFieldInfo_format___closed__9(); -lean_mark_persistent(l_Lean_IR_CtorFieldInfo_format___closed__9); l_Lean_IR_CtorFieldInfo_Lean_HasFormat___closed__1 = _init_l_Lean_IR_CtorFieldInfo_Lean_HasFormat___closed__1(); lean_mark_persistent(l_Lean_IR_CtorFieldInfo_Lean_HasFormat___closed__1); l_Lean_IR_CtorFieldInfo_Lean_HasFormat = _init_l_Lean_IR_CtorFieldInfo_Lean_HasFormat(); diff --git a/stage0/stdlib/Init/Lean/Data/Position.c b/stage0/stdlib/Init/Lean/Data/Position.c index 2c1701d548..14f598ac9e 100644 --- a/stage0/stdlib/Init/Lean/Data/Position.c +++ b/stage0/stdlib/Init/Lean/Data/Position.c @@ -39,6 +39,7 @@ uint8_t lean_nat_dec_eq(lean_object*, lean_object*); lean_object* l_Lean_Position_Lean_HasFormat(lean_object*); lean_object* lean_nat_sub(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Data_Position_3__toPositionAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_back___at_Lean_FileMap_toPosition___spec__1___boxed(lean_object*); lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Data_Position_3__toPositionAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Nat_repr(lean_object*); @@ -52,6 +53,8 @@ lean_object* l___private_Init_Lean_Data_Position_2__toColumnAux___boxed(lean_obj lean_object* l___private_Init_Lean_Data_Position_1__ofStringAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_UInt32_decEq(uint32_t, uint32_t); lean_object* l_Lean_Position_Lean_HasFormat___closed__1; +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +lean_object* l_Array_back___at_Lean_FileMap_toPosition___spec__1(lean_object*); lean_object* l___private_Init_Lean_Data_Position_2__toColumnAux___main(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Position_DecidableEq___boxed(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Data_Position_2__toColumnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -532,28 +535,84 @@ lean_dec(x_1); return x_7; } } +lean_object* l_Array_back___at_Lean_FileMap_toPosition___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_2 = lean_array_get_size(x_1); +x_3 = lean_unsigned_to_nat(1u); +x_4 = lean_nat_sub(x_2, x_3); +lean_dec(x_2); +x_5 = l_Nat_Inhabited; +x_6 = lean_array_get(x_5, x_1, x_4); +lean_dec(x_4); +return x_6; +} +} lean_object* l_Lean_FileMap_toPosition(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_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 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_array_get_size(x_4); -x_7 = lean_unsigned_to_nat(1u); -x_8 = lean_nat_sub(x_6, x_7); +x_7 = lean_unsigned_to_nat(2u); +x_8 = lean_nat_dec_le(x_7, x_6); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_dec(x_6); -x_9 = lean_unsigned_to_nat(0u); -x_10 = l___private_Init_Lean_Data_Position_3__toPositionAux___main(x_3, x_4, x_5, x_2, x_9, x_8); +x_9 = lean_unsigned_to_nat(1u); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_2); return x_10; } +else +{ +lean_object* x_11; uint8_t x_12; +x_11 = l_Array_back___at_Lean_FileMap_toPosition___spec__1(x_4); +x_12 = lean_nat_dec_le(x_2, x_11); +lean_dec(x_11); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; +lean_dec(x_6); +x_13 = lean_unsigned_to_nat(1u); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_2); +return x_14; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_15 = lean_unsigned_to_nat(1u); +x_16 = lean_nat_sub(x_6, x_15); +lean_dec(x_6); +x_17 = lean_unsigned_to_nat(0u); +x_18 = l___private_Init_Lean_Data_Position_3__toPositionAux___main(x_3, x_4, x_5, x_2, x_17, x_16); +lean_dec(x_2); +return x_18; +} +} +} +} +lean_object* l_Array_back___at_Lean_FileMap_toPosition___spec__1___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Array_back___at_Lean_FileMap_toPosition___spec__1(x_1); +lean_dec(x_1); +return x_2; +} } lean_object* l_Lean_FileMap_toPosition___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; x_3 = l_Lean_FileMap_toPosition(x_1, x_2); -lean_dec(x_2); lean_dec(x_1); return x_3; } diff --git a/stage0/stdlib/Init/Lean/Declaration.c b/stage0/stdlib/Init/Lean/Declaration.c index b501384fdc..895a1356cf 100644 --- a/stage0/stdlib/Init/Lean/Declaration.c +++ b/stage0/stdlib/Init/Lean/Declaration.c @@ -24,6 +24,7 @@ lean_object* l_Lean_ConstantVal_inhabited___closed__1; lean_object* lean_mk_reducibility_hints_regular(uint32_t); uint8_t lean_opaque_val_is_unsafe(lean_object*); lean_object* l___private_Init_Util_1__mkPanicMessage(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_Lean_ConstantInfo_isUnsafe(lean_object*); lean_object* l_Lean_ConstantInfo_instantiateValueLevelParams___boxed(lean_object*, lean_object*); lean_object* l_Lean_ConstantVal_inhabited___closed__2; lean_object* lean_mk_inductive_decl(lean_object*, lean_object*, lean_object*, uint8_t); @@ -103,6 +104,7 @@ lean_object* l_Lean_InductiveVal_isReflexiveEx___boxed(lean_object*); uint32_t lean_reducibility_hints_get_height(lean_object*); lean_object* l_Lean_mkInductiveValEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_task_get(lean_object*); +lean_object* l_Lean_ConstantInfo_isUnsafe___boxed(lean_object*); lean_object* l_Lean_mkRecFor(lean_object*); lean_object* l_Lean_ConstantInfo_type___boxed(lean_object*); uint8_t l_Lean_ReducibilityHints_lt(lean_object*, lean_object*); @@ -791,6 +793,71 @@ lean_dec(x_1); return x_2; } } +uint8_t l_Lean_ConstantInfo_isUnsafe(lean_object* x_1) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +lean_object* x_2; uint8_t x_3; +x_2 = lean_ctor_get(x_1, 0); +x_3 = lean_ctor_get_uint8(x_2, sizeof(void*)*1); +return x_3; +} +case 1: +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get_uint8(x_4, sizeof(void*)*3); +return x_5; +} +case 3: +{ +lean_object* x_6; uint8_t x_7; +x_6 = lean_ctor_get(x_1, 0); +x_7 = lean_ctor_get_uint8(x_6, sizeof(void*)*2); +return x_7; +} +case 5: +{ +lean_object* x_8; uint8_t x_9; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get_uint8(x_8, sizeof(void*)*5 + 1); +return x_9; +} +case 6: +{ +lean_object* x_10; uint8_t x_11; +x_10 = lean_ctor_get(x_1, 0); +x_11 = lean_ctor_get_uint8(x_10, sizeof(void*)*5); +return x_11; +} +case 7: +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_1, 0); +x_13 = lean_ctor_get_uint8(x_12, sizeof(void*)*7 + 1); +return x_13; +} +default: +{ +uint8_t x_14; +x_14 = 0; +return x_14; +} +} +} +} +lean_object* l_Lean_ConstantInfo_isUnsafe___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lean_ConstantInfo_isUnsafe(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} lean_object* l_Lean_ConstantInfo_name(lean_object* x_1) { _start: { @@ -949,7 +1016,7 @@ _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_ConstantInfo_value_x21___closed__1; -x_2 = lean_unsigned_to_nat(258u); +x_2 = lean_unsigned_to_nat(268u); x_3 = lean_unsigned_to_nat(31u); x_4 = l_Lean_ConstantInfo_value_x21___closed__2; x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4); diff --git a/stage0/stdlib/Init/Lean/Delaborator.c b/stage0/stdlib/Init/Lean/Delaborator.c index 764feee86e..a2cb22bac9 100644 --- a/stage0/stdlib/Init/Lean/Delaborator.c +++ b/stage0/stdlib/Init/Lean/Delaborator.c @@ -1,6 +1,6 @@ // Lean compiler output // Module: Init.Lean.Delaborator -// Imports: Init.Lean.KeyedDeclsAttribute +// Imports: Init.Lean.KeyedDeclsAttribute Init.Lean.Parser.Level Init.Lean.Elab #include "runtime/lean.h" #if defined(__clang__) #pragma clang diagnostic ignored "-Wunused-parameter" @@ -13,47 +13,1478 @@ #ifdef __cplusplus extern "C" { #endif +extern lean_object* l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__1; +lean_object* l_List_firstM___main___at_Lean_Delaborator_delabFor___main___spec__7(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Name_toString___closed__1; +lean_object* l_Lean_Delaborator_withAppFn___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Level_quote___main(lean_object*); +lean_object* l_PersistentHashMap_findAtAux___main___at_Lean_Delaborator_delabFor___main___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Delaborator_mkDelabAttribute___lambda__1___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__1___closed__6; +lean_object* l_Lean_Delaborator_getExprKind___closed__27; +extern lean_object* l_Lean_Parser_Term_explicit___elambda__1___closed__2; +lean_object* l_Lean_Delaborator_getExprKind___closed__9; +lean_object* lean_local_ctx_get_unused_name(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_DelabM_monadQuotation___closed__2; +lean_object* l___regBuiltin_Lean_Delaborator_delabFVar___closed__1; +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__1___closed__5; +lean_object* l_Lean_Delaborator_annotatePos(lean_object*, lean_object*); +lean_object* l_PersistentHashMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__2___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabSort___closed__12; +lean_object* l_Lean_Delaborator_annotatePos___main(lean_object*, lean_object*); +lean_object* l_Lean_mkTermIdFromIdent(lean_object*); +lean_object* l_Lean_LocalDecl_userName(lean_object*); +extern lean_object* l_Lean_Nat_HasQuote___closed__2; +lean_object* l_unreachable_x21___rarg(lean_object*); +lean_object* l_Lean_Delaborator_DelabM_inhabited(lean_object*); lean_object* l_PersistentHashMap_empty___at_Lean_Delaborator_delabAttribute___spec__3; +lean_object* l_Lean_Delaborator_getExpr___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getExpr(lean_object*, lean_object*, lean_object*); +lean_object* l_Array_eraseIdx___rarg(lean_object*, lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_uget(lean_object*, size_t); +lean_object* l___regBuiltin_Lean_Delaborator_delabFVar(lean_object*); +lean_object* l_Lean_Expr_bindingDomain_x21(lean_object*); +extern lean_object* l_Lean_Parser_Term_explicit___elambda__1___closed__1; +lean_object* l_Lean_Delaborator_delab(lean_object*, lean_object*, lean_object*); +uint8_t lean_name_eq(lean_object*, lean_object*); +extern lean_object* l_Lean_registerTraceClass___closed__1; +lean_object* l_Lean_Delaborator_getExprKind___closed__15; +extern size_t l_PersistentHashMap_insertAux___main___rarg___closed__2; +lean_object* l_Lean_Level_quote___main___lambda__2___closed__1; +lean_object* l_Array_anyRangeMAux___main___at_Lean_Delaborator_delabAppExplicit___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_withBindingBody___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___regBuiltin_Lean_Delaborator_delabAppImplicit___closed__1; +lean_object* l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__31; +lean_object* l_Lean_Delaborator_whenNotPPOption(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_getPPBinderTypes___closed__3; +lean_object* l_Lean_Delaborator_getExprKind___closed__1; +lean_object* l_Lean_Delaborator_getExprKind___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_withAppFn(lean_object*); +lean_object* l___private_Init_Lean_Delaborator_2__delabLamAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_Lean_getPPExplicit(lean_object*); +extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__2; lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__3; +lean_object* l_Lean_Delaborator_DelabM_monadQuotation___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabAppImplicit___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_ppOptions___closed__1; +extern lean_object* l_Lean_Level_LevelToFormat_Result_format___main___closed__1; extern lean_object* l_Array_empty___closed__1; +lean_object* l_Lean_Delaborator_getImplicitParams___closed__1; +lean_object* l_Lean_Delaborator_withAppArg(lean_object*); +lean_object* l_Lean_Delaborator_descend___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_List_tailD___rarg(lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_Level_max___elambda__1___closed__1; +lean_object* l_PersistentHashMap_findAtAux___main___at_Lean_Delaborator_delabFor___main___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Level_dec___main(lean_object*); +lean_object* l_Lean_Level_quote___main___closed__5; +extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__1; +lean_object* l_ReaderT_failure___at_Lean_Delaborator_DelabM_inhabited___spec__1___rarg(lean_object*); lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__10; +lean_object* l___private_Init_Lean_Delaborator_2__delabLamAux___main___closed__1; +lean_object* l_Lean_Delaborator_getExprKind___closed__23; +lean_object* l_Lean_Delaborator_withAppFnArgs___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_DelabM_inhabited___closed__1; +lean_object* lean_expr_instantiate1(lean_object*, lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__21; +lean_object* lean_array_get_size(lean_object*); +lean_object* lean_string_append(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__8; +lean_object* l_Lean_Level_quote___main___closed__3; +lean_object* l_Lean_Delaborator_getExprKind___closed__17; +lean_object* l_Lean_Delaborator_DelabM_monadQuotation___closed__4; lean_object* l_Lean_SMap_empty___at_Lean_Delaborator_delabAttribute___spec__1; lean_object* l_Lean_Delaborator_mkDelabAttribute___lambda__1___closed__1; +lean_object* l_Lean_Expr_getAppFn___main(lean_object*); +extern lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__5; +lean_object* l_Lean_Delaborator_DelabM_monadQuotation___closed__1; +lean_object* l___private_Init_Lean_Delaborator_2__delabLamAux___main___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__2; +lean_object* l_Lean_Delaborator_getExprKind___closed__4; +lean_object* l_Lean_Delaborator_annotateCurPos___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +size_t l_USize_shiftRight(size_t, size_t); +extern lean_object* l_Lean_Parser_Term_proj___elambda__1___closed__1; +lean_object* l_Lean_Level_HasQuote___closed__1; +lean_object* lean_string_utf8_byte_size(lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_Term_sort___elambda__1___closed__2; +lean_object* l_Lean_Level_HasQuote; +lean_object* l___regBuiltin_Lean_Delaborator_delabAppImplicit(lean_object*); +lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___regBuiltin_Lean_Delaborator_delabMVar(lean_object*); +extern lean_object* l_Lean_mkTermIdFromIdent___closed__1; +lean_object* l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__1; +lean_object* l_Lean_Delaborator_delabMVar(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_LocalContext_Inhabited___closed__1; +extern lean_object* l_Lean_mkAppStx___closed__8; +uint8_t l_Lean_getPPUniverses(lean_object*); +extern lean_object* l_Lean_mkAppStx___closed__7; +lean_object* lean_nat_add(lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_Term_sort___elambda__1___closed__5; +uint8_t l_Lean_getPPBinderTypes(lean_object*); +lean_object* l_Lean_Delaborator_delabAppImplicit(lean_object*, lean_object*, lean_object*); +lean_object* l_ReaderT_failure___at_Lean_Delaborator_DelabM_inhabited___spec__1___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__32; +lean_object* l_Lean_Delaborator_getExprKind___closed__10; +lean_object* l_Lean_Delaborator_delabSort___closed__3; +extern lean_object* l_Lean_mkTermIdFromIdent___closed__2; +lean_object* l_Lean_Delaborator_getExprKind___closed__12; +lean_object* l_Lean_Level_quote___main___lambda__1___boxed(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__1; +lean_object* l_Lean_Level_quote___main___lambda__1___closed__1; +lean_object* l_Lean_Level_quote___main___closed__6; lean_object* l_Lean_Delaborator_mkDelabAttribute___lambda__1___closed__2; +lean_object* l_Lean_Delaborator_delabSort___closed__7; +extern lean_object* l_Lean_Parser_Term_namedPattern___elambda__1___closed__5; +lean_object* l_Lean_Delaborator_annotateCurPos(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabAppExplicit___closed__3; +extern lean_object* l_Lean_Parser_Level_imax___elambda__1___closed__1; +extern lean_object* l_Lean_Parser_Term_sort___elambda__1___closed__1; +lean_object* l_Lean_Level_getLevelOffset___main(lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__13; +lean_object* l_Lean_ppOptions(lean_object*); +lean_object* lean_array_fget(lean_object*, lean_object*); lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__7; +lean_object* l_Lean_Delaborator_delabAppExplicit(lean_object*, lean_object*, lean_object*); +uint8_t lean_nat_dec_eq(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_infoForPos___closed__2; +lean_object* l_Lean_Delaborator_delabSort___closed__10; extern lean_object* l_Lean_EnvExtension_Inhabited___rarg___closed__1; -extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__2; +extern lean_object* l_Lean_Parser_Term_type___elambda__1___closed__5; +extern lean_object* l_Lean_Elab_Term_elabArrayLit___closed__11; +extern lean_object* l_Lean_numLitKind; +lean_object* l_Lean_Delaborator_delabFVar(lean_object*, lean_object*, lean_object*); +lean_object* l___regBuiltin_Lean_Delaborator_delabExplicitLam___closed__1; +lean_object* l_Lean_Delaborator_delabAppImplicit___closed__7; +lean_object* l_Lean_Delaborator_delab___closed__1; +lean_object* l_Lean_Delaborator_getExprKind___closed__20; +lean_object* l___private_Init_Lean_Delaborator_2__delabLamAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabLit(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_append___main(lean_object*, lean_object*); +uint8_t l_Lean_KVMap_getBool(lean_object*, lean_object*, uint8_t); +lean_object* l_Lean_Delaborator_delabAppImplicit___closed__3; +extern lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__2; +lean_object* l_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1___boxed(lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_Term_instBinder___elambda__1___closed__2; +lean_object* l_Lean_Level_quote___main___closed__1; lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__5; +lean_object* l_Lean_Level_quote___main___lambda__4___closed__1; +lean_object* l_Lean_Delaborator_whenPPOption(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Meta_recursorAttribute___closed__1; +lean_object* l___regBuiltin_Lean_Delaborator_delabAppExplicit(lean_object*); +lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Unhygienic_run___rarg(lean_object*); +lean_object* l_Lean_Expr_fvarId_x21(lean_object*); +lean_object* l_Lean_Delaborator_delabAppImplicit___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabSort___closed__5; +extern lean_object* l_Lean_Unhygienic_MonadQuotation___closed__4; +lean_object* l_Lean_Level_quote___main___closed__2; +lean_object* l_Lean_Delaborator_getExprKind___closed__11; +lean_object* l_Lean_Level_quote___main___lambda__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Level_toNat(lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___regBuiltin_Lean_Delaborator_delabLit(lean_object*); lean_object* l_Lean_Delaborator_delabAttribute___closed__2; lean_object* l_Lean_Delaborator_mkDelabAttribute___lambda__1(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabAppImplicit___closed__5; +lean_object* l_Lean_Delaborator_infoForPos___closed__1; +size_t l_Lean_Name_hash(lean_object*); +lean_object* l_Nat_repr(lean_object*); +extern lean_object* l_Char_HasRepr___closed__1; +uint8_t l_Lean_LocalDecl_binderInfo(lean_object*); +extern lean_object* l_Lean_Level_LevelToFormat_Result_format___main___closed__5; +extern lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__3; +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Delaborator_2__delabLamAux___main___spec__1(lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_Term_namedHole___elambda__1___closed__2; +lean_object* l_Lean_Delaborator_getExprKind___closed__26; +lean_object* l_Lean_Delaborator_delabFor___main(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_withAppFnArgs(lean_object*); lean_object* lean_name_mk_string(lean_object*, lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__2; +extern lean_object* l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; +lean_object* l_Lean_Delaborator_getPPOption(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(lean_object*, lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__1(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_numLitKind___closed__2; +lean_object* l_Lean_Level_getOffsetAux___main(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_withBindingBody___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_ReaderT_failure___at_Lean_Delaborator_DelabM_inhabited___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_attrParamSyntaxToIdentifier(lean_object*); +size_t lean_usize_modn(size_t, lean_object*); +lean_object* l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__1; +extern lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__2; +lean_object* l_Lean_Delaborator_getExprKind___closed__33; +lean_object* l_Lean_Level_quote___main___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_Lean_Expr_isConst(lean_object*); +uint8_t l_Array_isEmpty___rarg(lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__2; +extern lean_object* l_String_Iterator_HasRepr___closed__2; +lean_object* l_Lean_Delaborator_infoForPos(lean_object*); +lean_object* l_Lean_Delaborator_withBindingDomain(lean_object*); +lean_object* l_Array_umapMAux___main___at_Lean_Delaborator_delabConst___spec__1(lean_object*, lean_object*); +lean_object* l_List_redLength___main___rarg(lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__24; lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__4; lean_object* l_mkHashMapImp___rarg(lean_object*); +lean_object* l_Lean_Delaborator_delabSort___closed__6; lean_object* l_Lean_Delaborator_delabAttribute___closed__4; +lean_object* l_Lean_Delaborator_getExprKind___closed__7; +lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_HashMapImp_find_x3f___at_Lean_Delaborator_delabFor___main___spec__5(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +extern lean_object* l_Lean_Parser_FirstTokens_toStr___closed__3; +lean_object* l_Lean_Delaborator_delabAppExplicit___closed__4; +lean_object* l_Lean_Delaborator_getExprKind___closed__19; extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__3; +lean_object* l_PersistentHashMap_findAux___main___at_Lean_Delaborator_delabFor___main___spec__3___boxed(lean_object*, lean_object*, lean_object*); +uint8_t l_Lean_Expr_isLambda(lean_object*); lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__6; +lean_object* l___regBuiltin_Lean_Delaborator_delabExplicitLam(lean_object*); +lean_object* l_Lean_Delaborator_DelabM_monadQuotation; +extern lean_object* l___private_Init_Lean_Elab_DoNotation_7__expandDoElemsAux___main___closed__2; +size_t l_USize_land(size_t, size_t); +extern lean_object* l_Lean_String_HasQuote___closed__2; +lean_object* l_Lean_Level_quote___main___closed__4; +uint8_t l_Lean_Syntax_isAtom(lean_object*); +extern lean_object* l_Lean_nullKind___closed__2; +extern lean_object* l_Lean_Meta_mkAuxName___closed__1; +lean_object* l_Lean_Delaborator_delabAppImplicit___closed__6; +lean_object* l_Lean_Delaborator_getExprKind___closed__5; +extern lean_object* l_Lean_Elab_Term_elabArrayLit___closed__10; +lean_object* l_Lean_Delaborator_getExprKind___closed__22; +extern lean_object* l_Lean_Parser_Level_hole___elambda__1___closed__1; +extern lean_object* l_Lean_mkAppStx___closed__3; +lean_object* l_Lean_Delaborator_getPPOption___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__2; +lean_object* l_Lean_Delaborator_delabSort___closed__2; +extern lean_object* l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2; +extern lean_object* l_Lean_Syntax_inhabited; lean_object* l_Lean_SMap_empty___at_Lean_Delaborator_delabAttribute___spec__1___closed__1; +lean_object* l_Lean_Meta_withLocalDecl___rarg(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +lean_object* l___regBuiltin_Lean_Delaborator_delabAppExplicit___closed__1; +lean_object* l_Lean_delab(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__13; +lean_object* l_Lean_Delaborator_delabFor(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getPPOption___closed__1; +lean_object* l_Lean_Delaborator_delabExplicitLam(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_mkAppStx___closed__5; +lean_object* l_Lean_Level_quote___main___lambda__1___closed__4; +extern lean_object* l_PersistentArray_Stats_toString___closed__4; +uint8_t l_Lean_BinderInfo_beq(uint8_t, uint8_t); lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__2; +lean_object* l_Lean_Meta_getLocalDecl(lean_object*, lean_object*, lean_object*); +uint8_t lean_expr_eqv(lean_object*, lean_object*); +lean_object* l_Lean_ppOptions___closed__2; +lean_object* l_Lean_Level_quote___main___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__2; +lean_object* l_Lean_Level_quote___main___lambda__9___closed__1; +lean_object* l_Lean_Delaborator_descend(lean_object*); +lean_object* l_Lean_SMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__1___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__9___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabConst(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_getArgs(lean_object*); +lean_object* l_Lean_Delaborator_delabAppImplicit___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_Lean_BinderInfo_isExplicit(uint8_t); +lean_object* l_Lean_Delaborator_delabMVar___closed__1; +lean_object* l_Lean_Level_quote___main___lambda__1___closed__2; +lean_object* l_Lean_Delaborator_delabSort___closed__13; +extern lean_object* l_Lean_Parser_Term_paren___elambda__1___closed__1; +lean_object* l_Lean_Delaborator_delabMVar___closed__2; +lean_object* l_Lean_Level_quote___main___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_SMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__1(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__16; +lean_object* l_Lean_Level_quote___main___lambda__4___closed__2; +lean_object* l_Lean_Delaborator_delabAppImplicit___closed__2; lean_object* l_Lean_Delaborator_delabAttribute___closed__1; +extern lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__5; +lean_object* l_Lean_Level_quote___main___lambda__9(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getImplicitParams(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_getPPAll___boxed(lean_object*); +lean_object* lean_register_option(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabAppExplicit___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_withBindingDomain___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_getPPAll___closed__1; lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__1; +lean_object* l_Lean_getPPAll___closed__2; +lean_object* l_Lean_getPPUniverses___closed__1; +lean_object* l_Lean_getPPUniverses___boxed(lean_object*); +lean_object* l_AssocList_find_x3f___main___at_Lean_Delaborator_delabFor___main___spec__6___boxed(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__1; +lean_object* l_Lean_mkStxStrLit(lean_object*, lean_object*); +lean_object* lean_nat_mul(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__2; +lean_object* l_Lean_Delaborator_delabConst___closed__1; +extern lean_object* l_Lean_Parser_Command_universes___elambda__1___closed__1; +lean_object* l_Lean_getPPExplicit___boxed(lean_object*); +lean_object* l_Lean_Delaborator_getExprKind(lean_object*, lean_object*, lean_object*); +lean_object* l_HashMapImp_find_x3f___at_Lean_Delaborator_delabFor___main___spec__5___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__1___closed__3; +lean_object* l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__2; +lean_object* lean_mk_syntax_num_lit(lean_object*); +lean_object* l_Lean_Syntax_setInfo(lean_object*, lean_object*); lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__8; +lean_object* l___private_Init_Lean_Delaborator_2__delabLamAux___main___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Meta_inferType(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabAppExplicit___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Level_LevelToFormat_Result_format___main___closed__3; +lean_object* l_Lean_mkTermIdFrom(lean_object*, lean_object*); lean_object* l_Lean_Delaborator_mkDelabAttribute(lean_object*); +lean_object* l_Lean_Delaborator_delabSort___closed__9; +lean_object* l_Lean_Name_getRoot___main(lean_object*); +lean_object* l___regBuiltin_Lean_Delaborator_delabLit___closed__1; +lean_object* l_Lean_getPPExplicit___closed__1; +lean_object* l_Lean_Delaborator_getExprKind___closed__6; lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__12; +lean_object* l_Array_toList___rarg(lean_object*); +lean_object* l___regBuiltin_Lean_Delaborator_delabSort___closed__1; +lean_object* l___regBuiltin_Lean_Delaborator_delabMVar___closed__1; lean_object* l_Lean_Delaborator_delabAttribute; +lean_object* l_Lean_Delaborator_delabConst___closed__2; +uint8_t l_Lean_Expr_binderInfo(lean_object*); +uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*); +lean_object* l_Lean_PersistentEnvExtension_getState___rarg(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabConst___closed__4; +lean_object* l_Lean_Delaborator_delabAppImplicit___closed__4; +lean_object* l_Lean_Level_quote___main___lambda__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabSort___closed__8; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; +lean_object* l_Lean_Delaborator_delabSort___closed__4; lean_object* l_Lean_SMap_empty___at_Lean_Delaborator_delabAttribute___spec__1___closed__2; +lean_object* l_Lean_Level_quote___main___lambda__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_PersistentHashMap_findAux___main___at_Lean_Delaborator_delabFor___main___spec__3(lean_object*, size_t, lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_mk_syntax_ident(lean_object*); +lean_object* l_Lean_Delaborator_delabSort___closed__1; +lean_object* l_Lean_mkStxLit(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_DelabM_monadQuotation___closed__3; +lean_object* l_Lean_Delaborator_getImplicitParams___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_withBindingBody(lean_object*); +lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*); +extern lean_object* l_Lean_mkOptionalNode___closed__2; +extern lean_object* l_Lean_Meta_isClassQuick___main___closed__1; +lean_object* l_Lean_Delaborator_descend___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_AssocList_find_x3f___main___at_Lean_Delaborator_delabFor___main___spec__6(lean_object*, lean_object*); lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__11; +extern lean_object* l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; +lean_object* l_Lean_Delaborator_withAppFnArgs___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_withAppArg___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_List_toArrayAux___main___rarg(lean_object*, lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*); +uint8_t l_Array_anyRangeMAux___main___at_Lean_Delaborator_delabAppExplicit___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_List_isEmpty___rarg(lean_object*); +lean_object* l_Lean_getPPBinderTypes___closed__2; +lean_object* l_Lean_Delaborator_delabAppExplicit___closed__2; +lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*); lean_object* l_Lean_KeyedDeclsAttribute_init___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Delaborator_delabAttribute___closed__5; +lean_object* l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_getImplicitParams___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_usize_to_nat(size_t); +lean_object* l_Lean_Delaborator_withAppFnArgs___main(lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__30; +uint8_t l_Lean_getPPAll(lean_object*); +lean_object* l_Lean_Delaborator_getExprKind___closed__3; +lean_object* l_Lean_Delaborator_getExprKind___closed__18; lean_object* l_Lean_Delaborator_delabAttribute___closed__3; +lean_object* l_Lean_Delaborator_getExprKind___closed__28; +lean_object* l_Lean_Delaborator_getExprKind___closed__14; extern lean_object* l_Lean_mkAppStx___closed__2; +lean_object* l_Lean_Expr_bindingBody_x21(lean_object*); +lean_object* l___private_Init_Lean_Delaborator_1__shouldGroupWithNext(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabSort___closed__11; +lean_object* l_Lean_Delaborator_delabSort(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Level_quote(lean_object*); +lean_object* l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1___boxed(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; +lean_object* l_Lean_Delaborator_delabConst___closed__3; +lean_object* l_Lean_Delaborator_getExprKind___closed__29; extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__4; +extern lean_object* l_Lean_Parser_Term_sortApp___elambda__1___closed__2; +lean_object* l_Lean_Delaborator_getExprKind___closed__25; +lean_object* l_Lean_Level_quote___main___lambda__8(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_getPPBinderTypes___closed__4; +extern lean_object* l_Lean_mkAppStx___closed__1; +lean_object* l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1(lean_object*); +lean_object* l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Meta_forallTelescopeReducing___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__9; +extern lean_object* l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__2; +lean_object* l_Lean_getPPBinderTypes___closed__1; +lean_object* l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__2; +lean_object* l_PersistentHashMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__2(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabAppImplicit___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabAppImplicit___closed__1; lean_object* l_mkHashMap___at_Lean_Delaborator_delabAttribute___spec__2(lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_withBindingBody___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___regBuiltin_Lean_Delaborator_delabSort(lean_object*); +uint8_t lean_string_dec_eq(lean_object*, lean_object*); +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +lean_object* l_Lean_Delaborator_delabAppExplicit___closed__1; +lean_object* l_Lean_Level_quote___main___lambda__6___closed__1; +lean_object* l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Level_quote___main___lambda__6___closed__2; +lean_object* l_Lean_getPPBinderTypes___boxed(lean_object*); +lean_object* _init_l_Lean_Level_quote___main___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("0"); +return x_1; +} +} +lean_object* _init_l_Lean_Level_quote___main___lambda__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Level_quote___main___lambda__1___closed__1; +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* _init_l_Lean_Level_quote___main___lambda__1___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Level_quote___main___lambda__1___closed__2; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Level_quote___main___lambda__1___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_numLitKind___closed__2; +x_2 = l_Lean_Level_quote___main___lambda__1___closed__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_Level_quote___main___lambda__1___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Level_quote___main___lambda__1___closed__4; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Level_quote___main___lambda__1___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_2 = l_Lean_Level_quote___main___lambda__1___closed__5; +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* l_Lean_Level_quote___main___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +x_4 = l_Lean_Level_quote___main___lambda__1___closed__6; +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_4); +lean_ctor_set(x_5, 1, x_3); +return x_5; +} +} +lean_object* _init_l_Lean_Level_quote___main___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Level_LevelToFormat_Result_format___main___closed__1; +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* l_Lean_Level_quote___main___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_5 = l_Lean_Level_getLevelOffset___main(x_1); +x_6 = l_Lean_Level_quote___main(x_5); +x_7 = l_Array_empty___closed__1; +x_8 = lean_array_push(x_7, x_6); +x_9 = l_Lean_Level_quote___main___lambda__2___closed__1; +x_10 = lean_array_push(x_8, x_9); +x_11 = lean_unsigned_to_nat(0u); +x_12 = l_Lean_Level_getOffsetAux___main(x_1, x_11); +x_13 = lean_mk_syntax_num_lit(x_12); +x_14 = lean_array_push(x_10, x_13); +x_15 = l_Lean_Parser_Level_addLit___elambda__1___closed__2; +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_14); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_4); +return x_17; +} +} +lean_object* l_Lean_Level_quote___main___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_5 = lean_mk_syntax_num_lit(x_1); +x_6 = l_Array_empty___closed__1; +x_7 = lean_array_push(x_6, x_5); +x_8 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_9 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_4); +return x_10; +} +} +lean_object* _init_l_Lean_Level_quote___main___lambda__4___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Level_LevelToFormat_Result_format___main___closed__3; +x_3 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Level_quote___main___lambda__4___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Level_quote___main___lambda__4___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Level_quote___main___lambda__4(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; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_7 = l_Lean_Level_quote___main(x_1); +x_8 = l_Array_empty___closed__1; +x_9 = lean_array_push(x_8, x_7); +x_10 = lean_array_push(x_9, x_2); +x_11 = l_Lean_nullKind___closed__2; +x_12 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_10); +x_13 = l_Lean_Level_quote___main___lambda__4___closed__2; +x_14 = lean_array_push(x_13, x_12); +x_15 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_15, 0, x_3); +lean_ctor_set(x_15, 1, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_6); +return x_16; +} +} +lean_object* l_Lean_Level_quote___main___lambda__5(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; 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_7 = l_Lean_Level_quote___main(x_1); +x_8 = l_Array_empty___closed__1; +x_9 = lean_array_push(x_8, x_7); +x_10 = lean_unsigned_to_nat(0u); +x_11 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_2, x_2, x_10, x_9); +x_12 = l_Lean_nullKind___closed__2; +x_13 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +x_14 = l_Lean_Level_quote___main___lambda__4___closed__2; +x_15 = lean_array_push(x_14, x_13); +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_3); +lean_ctor_set(x_16, 1, x_15); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_6); +return x_17; +} +} +lean_object* _init_l_Lean_Level_quote___main___lambda__6___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Level_LevelToFormat_Result_format___main___closed__5; +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* _init_l_Lean_Level_quote___main___lambda__6___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Level_quote___main___lambda__6___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Level_quote___main___lambda__6(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; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_7 = l_Lean_Level_quote___main(x_1); +x_8 = l_Array_empty___closed__1; +x_9 = lean_array_push(x_8, x_7); +x_10 = lean_array_push(x_9, x_2); +x_11 = l_Lean_nullKind___closed__2; +x_12 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_10); +x_13 = l_Lean_Level_quote___main___lambda__6___closed__2; +x_14 = lean_array_push(x_13, x_12); +x_15 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_15, 0, x_3); +lean_ctor_set(x_15, 1, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_6); +return x_16; +} +} +lean_object* l_Lean_Level_quote___main___lambda__7(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; 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_7 = l_Lean_Level_quote___main(x_1); +x_8 = l_Array_empty___closed__1; +x_9 = lean_array_push(x_8, x_7); +x_10 = lean_unsigned_to_nat(0u); +x_11 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_2, x_2, x_10, x_9); +x_12 = l_Lean_nullKind___closed__2; +x_13 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +x_14 = l_Lean_Level_quote___main___lambda__6___closed__2; +x_15 = lean_array_push(x_14, x_13); +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_3); +lean_ctor_set(x_16, 1, x_15); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_6); +return x_17; +} +} +lean_object* l_Lean_Level_quote___main___lambda__8(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; +x_5 = lean_mk_syntax_ident(x_1); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_4); +return x_6; +} +} +lean_object* _init_l_Lean_Level_quote___main___lambda__9___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Level_hole___elambda__1___closed__1; +x_2 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__2; +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* l_Lean_Level_quote___main___lambda__9(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +x_4 = l_Lean_Level_quote___main___lambda__9___closed__1; +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_4); +lean_ctor_set(x_5, 1, x_3); +return x_5; +} +} +lean_object* _init_l_Lean_Level_quote___main___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Level_quote___main___lambda__1___boxed), 3, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Level_quote___main___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Unhygienic_MonadQuotation___closed__4; +x_2 = l_Lean_Level_quote___main___closed__1; +x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Level_quote___main___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Level_quote___main___closed__2; +x_2 = l_Lean_Unhygienic_run___rarg(x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Level_quote___main___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Level_quote___main___lambda__9___boxed), 3, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Level_quote___main___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Unhygienic_MonadQuotation___closed__4; +x_2 = l_Lean_Level_quote___main___closed__4; +x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Level_quote___main___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Level_quote___main___closed__5; +x_2 = l_Lean_Unhygienic_run___rarg(x_1); +return x_2; +} +} +lean_object* l_Lean_Level_quote___main(lean_object* x_1) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +lean_object* x_2; +lean_dec(x_1); +x_2 = l_Lean_Level_quote___main___closed__3; +return x_2; +} +case 1: +{ +lean_object* x_3; +x_3 = l_Lean_Level_toNat(x_1); +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_4 = lean_alloc_closure((void*)(l_Lean_Level_quote___main___lambda__2___boxed), 4, 1); +lean_closure_set(x_4, 0, x_1); +x_5 = l_Lean_Unhygienic_MonadQuotation___closed__4; +x_6 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); +lean_closure_set(x_6, 0, x_5); +lean_closure_set(x_6, 1, x_4); +x_7 = l_Lean_Unhygienic_run___rarg(x_6); +return x_7; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +lean_dec(x_1); +x_8 = lean_ctor_get(x_3, 0); +lean_inc(x_8); +lean_dec(x_3); +x_9 = lean_alloc_closure((void*)(l_Lean_Level_quote___main___lambda__3___boxed), 4, 1); +lean_closure_set(x_9, 0, x_8); +x_10 = l_Lean_Unhygienic_MonadQuotation___closed__4; +x_11 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); +lean_closure_set(x_11, 0, x_10); +lean_closure_set(x_11, 1, x_9); +x_12 = l_Lean_Unhygienic_run___rarg(x_11); +return x_12; +} +} +case 2: +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_31; uint8_t x_32; +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_1, 1); +lean_inc(x_14); +lean_dec(x_1); +x_15 = l_Lean_Level_quote___main(x_14); +x_31 = l_Lean_Parser_Level_max___elambda__1___closed__1; +lean_inc(x_15); +x_32 = l_Lean_Syntax_isOfKind(x_15, x_31); +if (x_32 == 0) +{ +uint8_t x_33; +x_33 = 0; +x_16 = x_33; +goto block_30; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_34 = l_Lean_Syntax_getArgs(x_15); +x_35 = lean_array_get_size(x_34); +lean_dec(x_34); +x_36 = lean_unsigned_to_nat(2u); +x_37 = lean_nat_dec_eq(x_35, x_36); +lean_dec(x_35); +x_16 = x_37; +goto block_30; +} +block_30: +{ +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_17 = l_Lean_Parser_Level_max___elambda__1___closed__1; +x_18 = lean_alloc_closure((void*)(l_Lean_Level_quote___main___lambda__4___boxed), 6, 3); +lean_closure_set(x_18, 0, x_13); +lean_closure_set(x_18, 1, x_15); +lean_closure_set(x_18, 2, x_17); +x_19 = l_Lean_Unhygienic_MonadQuotation___closed__4; +x_20 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); +lean_closure_set(x_20, 0, x_19); +lean_closure_set(x_20, 1, x_18); +x_21 = l_Lean_Unhygienic_run___rarg(x_20); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_22 = lean_unsigned_to_nat(1u); +x_23 = l_Lean_Syntax_getArg(x_15, x_22); +lean_dec(x_15); +x_24 = l_Lean_Syntax_getArgs(x_23); +lean_dec(x_23); +x_25 = l_Lean_Parser_Level_max___elambda__1___closed__1; +x_26 = lean_alloc_closure((void*)(l_Lean_Level_quote___main___lambda__5___boxed), 6, 3); +lean_closure_set(x_26, 0, x_13); +lean_closure_set(x_26, 1, x_24); +lean_closure_set(x_26, 2, x_25); +x_27 = l_Lean_Unhygienic_MonadQuotation___closed__4; +x_28 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); +lean_closure_set(x_28, 0, x_27); +lean_closure_set(x_28, 1, x_26); +x_29 = l_Lean_Unhygienic_run___rarg(x_28); +return x_29; +} +} +} +case 3: +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_56; uint8_t x_57; +x_38 = lean_ctor_get(x_1, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_1, 1); +lean_inc(x_39); +lean_dec(x_1); +x_40 = l_Lean_Level_quote___main(x_39); +x_56 = l_Lean_Parser_Level_imax___elambda__1___closed__1; +lean_inc(x_40); +x_57 = l_Lean_Syntax_isOfKind(x_40, x_56); +if (x_57 == 0) +{ +uint8_t x_58; +x_58 = 0; +x_41 = x_58; +goto block_55; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; +x_59 = l_Lean_Syntax_getArgs(x_40); +x_60 = lean_array_get_size(x_59); +lean_dec(x_59); +x_61 = lean_unsigned_to_nat(2u); +x_62 = lean_nat_dec_eq(x_60, x_61); +lean_dec(x_60); +x_41 = x_62; +goto block_55; +} +block_55: +{ +if (x_41 == 0) +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_42 = l_Lean_Parser_Level_imax___elambda__1___closed__1; +x_43 = lean_alloc_closure((void*)(l_Lean_Level_quote___main___lambda__6___boxed), 6, 3); +lean_closure_set(x_43, 0, x_38); +lean_closure_set(x_43, 1, x_40); +lean_closure_set(x_43, 2, x_42); +x_44 = l_Lean_Unhygienic_MonadQuotation___closed__4; +x_45 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); +lean_closure_set(x_45, 0, x_44); +lean_closure_set(x_45, 1, x_43); +x_46 = l_Lean_Unhygienic_run___rarg(x_45); +return x_46; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_47 = lean_unsigned_to_nat(1u); +x_48 = l_Lean_Syntax_getArg(x_40, x_47); +lean_dec(x_40); +x_49 = l_Lean_Syntax_getArgs(x_48); +lean_dec(x_48); +x_50 = l_Lean_Parser_Level_imax___elambda__1___closed__1; +x_51 = lean_alloc_closure((void*)(l_Lean_Level_quote___main___lambda__7___boxed), 6, 3); +lean_closure_set(x_51, 0, x_38); +lean_closure_set(x_51, 1, x_49); +lean_closure_set(x_51, 2, x_50); +x_52 = l_Lean_Unhygienic_MonadQuotation___closed__4; +x_53 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); +lean_closure_set(x_53, 0, x_52); +lean_closure_set(x_53, 1, x_51); +x_54 = l_Lean_Unhygienic_run___rarg(x_53); +return x_54; +} +} +} +case 4: +{ +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_1, 0); +lean_inc(x_63); +lean_dec(x_1); +x_64 = lean_alloc_closure((void*)(l_Lean_Level_quote___main___lambda__8___boxed), 4, 1); +lean_closure_set(x_64, 0, x_63); +x_65 = l_Lean_Unhygienic_MonadQuotation___closed__4; +x_66 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); +lean_closure_set(x_66, 0, x_65); +lean_closure_set(x_66, 1, x_64); +x_67 = l_Lean_Unhygienic_run___rarg(x_66); +return x_67; +} +default: +{ +lean_object* x_68; +lean_dec(x_1); +x_68 = l_Lean_Level_quote___main___closed__6; +return x_68; +} +} +} +} +lean_object* l_Lean_Level_quote___main___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Level_quote___main___lambda__1(x_1, x_2, x_3); +lean_dec(x_2); +lean_dec(x_1); +return x_4; +} +} +lean_object* l_Lean_Level_quote___main___lambda__2___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_Level_quote___main___lambda__2(x_1, x_2, x_3, x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +return x_5; +} +} +lean_object* l_Lean_Level_quote___main___lambda__3___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_Level_quote___main___lambda__3(x_1, x_2, x_3, x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_5; +} +} +lean_object* l_Lean_Level_quote___main___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lean_Level_quote___main___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_5); +lean_dec(x_4); +return x_7; +} +} +lean_object* l_Lean_Level_quote___main___lambda__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lean_Level_quote___main___lambda__5(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +return x_7; +} +} +lean_object* l_Lean_Level_quote___main___lambda__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: +{ +lean_object* x_7; +x_7 = l_Lean_Level_quote___main___lambda__6(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_5); +lean_dec(x_4); +return x_7; +} +} +lean_object* l_Lean_Level_quote___main___lambda__7___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lean_Level_quote___main___lambda__7(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +return x_7; +} +} +lean_object* l_Lean_Level_quote___main___lambda__8___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_Level_quote___main___lambda__8(x_1, x_2, x_3, x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_5; +} +} +lean_object* l_Lean_Level_quote___main___lambda__9___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Level_quote___main___lambda__9(x_1, x_2, x_3); +lean_dec(x_2); +lean_dec(x_1); +return x_4; +} +} +lean_object* l_Lean_Level_quote(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_Level_quote___main(x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Level_HasQuote___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Level_quote), 1, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Level_HasQuote() { +_start: +{ +lean_object* x_1; +x_1 = l_Lean_Level_HasQuote___closed__1; +return x_1; +} +} +lean_object* _init_l_Lean_getPPBinderTypes___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("pp"); +return x_1; +} +} +lean_object* _init_l_Lean_getPPBinderTypes___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_getPPBinderTypes___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_getPPBinderTypes___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("binder_types"); +return x_1; +} +} +lean_object* _init_l_Lean_getPPBinderTypes___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_getPPBinderTypes___closed__2; +x_2 = l_Lean_getPPBinderTypes___closed__3; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +uint8_t l_Lean_getPPBinderTypes(lean_object* x_1) { +_start: +{ +lean_object* x_2; uint8_t x_3; uint8_t x_4; +x_2 = l_Lean_getPPBinderTypes___closed__4; +x_3 = 1; +x_4 = l_Lean_KVMap_getBool(x_1, x_2, x_3); +return x_4; +} +} +lean_object* l_Lean_getPPBinderTypes___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lean_getPPBinderTypes(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +lean_object* _init_l_Lean_getPPExplicit___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_getPPBinderTypes___closed__2; +x_2 = l_Lean_Parser_Term_explicit___elambda__1___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +uint8_t l_Lean_getPPExplicit(lean_object* x_1) { +_start: +{ +lean_object* x_2; uint8_t x_3; uint8_t x_4; +x_2 = l_Lean_getPPExplicit___closed__1; +x_3 = 0; +x_4 = l_Lean_KVMap_getBool(x_1, x_2, x_3); +return x_4; +} +} +lean_object* l_Lean_getPPExplicit___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lean_getPPExplicit(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +lean_object* _init_l_Lean_getPPUniverses___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_getPPBinderTypes___closed__2; +x_2 = l_Lean_Parser_Command_universes___elambda__1___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +uint8_t l_Lean_getPPUniverses(lean_object* x_1) { +_start: +{ +lean_object* x_2; uint8_t x_3; uint8_t x_4; +x_2 = l_Lean_getPPUniverses___closed__1; +x_3 = 0; +x_4 = l_Lean_KVMap_getBool(x_1, x_2, x_3); +return x_4; +} +} +lean_object* l_Lean_getPPUniverses___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lean_getPPUniverses(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +lean_object* _init_l_Lean_getPPAll___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("all"); +return x_1; +} +} +lean_object* _init_l_Lean_getPPAll___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_getPPBinderTypes___closed__2; +x_2 = l_Lean_getPPAll___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +uint8_t l_Lean_getPPAll(lean_object* x_1) { +_start: +{ +lean_object* x_2; uint8_t x_3; uint8_t x_4; +x_2 = l_Lean_getPPAll___closed__2; +x_3 = 0; +x_4 = l_Lean_KVMap_getBool(x_1, x_2, x_3); +return x_4; +} +} +lean_object* l_Lean_getPPAll___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lean_getPPAll(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +lean_object* _init_l_Lean_ppOptions___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(pretty printer) display implicit arguments"); +return x_1; +} +} +lean_object* _init_l_Lean_ppOptions___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lean_registerTraceClass___closed__1; +x_2 = l_Lean_getPPBinderTypes___closed__1; +x_3 = l_Lean_ppOptions___closed__1; +x_4 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +lean_object* l_Lean_ppOptions(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_2 = l_Lean_getPPExplicit___closed__1; +x_3 = l_Lean_ppOptions___closed__2; +x_4 = lean_register_option(x_2, x_3, x_1); +if (lean_obj_tag(x_4) == 0) +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_ctor_get(x_4, 0); +lean_dec(x_6); +x_7 = lean_box(0); +lean_ctor_set(x_4, 0, x_7); +return x_4; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_4, 1); +lean_inc(x_8); +lean_dec(x_4); +x_9 = lean_box(0); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_8); +return x_10; +} +} +else +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_4); +if (x_11 == 0) +{ +return x_4; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_4, 0); +x_13 = lean_ctor_get(x_4, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_4); +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; +} +} +} +} +lean_object* l_ReaderT_failure___at_Lean_Delaborator_DelabM_inhabited___spec__1___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = lean_box(0); +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* l_ReaderT_failure___at_Lean_Delaborator_DelabM_inhabited___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_ReaderT_failure___at_Lean_Delaborator_DelabM_inhabited___spec__1___rarg), 1, 0); +return x_4; +} +} +lean_object* _init_l_Lean_Delaborator_DelabM_inhabited___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_ReaderT_failure___at_Lean_Delaborator_DelabM_inhabited___spec__1___boxed), 3, 1); +lean_closure_set(x_1, 0, lean_box(0)); +return x_1; +} +} +lean_object* l_Lean_Delaborator_DelabM_inhabited(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +return x_2; +} +} +lean_object* l_ReaderT_failure___at_Lean_Delaborator_DelabM_inhabited___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_ReaderT_failure___at_Lean_Delaborator_DelabM_inhabited___spec__1(x_1, x_2, x_3); +lean_dec(x_3); +lean_dec(x_2); +return x_4; +} +} +lean_object* l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_5, 0, x_1); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_4); +return x_6; +} +} +lean_object* l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1___rarg___boxed), 4, 0); +return x_2; +} +} +lean_object* l_Lean_Delaborator_DelabM_monadQuotation___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = lean_apply_3(x_2, x_3, x_4, x_5); +return x_6; +} +} +lean_object* _init_l_Lean_Delaborator_DelabM_monadQuotation___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_DelabM_monadQuotation___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_box(0); +x_2 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_DelabM_monadQuotation___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_DelabM_monadQuotation___lambda__1), 5, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_DelabM_monadQuotation___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lean_Delaborator_DelabM_monadQuotation___closed__1; +x_2 = l_Lean_Delaborator_DelabM_monadQuotation___closed__2; +x_3 = l_Lean_Delaborator_DelabM_monadQuotation___closed__3; +x_4 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +lean_object* _init_l_Lean_Delaborator_DelabM_monadQuotation() { +_start: +{ +lean_object* x_1; +x_1 = l_Lean_Delaborator_DelabM_monadQuotation___closed__4; +return x_1; +} +} +lean_object* l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_ReaderT_pure___at_Lean_Delaborator_DelabM_monadQuotation___spec__1___rarg(x_1, x_2, x_3, x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_5; +} +} lean_object* _init_l_Lean_Delaborator_mkDelabAttribute___lambda__1___closed__1() { _start: { @@ -171,7 +1602,7 @@ lean_object* _init_l_Lean_Delaborator_mkDelabAttribute___closed__9() { _start: { lean_object* x_1; -x_1 = lean_mk_string("delaborator"); +x_1 = lean_mk_string("Register a delaborator.\n\n[delab k] registers a declaration of type `Lean.Delaborator.Delab` for the `Lean.Expr`\nconstructor `k`. Multiple delaborators for a single constructor are tried in turn until\nthe first success. If the term to be delaborated is an application of a constant `c`,\nelaborators for `app.c` are tried first; this is also done for `Expr.const`s (\"nullary applications\")\nto reduce special casing. If the term is an `Expr.mdata` with a single key `k`, `mdata.k`\nis tried first."); return x_1; } } @@ -331,7 +1762,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj x_1 = l_Lean_Delaborator_delabAttribute___closed__3; x_2 = lean_box(0); x_3 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__1; -x_4 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__2; +x_4 = l_Lean_Meta_recursorAttribute___closed__1; x_5 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__3; x_6 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__4; x_7 = lean_alloc_ctor(0, 6, 0); @@ -356,7 +1787,11946 @@ lean_ctor_set(x_3, 1, x_2); return x_3; } } +lean_object* l_Lean_Delaborator_getExpr(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +x_5 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_5, 0, x_4); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_3); +return x_6; +} +} +lean_object* l_Lean_Delaborator_getExpr___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Delaborator_getExpr(x_1, x_2, x_3); +lean_dec(x_2); +lean_dec(x_1); +return x_4; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("bvar"); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Delaborator_getExprKind___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__2; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("fvar"); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Delaborator_getExprKind___closed__4; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__5; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("mvar"); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Delaborator_getExprKind___closed__7; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__8; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Parser_Term_sort___elambda__1___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__10; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_mkAppStx___closed__7; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__12; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__14() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("lam"); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__15() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Delaborator_getExprKind___closed__14; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__16() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__15; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__17() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("forallE"); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__18() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Delaborator_getExprKind___closed__17; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__19() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__18; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__20() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("letE"); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__21() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Delaborator_getExprKind___closed__20; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__22() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__21; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__23() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("lit"); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__24() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Delaborator_getExprKind___closed__23; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__25() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__24; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__26() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("mdata"); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__27() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Delaborator_getExprKind___closed__26; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__28() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__27; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__29() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Parser_Term_proj___elambda__1___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__30() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__29; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__31() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("localE"); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__32() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Delaborator_getExprKind___closed__31; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_getExprKind___closed__33() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_getExprKind___closed__32; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* l_Lean_Delaborator_getExprKind(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = l_Lean_Delaborator_getExpr(x_1, x_2, x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_5, 0); +switch (lean_obj_tag(x_7)) { +case 0: +{ +uint8_t x_8; +lean_free_object(x_5); +lean_dec(x_7); +x_8 = !lean_is_exclusive(x_4); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_4, 0); +lean_dec(x_9); +x_10 = l_Lean_Delaborator_getExprKind___closed__3; +lean_ctor_set(x_4, 0, x_10); +return x_4; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_4, 1); +lean_inc(x_11); +lean_dec(x_4); +x_12 = l_Lean_Delaborator_getExprKind___closed__3; +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +return x_13; +} +} +case 1: +{ +uint8_t x_14; +lean_free_object(x_5); +lean_dec(x_7); +x_14 = !lean_is_exclusive(x_4); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_ctor_get(x_4, 0); +lean_dec(x_15); +x_16 = l_Lean_Delaborator_getExprKind___closed__6; +lean_ctor_set(x_4, 0, x_16); +return x_4; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_4, 1); +lean_inc(x_17); +lean_dec(x_4); +x_18 = l_Lean_Delaborator_getExprKind___closed__6; +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_17); +return x_19; +} +} +case 2: +{ +uint8_t x_20; +lean_free_object(x_5); +lean_dec(x_7); +x_20 = !lean_is_exclusive(x_4); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_4, 0); +lean_dec(x_21); +x_22 = l_Lean_Delaborator_getExprKind___closed__9; +lean_ctor_set(x_4, 0, x_22); +return x_4; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_4, 1); +lean_inc(x_23); +lean_dec(x_4); +x_24 = l_Lean_Delaborator_getExprKind___closed__9; +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_23); +return x_25; +} +} +case 3: +{ +uint8_t x_26; +lean_free_object(x_5); +lean_dec(x_7); +x_26 = !lean_is_exclusive(x_4); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_4, 0); +lean_dec(x_27); +x_28 = l_Lean_Delaborator_getExprKind___closed__11; +lean_ctor_set(x_4, 0, x_28); +return x_4; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_4, 1); +lean_inc(x_29); +lean_dec(x_4); +x_30 = l_Lean_Delaborator_getExprKind___closed__11; +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_29); +return x_31; +} +} +case 4: +{ +uint8_t x_32; +x_32 = !lean_is_exclusive(x_4); +if (x_32 == 0) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_4, 0); +lean_dec(x_33); +x_34 = lean_ctor_get(x_7, 0); +lean_inc(x_34); +lean_dec(x_7); +x_35 = l_Lean_Delaborator_getExprKind___closed__12; +x_36 = l_Lean_Name_append___main(x_35, x_34); +lean_ctor_set(x_5, 0, x_36); +return x_4; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_37 = lean_ctor_get(x_4, 1); +lean_inc(x_37); +lean_dec(x_4); +x_38 = lean_ctor_get(x_7, 0); +lean_inc(x_38); +lean_dec(x_7); +x_39 = l_Lean_Delaborator_getExprKind___closed__12; +x_40 = l_Lean_Name_append___main(x_39, x_38); +lean_ctor_set(x_5, 0, x_40); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_5); +lean_ctor_set(x_41, 1, x_37); +return x_41; +} +} +case 5: +{ +uint8_t x_42; +x_42 = !lean_is_exclusive(x_4); +if (x_42 == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_4, 0); +lean_dec(x_43); +x_44 = lean_ctor_get(x_7, 0); +lean_inc(x_44); +lean_dec(x_7); +x_45 = l_Lean_Expr_getAppFn___main(x_44); +lean_dec(x_44); +if (lean_obj_tag(x_45) == 4) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +lean_dec(x_45); +x_47 = l_Lean_Delaborator_getExprKind___closed__12; +x_48 = l_Lean_Name_append___main(x_47, x_46); +lean_ctor_set(x_5, 0, x_48); +return x_4; +} +else +{ +lean_object* x_49; +lean_dec(x_45); +lean_free_object(x_5); +x_49 = l_Lean_Delaborator_getExprKind___closed__13; +lean_ctor_set(x_4, 0, x_49); +return x_4; +} +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_4, 1); +lean_inc(x_50); +lean_dec(x_4); +x_51 = lean_ctor_get(x_7, 0); +lean_inc(x_51); +lean_dec(x_7); +x_52 = l_Lean_Expr_getAppFn___main(x_51); +lean_dec(x_51); +if (lean_obj_tag(x_52) == 4) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 0); +lean_inc(x_53); +lean_dec(x_52); +x_54 = l_Lean_Delaborator_getExprKind___closed__12; +x_55 = l_Lean_Name_append___main(x_54, x_53); +lean_ctor_set(x_5, 0, x_55); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_5); +lean_ctor_set(x_56, 1, x_50); +return x_56; +} +else +{ +lean_object* x_57; lean_object* x_58; +lean_dec(x_52); +lean_free_object(x_5); +x_57 = l_Lean_Delaborator_getExprKind___closed__13; +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_50); +return x_58; +} +} +} +case 6: +{ +uint8_t x_59; +lean_free_object(x_5); +lean_dec(x_7); +x_59 = !lean_is_exclusive(x_4); +if (x_59 == 0) +{ +lean_object* x_60; lean_object* x_61; +x_60 = lean_ctor_get(x_4, 0); +lean_dec(x_60); +x_61 = l_Lean_Delaborator_getExprKind___closed__16; +lean_ctor_set(x_4, 0, x_61); +return x_4; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_62 = lean_ctor_get(x_4, 1); +lean_inc(x_62); +lean_dec(x_4); +x_63 = l_Lean_Delaborator_getExprKind___closed__16; +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_62); +return x_64; +} +} +case 7: +{ +uint8_t x_65; +lean_free_object(x_5); +lean_dec(x_7); +x_65 = !lean_is_exclusive(x_4); +if (x_65 == 0) +{ +lean_object* x_66; lean_object* x_67; +x_66 = lean_ctor_get(x_4, 0); +lean_dec(x_66); +x_67 = l_Lean_Delaborator_getExprKind___closed__19; +lean_ctor_set(x_4, 0, x_67); +return x_4; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_68 = lean_ctor_get(x_4, 1); +lean_inc(x_68); +lean_dec(x_4); +x_69 = l_Lean_Delaborator_getExprKind___closed__19; +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_68); +return x_70; +} +} +case 8: +{ +uint8_t x_71; +lean_free_object(x_5); +lean_dec(x_7); +x_71 = !lean_is_exclusive(x_4); +if (x_71 == 0) +{ +lean_object* x_72; lean_object* x_73; +x_72 = lean_ctor_get(x_4, 0); +lean_dec(x_72); +x_73 = l_Lean_Delaborator_getExprKind___closed__22; +lean_ctor_set(x_4, 0, x_73); +return x_4; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_4, 1); +lean_inc(x_74); +lean_dec(x_4); +x_75 = l_Lean_Delaborator_getExprKind___closed__22; +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +case 9: +{ +uint8_t x_77; +lean_free_object(x_5); +lean_dec(x_7); +x_77 = !lean_is_exclusive(x_4); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; +x_78 = lean_ctor_get(x_4, 0); +lean_dec(x_78); +x_79 = l_Lean_Delaborator_getExprKind___closed__25; +lean_ctor_set(x_4, 0, x_79); +return x_4; +} +else +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_80 = lean_ctor_get(x_4, 1); +lean_inc(x_80); +lean_dec(x_4); +x_81 = l_Lean_Delaborator_getExprKind___closed__25; +x_82 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_80); +return x_82; +} +} +case 10: +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_7, 0); +lean_inc(x_83); +lean_dec(x_7); +if (lean_obj_tag(x_83) == 0) +{ +uint8_t x_84; +lean_free_object(x_5); +x_84 = !lean_is_exclusive(x_4); +if (x_84 == 0) +{ +lean_object* x_85; lean_object* x_86; +x_85 = lean_ctor_get(x_4, 0); +lean_dec(x_85); +x_86 = l_Lean_Delaborator_getExprKind___closed__28; +lean_ctor_set(x_4, 0, x_86); +return x_4; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_4, 1); +lean_inc(x_87); +lean_dec(x_4); +x_88 = l_Lean_Delaborator_getExprKind___closed__28; +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_87); +return x_89; +} +} +else +{ +lean_object* x_90; lean_object* x_91; +x_90 = lean_ctor_get(x_83, 0); +lean_inc(x_90); +x_91 = lean_ctor_get(x_83, 1); +lean_inc(x_91); +lean_dec(x_83); +if (lean_obj_tag(x_91) == 0) +{ +uint8_t x_92; +x_92 = !lean_is_exclusive(x_4); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_93 = lean_ctor_get(x_4, 0); +lean_dec(x_93); +x_94 = lean_ctor_get(x_90, 0); +lean_inc(x_94); +lean_dec(x_90); +x_95 = l_Lean_Delaborator_getExprKind___closed__27; +x_96 = l_Lean_Name_append___main(x_95, x_94); +lean_ctor_set(x_5, 0, x_96); +return x_4; +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_4, 1); +lean_inc(x_97); +lean_dec(x_4); +x_98 = lean_ctor_get(x_90, 0); +lean_inc(x_98); +lean_dec(x_90); +x_99 = l_Lean_Delaborator_getExprKind___closed__27; +x_100 = l_Lean_Name_append___main(x_99, x_98); +lean_ctor_set(x_5, 0, x_100); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_5); +lean_ctor_set(x_101, 1, x_97); +return x_101; +} +} +else +{ +uint8_t x_102; +lean_dec(x_91); +lean_dec(x_90); +lean_free_object(x_5); +x_102 = !lean_is_exclusive(x_4); +if (x_102 == 0) +{ +lean_object* x_103; lean_object* x_104; +x_103 = lean_ctor_get(x_4, 0); +lean_dec(x_103); +x_104 = l_Lean_Delaborator_getExprKind___closed__28; +lean_ctor_set(x_4, 0, x_104); +return x_4; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_105 = lean_ctor_get(x_4, 1); +lean_inc(x_105); +lean_dec(x_4); +x_106 = l_Lean_Delaborator_getExprKind___closed__28; +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_105); +return x_107; +} +} +} +} +case 11: +{ +uint8_t x_108; +lean_free_object(x_5); +lean_dec(x_7); +x_108 = !lean_is_exclusive(x_4); +if (x_108 == 0) +{ +lean_object* x_109; lean_object* x_110; +x_109 = lean_ctor_get(x_4, 0); +lean_dec(x_109); +x_110 = l_Lean_Delaborator_getExprKind___closed__30; +lean_ctor_set(x_4, 0, x_110); +return x_4; +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_111 = lean_ctor_get(x_4, 1); +lean_inc(x_111); +lean_dec(x_4); +x_112 = l_Lean_Delaborator_getExprKind___closed__30; +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_111); +return x_113; +} +} +default: +{ +uint8_t x_114; +lean_free_object(x_5); +lean_dec(x_7); +x_114 = !lean_is_exclusive(x_4); +if (x_114 == 0) +{ +lean_object* x_115; lean_object* x_116; +x_115 = lean_ctor_get(x_4, 0); +lean_dec(x_115); +x_116 = l_Lean_Delaborator_getExprKind___closed__33; +lean_ctor_set(x_4, 0, x_116); +return x_4; +} +else +{ +lean_object* x_117; lean_object* x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 1); +lean_inc(x_117); +lean_dec(x_4); +x_118 = l_Lean_Delaborator_getExprKind___closed__33; +x_119 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_119, 0, x_118); +lean_ctor_set(x_119, 1, x_117); +return x_119; +} +} +} +} +else +{ +lean_object* x_120; +x_120 = lean_ctor_get(x_5, 0); +lean_inc(x_120); +lean_dec(x_5); +switch (lean_obj_tag(x_120)) { +case 0: +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_120); +x_121 = lean_ctor_get(x_4, 1); +lean_inc(x_121); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_122 = x_4; +} else { + lean_dec_ref(x_4); + x_122 = lean_box(0); +} +x_123 = l_Lean_Delaborator_getExprKind___closed__3; +if (lean_is_scalar(x_122)) { + x_124 = lean_alloc_ctor(0, 2, 0); +} else { + x_124 = x_122; +} +lean_ctor_set(x_124, 0, x_123); +lean_ctor_set(x_124, 1, x_121); +return x_124; +} +case 1: +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; +lean_dec(x_120); +x_125 = lean_ctor_get(x_4, 1); +lean_inc(x_125); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_126 = x_4; +} else { + lean_dec_ref(x_4); + x_126 = lean_box(0); +} +x_127 = l_Lean_Delaborator_getExprKind___closed__6; +if (lean_is_scalar(x_126)) { + x_128 = lean_alloc_ctor(0, 2, 0); +} else { + x_128 = x_126; +} +lean_ctor_set(x_128, 0, x_127); +lean_ctor_set(x_128, 1, x_125); +return x_128; +} +case 2: +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; +lean_dec(x_120); +x_129 = lean_ctor_get(x_4, 1); +lean_inc(x_129); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_130 = x_4; +} else { + lean_dec_ref(x_4); + x_130 = lean_box(0); +} +x_131 = l_Lean_Delaborator_getExprKind___closed__9; +if (lean_is_scalar(x_130)) { + x_132 = lean_alloc_ctor(0, 2, 0); +} else { + x_132 = x_130; +} +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_129); +return x_132; +} +case 3: +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; +lean_dec(x_120); +x_133 = lean_ctor_get(x_4, 1); +lean_inc(x_133); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_134 = x_4; +} else { + lean_dec_ref(x_4); + x_134 = lean_box(0); +} +x_135 = l_Lean_Delaborator_getExprKind___closed__11; +if (lean_is_scalar(x_134)) { + x_136 = lean_alloc_ctor(0, 2, 0); +} else { + x_136 = x_134; +} +lean_ctor_set(x_136, 0, x_135); +lean_ctor_set(x_136, 1, x_133); +return x_136; +} +case 4: +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_137 = lean_ctor_get(x_4, 1); +lean_inc(x_137); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_138 = x_4; +} else { + lean_dec_ref(x_4); + x_138 = lean_box(0); +} +x_139 = lean_ctor_get(x_120, 0); +lean_inc(x_139); +lean_dec(x_120); +x_140 = l_Lean_Delaborator_getExprKind___closed__12; +x_141 = l_Lean_Name_append___main(x_140, x_139); +x_142 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_142, 0, x_141); +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_142); +lean_ctor_set(x_143, 1, x_137); +return x_143; +} +case 5: +{ +lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_144 = lean_ctor_get(x_4, 1); +lean_inc(x_144); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_145 = x_4; +} else { + lean_dec_ref(x_4); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_120, 0); +lean_inc(x_146); +lean_dec(x_120); +x_147 = l_Lean_Expr_getAppFn___main(x_146); +lean_dec(x_146); +if (lean_obj_tag(x_147) == 4) +{ +lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_148 = lean_ctor_get(x_147, 0); +lean_inc(x_148); +lean_dec(x_147); +x_149 = l_Lean_Delaborator_getExprKind___closed__12; +x_150 = l_Lean_Name_append___main(x_149, x_148); +x_151 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_151, 0, x_150); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(0, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_151); +lean_ctor_set(x_152, 1, x_144); +return x_152; +} +else +{ +lean_object* x_153; lean_object* x_154; +lean_dec(x_147); +x_153 = l_Lean_Delaborator_getExprKind___closed__13; +if (lean_is_scalar(x_145)) { + x_154 = lean_alloc_ctor(0, 2, 0); +} else { + x_154 = x_145; +} +lean_ctor_set(x_154, 0, x_153); +lean_ctor_set(x_154, 1, x_144); +return x_154; +} +} +case 6: +{ +lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; +lean_dec(x_120); +x_155 = lean_ctor_get(x_4, 1); +lean_inc(x_155); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_156 = x_4; +} else { + lean_dec_ref(x_4); + x_156 = lean_box(0); +} +x_157 = l_Lean_Delaborator_getExprKind___closed__16; +if (lean_is_scalar(x_156)) { + x_158 = lean_alloc_ctor(0, 2, 0); +} else { + x_158 = x_156; +} +lean_ctor_set(x_158, 0, x_157); +lean_ctor_set(x_158, 1, x_155); +return x_158; +} +case 7: +{ +lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; +lean_dec(x_120); +x_159 = lean_ctor_get(x_4, 1); +lean_inc(x_159); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_160 = x_4; +} else { + lean_dec_ref(x_4); + x_160 = lean_box(0); +} +x_161 = l_Lean_Delaborator_getExprKind___closed__19; +if (lean_is_scalar(x_160)) { + x_162 = lean_alloc_ctor(0, 2, 0); +} else { + x_162 = x_160; +} +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_159); +return x_162; +} +case 8: +{ +lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; +lean_dec(x_120); +x_163 = lean_ctor_get(x_4, 1); +lean_inc(x_163); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_164 = x_4; +} else { + lean_dec_ref(x_4); + x_164 = lean_box(0); +} +x_165 = l_Lean_Delaborator_getExprKind___closed__22; +if (lean_is_scalar(x_164)) { + x_166 = lean_alloc_ctor(0, 2, 0); +} else { + x_166 = x_164; +} +lean_ctor_set(x_166, 0, x_165); +lean_ctor_set(x_166, 1, x_163); +return x_166; +} +case 9: +{ +lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; +lean_dec(x_120); +x_167 = lean_ctor_get(x_4, 1); +lean_inc(x_167); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_168 = x_4; +} else { + lean_dec_ref(x_4); + x_168 = lean_box(0); +} +x_169 = l_Lean_Delaborator_getExprKind___closed__25; +if (lean_is_scalar(x_168)) { + x_170 = lean_alloc_ctor(0, 2, 0); +} else { + x_170 = x_168; +} +lean_ctor_set(x_170, 0, x_169); +lean_ctor_set(x_170, 1, x_167); +return x_170; +} +case 10: +{ +lean_object* x_171; +x_171 = lean_ctor_get(x_120, 0); +lean_inc(x_171); +lean_dec(x_120); +if (lean_obj_tag(x_171) == 0) +{ +lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; +x_172 = lean_ctor_get(x_4, 1); +lean_inc(x_172); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_173 = x_4; +} else { + lean_dec_ref(x_4); + x_173 = lean_box(0); +} +x_174 = l_Lean_Delaborator_getExprKind___closed__28; +if (lean_is_scalar(x_173)) { + x_175 = lean_alloc_ctor(0, 2, 0); +} else { + x_175 = x_173; +} +lean_ctor_set(x_175, 0, x_174); +lean_ctor_set(x_175, 1, x_172); +return x_175; +} +else +{ +lean_object* x_176; lean_object* x_177; +x_176 = lean_ctor_get(x_171, 0); +lean_inc(x_176); +x_177 = lean_ctor_get(x_171, 1); +lean_inc(x_177); +lean_dec(x_171); +if (lean_obj_tag(x_177) == 0) +{ +lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; +x_178 = lean_ctor_get(x_4, 1); +lean_inc(x_178); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_179 = x_4; +} else { + lean_dec_ref(x_4); + x_179 = lean_box(0); +} +x_180 = lean_ctor_get(x_176, 0); +lean_inc(x_180); +lean_dec(x_176); +x_181 = l_Lean_Delaborator_getExprKind___closed__27; +x_182 = l_Lean_Name_append___main(x_181, x_180); +x_183 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_183, 0, x_182); +if (lean_is_scalar(x_179)) { + x_184 = lean_alloc_ctor(0, 2, 0); +} else { + x_184 = x_179; +} +lean_ctor_set(x_184, 0, x_183); +lean_ctor_set(x_184, 1, x_178); +return x_184; +} +else +{ +lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; +lean_dec(x_177); +lean_dec(x_176); +x_185 = lean_ctor_get(x_4, 1); +lean_inc(x_185); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_186 = x_4; +} else { + lean_dec_ref(x_4); + x_186 = lean_box(0); +} +x_187 = l_Lean_Delaborator_getExprKind___closed__28; +if (lean_is_scalar(x_186)) { + x_188 = lean_alloc_ctor(0, 2, 0); +} else { + x_188 = x_186; +} +lean_ctor_set(x_188, 0, x_187); +lean_ctor_set(x_188, 1, x_185); +return x_188; +} +} +} +case 11: +{ +lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; +lean_dec(x_120); +x_189 = lean_ctor_get(x_4, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_190 = x_4; +} else { + lean_dec_ref(x_4); + x_190 = lean_box(0); +} +x_191 = l_Lean_Delaborator_getExprKind___closed__30; +if (lean_is_scalar(x_190)) { + x_192 = lean_alloc_ctor(0, 2, 0); +} else { + x_192 = x_190; +} +lean_ctor_set(x_192, 0, x_191); +lean_ctor_set(x_192, 1, x_189); +return x_192; +} +default: +{ +lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; +lean_dec(x_120); +x_193 = lean_ctor_get(x_4, 1); +lean_inc(x_193); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_194 = x_4; +} else { + lean_dec_ref(x_4); + x_194 = lean_box(0); +} +x_195 = l_Lean_Delaborator_getExprKind___closed__33; +if (lean_is_scalar(x_194)) { + x_196 = lean_alloc_ctor(0, 2, 0); +} else { + x_196 = x_194; +} +lean_ctor_set(x_196, 0, x_195); +lean_ctor_set(x_196, 1, x_193); +return x_196; +} +} +} +} +} +lean_object* l_Lean_Delaborator_getExprKind___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Delaborator_getExprKind(x_1, x_2, x_3); +lean_dec(x_2); +lean_dec(x_1); +return x_4; +} +} +lean_object* l_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_3; +x_3 = lean_box(0); +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get(x_1, 1); +x_6 = lean_ctor_get(x_1, 2); +x_7 = lean_ctor_get(x_1, 3); +x_8 = lean_nat_dec_lt(x_2, x_5); +if (x_8 == 0) +{ +uint8_t x_9; +x_9 = lean_nat_dec_lt(x_5, x_2); +if (x_9 == 0) +{ +lean_object* x_10; +lean_inc(x_6); +x_10 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_10, 0, x_6); +return x_10; +} +else +{ +x_1 = x_7; +goto _start; +} +} +else +{ +x_1 = x_4; +goto _start; +} +} +} +} +lean_object* _init_l_Lean_Delaborator_getPPOption___closed__1() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 1; +x_2 = lean_box(x_1); +x_3 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_3, 0, x_2); +return x_3; +} +} +lean_object* l_Lean_Delaborator_getPPOption(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; uint8_t x_7; +x_5 = lean_ctor_get(x_2, 2); +lean_inc(x_5); +lean_inc(x_1); +lean_inc(x_5); +x_6 = lean_apply_1(x_1, x_5); +x_7 = lean_unbox(x_6); +lean_dec(x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_2, 3); +lean_inc(x_8); +x_9 = lean_ctor_get(x_2, 1); +lean_inc(x_9); +lean_dec(x_2); +x_10 = l_Lean_getPPAll(x_5); +lean_dec(x_5); +x_11 = l_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(x_8, x_9); +lean_dec(x_9); +lean_dec(x_8); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_1); +x_12 = lean_box(x_10); +x_13 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_13, 0, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_4); +return x_14; +} +else +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_11); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; +x_16 = lean_ctor_get(x_11, 0); +lean_inc(x_16); +x_17 = lean_apply_1(x_1, x_16); +x_18 = lean_unbox(x_17); +lean_dec(x_17); +if (x_18 == 0) +{ +uint8_t x_19; lean_object* x_20; lean_object* x_21; +x_19 = l_Lean_getPPAll(x_16); +lean_dec(x_16); +x_20 = lean_box(x_19); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_4); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; +lean_free_object(x_11); +lean_dec(x_16); +x_22 = l_Lean_Delaborator_getPPOption___closed__1; +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_4); +return x_23; +} +} +else +{ +lean_object* x_24; lean_object* x_25; uint8_t x_26; +x_24 = lean_ctor_get(x_11, 0); +lean_inc(x_24); +lean_dec(x_11); +lean_inc(x_24); +x_25 = lean_apply_1(x_1, x_24); +x_26 = lean_unbox(x_25); +lean_dec(x_25); +if (x_26 == 0) +{ +uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_27 = l_Lean_getPPAll(x_24); +lean_dec(x_24); +x_28 = lean_box(x_27); +x_29 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_29, 0, x_28); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_4); +return x_30; +} +else +{ +lean_object* x_31; lean_object* x_32; +lean_dec(x_24); +x_31 = l_Lean_Delaborator_getPPOption___closed__1; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_4); +return x_32; +} +} +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_dec(x_5); +x_33 = lean_ctor_get(x_2, 3); +lean_inc(x_33); +x_34 = lean_ctor_get(x_2, 1); +lean_inc(x_34); +lean_dec(x_2); +x_35 = l_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(x_33, x_34); +lean_dec(x_34); +lean_dec(x_33); +if (lean_obj_tag(x_35) == 0) +{ +lean_object* x_36; lean_object* x_37; +lean_dec(x_1); +x_36 = l_Lean_Delaborator_getPPOption___closed__1; +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_4); +return x_37; +} +else +{ +uint8_t x_38; +x_38 = !lean_is_exclusive(x_35); +if (x_38 == 0) +{ +lean_object* x_39; lean_object* x_40; uint8_t x_41; +x_39 = lean_ctor_get(x_35, 0); +lean_inc(x_39); +x_40 = lean_apply_1(x_1, x_39); +x_41 = lean_unbox(x_40); +lean_dec(x_40); +if (x_41 == 0) +{ +uint8_t x_42; lean_object* x_43; lean_object* x_44; +x_42 = l_Lean_getPPAll(x_39); +lean_dec(x_39); +x_43 = lean_box(x_42); +lean_ctor_set(x_35, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_35); +lean_ctor_set(x_44, 1, x_4); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; +lean_free_object(x_35); +lean_dec(x_39); +x_45 = l_Lean_Delaborator_getPPOption___closed__1; +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_4); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; uint8_t x_49; +x_47 = lean_ctor_get(x_35, 0); +lean_inc(x_47); +lean_dec(x_35); +lean_inc(x_47); +x_48 = lean_apply_1(x_1, x_47); +x_49 = lean_unbox(x_48); +lean_dec(x_48); +if (x_49 == 0) +{ +uint8_t x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_50 = l_Lean_getPPAll(x_47); +lean_dec(x_47); +x_51 = lean_box(x_50); +x_52 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_52, 0, x_51); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_4); +return x_53; +} +else +{ +lean_object* x_54; lean_object* x_55; +lean_dec(x_47); +x_54 = l_Lean_Delaborator_getPPOption___closed__1; +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_4); +return x_55; +} +} +} +} +} +} +lean_object* l_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_Lean_Delaborator_getPPOption___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_Delaborator_getPPOption(x_1, x_2, x_3, x_4); +lean_dec(x_3); +return x_5; +} +} +lean_object* l_Lean_Delaborator_whenPPOption(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; +lean_inc(x_3); +x_6 = l_Lean_Delaborator_getPPOption(x_1, x_3, x_4, x_5); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +lean_dec(x_7); +x_9 = lean_unbox(x_8); +lean_dec(x_8); +if (x_9 == 0) +{ +uint8_t x_10; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_10 = !lean_is_exclusive(x_6); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_6, 0); +lean_dec(x_11); +x_12 = lean_box(0); +lean_ctor_set(x_6, 0, x_12); +return x_6; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_13 = lean_ctor_get(x_6, 1); +lean_inc(x_13); +lean_dec(x_6); +x_14 = lean_box(0); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_13); +return x_15; +} +} +else +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_dec(x_6); +x_17 = lean_apply_3(x_2, x_3, x_4, x_16); +return x_17; +} +} +} +lean_object* l_Lean_Delaborator_whenNotPPOption(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; +lean_inc(x_3); +x_6 = l_Lean_Delaborator_getPPOption(x_1, x_3, x_4, x_5); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +lean_dec(x_7); +x_9 = lean_unbox(x_8); +lean_dec(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_6, 1); +lean_inc(x_10); +lean_dec(x_6); +x_11 = lean_apply_3(x_2, x_3, x_4, x_10); +return x_11; +} +else +{ +uint8_t x_12; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_12 = !lean_is_exclusive(x_6); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_6, 0); +lean_dec(x_13); +x_14 = lean_box(0); +lean_ctor_set(x_6, 0, x_14); +return x_6; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_6, 1); +lean_inc(x_15); +lean_dec(x_6); +x_16 = lean_box(0); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +return x_17; +} +} +} +} +lean_object* l_Lean_Delaborator_descend___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_4); +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; +x_8 = lean_ctor_get(x_4, 1); +x_9 = lean_ctor_get(x_4, 0); +lean_dec(x_9); +x_10 = lean_unsigned_to_nat(3u); +x_11 = lean_nat_mul(x_8, x_10); +lean_dec(x_8); +x_12 = lean_nat_add(x_11, x_2); +lean_dec(x_11); +lean_ctor_set(x_4, 1, x_12); +lean_ctor_set(x_4, 0, x_1); +x_13 = lean_apply_3(x_3, x_4, x_5, x_6); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_14 = lean_ctor_get(x_4, 1); +x_15 = lean_ctor_get(x_4, 2); +x_16 = lean_ctor_get(x_4, 3); +lean_inc(x_16); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_4); +x_17 = lean_unsigned_to_nat(3u); +x_18 = lean_nat_mul(x_14, x_17); +lean_dec(x_14); +x_19 = lean_nat_add(x_18, x_2); +lean_dec(x_18); +x_20 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_20, 0, x_1); +lean_ctor_set(x_20, 1, x_19); +lean_ctor_set(x_20, 2, x_15); +lean_ctor_set(x_20, 3, x_16); +x_21 = lean_apply_3(x_3, x_20, x_5, x_6); +return x_21; +} +} +} +lean_object* l_Lean_Delaborator_descend(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Delaborator_descend___rarg___boxed), 6, 0); +return x_2; +} +} +lean_object* l_Lean_Delaborator_descend___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lean_Delaborator_descend___rarg(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_2); +return x_7; +} +} +lean_object* l_Lean_Delaborator_withAppFn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = l_Lean_Delaborator_getExpr(x_2, x_3, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +lean_dec(x_6); +if (lean_obj_tag(x_7) == 5) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_dec(x_5); +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_unsigned_to_nat(0u); +x_11 = l_Lean_Delaborator_descend___rarg(x_9, x_10, x_1, x_2, x_3, x_8); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +lean_dec(x_7); +lean_dec(x_1); +x_12 = lean_ctor_get(x_5, 1); +lean_inc(x_12); +lean_dec(x_5); +x_13 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_14 = l_unreachable_x21___rarg(x_13); +x_15 = lean_apply_3(x_14, x_2, x_3, x_12); +return x_15; +} +} +} +lean_object* l_Lean_Delaborator_withAppFn(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Delaborator_withAppFn___rarg), 4, 0); +return x_2; +} +} +lean_object* l_Lean_Delaborator_withAppArg___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = l_Lean_Delaborator_getExpr(x_2, x_3, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +lean_dec(x_6); +if (lean_obj_tag(x_7) == 5) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_dec(x_5); +x_9 = lean_ctor_get(x_7, 1); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_unsigned_to_nat(1u); +x_11 = l_Lean_Delaborator_descend___rarg(x_9, x_10, x_1, x_2, x_3, x_8); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +lean_dec(x_7); +lean_dec(x_1); +x_12 = lean_ctor_get(x_5, 1); +lean_inc(x_12); +lean_dec(x_5); +x_13 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_14 = l_unreachable_x21___rarg(x_13); +x_15 = lean_apply_3(x_14, x_2, x_3, x_12); +return x_15; +} +} +} +lean_object* l_Lean_Delaborator_withAppArg(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Delaborator_withAppArg___rarg), 4, 0); +return x_2; +} +} +lean_object* l_Lean_Delaborator_withAppFnArgs___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = l_Lean_Delaborator_getExpr(x_3, x_4, x_5); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +lean_dec(x_7); +if (lean_obj_tag(x_8) == 5) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +lean_inc(x_2); +x_10 = lean_alloc_closure((void*)(l_Lean_Delaborator_withAppFnArgs___main___rarg), 5, 2); +lean_closure_set(x_10, 0, x_1); +lean_closure_set(x_10, 1, x_2); +lean_inc(x_4); +lean_inc(x_3); +x_11 = l_Lean_Delaborator_withAppFn___rarg(x_10, x_3, x_4, x_9); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +uint8_t x_13; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_13 = !lean_is_exclusive(x_11); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; +x_14 = lean_ctor_get(x_11, 0); +lean_dec(x_14); +x_15 = lean_box(0); +lean_ctor_set(x_11, 0, x_15); +return x_11; +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_11, 1); +lean_inc(x_16); +lean_dec(x_11); +x_17 = lean_box(0); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_16); +return x_18; +} +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_11, 1); +lean_inc(x_19); +lean_dec(x_11); +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +x_21 = lean_apply_1(x_2, x_20); +x_22 = l_Lean_Delaborator_withAppArg___rarg(x_21, x_3, x_4, x_19); +return x_22; +} +} +else +{ +uint8_t x_23; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_23 = !lean_is_exclusive(x_11); +if (x_23 == 0) +{ +return x_11; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_11, 0); +x_25 = lean_ctor_get(x_11, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_11); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_25); +return x_26; +} +} +} +else +{ +lean_object* x_27; lean_object* x_28; +lean_dec(x_8); +lean_dec(x_2); +x_27 = lean_ctor_get(x_6, 1); +lean_inc(x_27); +lean_dec(x_6); +x_28 = lean_apply_3(x_1, x_3, x_4, x_27); +return x_28; +} +} +} +lean_object* l_Lean_Delaborator_withAppFnArgs___main(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Delaborator_withAppFnArgs___main___rarg), 5, 0); +return x_2; +} +} +lean_object* l_Lean_Delaborator_withAppFnArgs___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lean_Delaborator_withAppFnArgs___main___rarg(x_1, x_2, x_3, x_4, x_5); +return x_6; +} +} +lean_object* l_Lean_Delaborator_withAppFnArgs(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Delaborator_withAppFnArgs___rarg), 5, 0); +return x_2; +} +} +lean_object* l_Lean_Delaborator_withBindingDomain___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_5 = l_Lean_Delaborator_getExpr(x_2, x_3, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +lean_dec(x_5); +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +lean_dec(x_6); +x_9 = l_Lean_Expr_bindingDomain_x21(x_8); +lean_dec(x_8); +x_10 = lean_unsigned_to_nat(0u); +x_11 = l_Lean_Delaborator_descend___rarg(x_9, x_10, x_1, x_2, x_3, x_7); +return x_11; +} +} +lean_object* l_Lean_Delaborator_withBindingDomain(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Delaborator_withBindingDomain___rarg), 4, 0); +return x_2; +} +} +lean_object* l_Lean_Delaborator_withBindingBody___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_7 = l_Lean_Expr_bindingBody_x21(x_1); +x_8 = lean_expr_instantiate1(x_7, x_4); +lean_dec(x_7); +x_9 = lean_unsigned_to_nat(1u); +x_10 = l_Lean_Delaborator_descend___rarg(x_8, x_9, x_2, x_3, x_5, x_6); +return x_10; +} +} +lean_object* l_Lean_Delaborator_withBindingBody___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; +x_6 = l_Lean_Delaborator_getExpr(x_3, x_4, x_5); +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_7, 0); +lean_inc(x_9); +lean_dec(x_7); +x_10 = l_Lean_Expr_bindingDomain_x21(x_9); +x_11 = l_Lean_Expr_binderInfo(x_9); +x_12 = lean_alloc_closure((void*)(l_Lean_Delaborator_withBindingBody___rarg___lambda__1___boxed), 6, 3); +lean_closure_set(x_12, 0, x_9); +lean_closure_set(x_12, 1, x_2); +lean_closure_set(x_12, 2, x_3); +x_13 = l_Lean_Meta_withLocalDecl___rarg(x_1, x_10, x_11, x_12, x_4, x_8); +return x_13; +} +} +lean_object* l_Lean_Delaborator_withBindingBody(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Delaborator_withBindingBody___rarg), 5, 0); +return x_2; +} +} +lean_object* l_Lean_Delaborator_withBindingBody___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lean_Delaborator_withBindingBody___rarg___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +lean_dec(x_1); +return x_7; +} +} +lean_object* _init_l_Lean_Delaborator_infoForPos___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_String_Iterator_HasRepr___closed__2; +x_2 = lean_string_utf8_byte_size(x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_infoForPos___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_String_Iterator_HasRepr___closed__2; +x_2 = lean_unsigned_to_nat(0u); +x_3 = l_Lean_Delaborator_infoForPos___closed__1; +x_4 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +lean_object* l_Lean_Delaborator_infoForPos(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lean_Delaborator_infoForPos___closed__2; +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_2); +return x_3; +} +} +lean_object* l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_array_get_size(x_1); +x_4 = lean_nat_dec_lt(x_2, x_3); +lean_dec(x_3); +if (x_4 == 0) +{ +lean_object* x_5; +lean_dec(x_2); +x_5 = lean_box(0); +return x_5; +} +else +{ +lean_object* x_6; uint8_t x_7; +x_6 = lean_array_fget(x_1, x_2); +x_7 = l_Lean_Syntax_isAtom(x_6); +lean_dec(x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_unsigned_to_nat(1u); +x_9 = lean_nat_add(x_2, x_8); +lean_dec(x_2); +x_2 = x_9; +goto _start; +} +else +{ +lean_object* x_11; +x_11 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_11, 0, x_2); +return x_11; +} +} +} +} +lean_object* l_Lean_Delaborator_annotatePos___main(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +switch (lean_obj_tag(x_2)) { +case 1: +{ +lean_object* x_31; +x_31 = lean_ctor_get(x_2, 0); +lean_inc(x_31); +if (lean_obj_tag(x_31) == 1) +{ +lean_object* x_32; +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +if (lean_obj_tag(x_32) == 1) +{ +lean_object* x_33; +x_33 = lean_ctor_get(x_32, 0); +lean_inc(x_33); +if (lean_obj_tag(x_33) == 1) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 1) +{ +lean_object* x_35; +x_35 = lean_ctor_get(x_34, 0); +lean_inc(x_35); +if (lean_obj_tag(x_35) == 0) +{ +lean_object* x_36; uint8_t x_37; +x_36 = lean_ctor_get(x_2, 1); +lean_inc(x_36); +x_37 = !lean_is_exclusive(x_31); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_31, 1); +x_39 = lean_ctor_get(x_31, 0); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_32); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; uint8_t x_43; +x_41 = lean_ctor_get(x_32, 1); +x_42 = lean_ctor_get(x_32, 0); +lean_dec(x_42); +x_43 = !lean_is_exclusive(x_33); +if (x_43 == 0) +{ +lean_object* x_44; lean_object* x_45; uint8_t x_46; +x_44 = lean_ctor_get(x_33, 1); +x_45 = lean_ctor_get(x_33, 0); +lean_dec(x_45); +x_46 = !lean_is_exclusive(x_34); +if (x_46 == 0) +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_47 = lean_ctor_get(x_34, 1); +x_48 = lean_ctor_get(x_34, 0); +lean_dec(x_48); +x_49 = l_Lean_mkAppStx___closed__1; +x_50 = lean_string_dec_eq(x_47, x_49); +lean_dec(x_47); +if (x_50 == 0) +{ +lean_object* x_51; +lean_free_object(x_34); +lean_free_object(x_33); +lean_dec(x_44); +lean_free_object(x_32); +lean_dec(x_41); +lean_free_object(x_31); +lean_dec(x_38); +lean_dec(x_36); +x_51 = lean_box(0); +x_3 = x_51; +goto block_30; +} +else +{ +uint8_t x_52; +x_52 = !lean_is_exclusive(x_2); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_53 = lean_ctor_get(x_2, 1); +lean_dec(x_53); +x_54 = lean_ctor_get(x_2, 0); +lean_dec(x_54); +x_55 = l_Lean_mkAppStx___closed__3; +x_56 = lean_string_dec_eq(x_44, x_55); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; +lean_ctor_set(x_34, 1, x_49); +lean_inc(x_36); +lean_inc(x_31); +x_57 = l_Lean_Syntax_getArgs(x_2); +lean_dec(x_2); +x_58 = lean_unsigned_to_nat(0u); +x_59 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_57, x_58); +lean_dec(x_57); +if (lean_obj_tag(x_59) == 0) +{ +lean_object* x_60; +lean_dec(x_1); +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_31); +lean_ctor_set(x_60, 1, x_36); +return x_60; +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; +x_61 = lean_ctor_get(x_59, 0); +lean_inc(x_61); +lean_dec(x_59); +x_62 = l_Lean_Delaborator_infoForPos(x_1); +x_63 = lean_array_get_size(x_36); +x_64 = lean_nat_dec_lt(x_61, x_63); +lean_dec(x_63); +if (x_64 == 0) +{ +lean_object* x_65; +lean_dec(x_62); +lean_dec(x_61); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_31); +lean_ctor_set(x_65, 1, x_36); +return x_65; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_66 = lean_array_fget(x_36, x_61); +x_67 = lean_box(0); +x_68 = lean_array_fset(x_36, x_61, x_67); +x_69 = l_Lean_Syntax_setInfo(x_62, x_66); +x_70 = lean_array_fset(x_68, x_61, x_69); +lean_dec(x_61); +x_71 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_71, 0, x_31); +lean_ctor_set(x_71, 1, x_70); +return x_71; +} +} +} +else +{ +lean_object* x_72; uint8_t x_73; +lean_dec(x_44); +x_72 = l_Lean_mkAppStx___closed__5; +x_73 = lean_string_dec_eq(x_41, x_72); +if (x_73 == 0) +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_ctor_set(x_34, 1, x_49); +lean_ctor_set(x_33, 1, x_55); +lean_inc(x_36); +lean_inc(x_31); +x_74 = l_Lean_Syntax_getArgs(x_2); +lean_dec(x_2); +x_75 = lean_unsigned_to_nat(0u); +x_76 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_74, x_75); +lean_dec(x_74); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; +lean_dec(x_1); +x_77 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_77, 0, x_31); +lean_ctor_set(x_77, 1, x_36); +return x_77; +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; +x_78 = lean_ctor_get(x_76, 0); +lean_inc(x_78); +lean_dec(x_76); +x_79 = l_Lean_Delaborator_infoForPos(x_1); +x_80 = lean_array_get_size(x_36); +x_81 = lean_nat_dec_lt(x_78, x_80); +lean_dec(x_80); +if (x_81 == 0) +{ +lean_object* x_82; +lean_dec(x_79); +lean_dec(x_78); +x_82 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_82, 0, x_31); +lean_ctor_set(x_82, 1, x_36); +return x_82; +} +else +{ +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_array_fget(x_36, x_78); +x_84 = lean_box(0); +x_85 = lean_array_fset(x_36, x_78, x_84); +x_86 = l_Lean_Syntax_setInfo(x_79, x_83); +x_87 = lean_array_fset(x_85, x_78, x_86); +lean_dec(x_78); +x_88 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_88, 0, x_31); +lean_ctor_set(x_88, 1, x_87); +return x_88; +} +} +} +else +{ +lean_object* x_89; uint8_t x_90; +lean_dec(x_41); +x_89 = l_Lean_mkTermIdFromIdent___closed__1; +x_90 = lean_string_dec_eq(x_38, x_89); +if (x_90 == 0) +{ +lean_object* x_91; uint8_t x_92; +x_91 = l_Lean_mkAppStx___closed__7; +x_92 = lean_string_dec_eq(x_38, x_91); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_ctor_set(x_34, 1, x_49); +lean_ctor_set(x_33, 1, x_55); +lean_ctor_set(x_32, 1, x_72); +lean_inc(x_36); +lean_inc(x_31); +x_93 = l_Lean_Syntax_getArgs(x_2); +lean_dec(x_2); +x_94 = lean_unsigned_to_nat(0u); +x_95 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_93, x_94); +lean_dec(x_93); +if (lean_obj_tag(x_95) == 0) +{ +lean_object* x_96; +lean_dec(x_1); +x_96 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_96, 0, x_31); +lean_ctor_set(x_96, 1, x_36); +return x_96; +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; uint8_t x_100; +x_97 = lean_ctor_get(x_95, 0); +lean_inc(x_97); +lean_dec(x_95); +x_98 = l_Lean_Delaborator_infoForPos(x_1); +x_99 = lean_array_get_size(x_36); +x_100 = lean_nat_dec_lt(x_97, x_99); +lean_dec(x_99); +if (x_100 == 0) +{ +lean_object* x_101; +lean_dec(x_98); +lean_dec(x_97); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_31); +lean_ctor_set(x_101, 1, x_36); +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 = lean_array_fget(x_36, x_97); +x_103 = lean_box(0); +x_104 = lean_array_fset(x_36, x_97, x_103); +x_105 = l_Lean_Syntax_setInfo(x_98, x_102); +x_106 = lean_array_fset(x_104, x_97, x_105); +lean_dec(x_97); +x_107 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_107, 0, x_31); +lean_ctor_set(x_107, 1, x_106); +return x_107; +} +} +} +else +{ +lean_object* x_108; lean_object* x_109; uint8_t x_110; +lean_dec(x_38); +lean_ctor_set(x_34, 1, x_49); +lean_ctor_set(x_33, 1, x_55); +lean_ctor_set(x_32, 1, x_72); +lean_ctor_set(x_31, 1, x_91); +x_108 = lean_array_get_size(x_36); +x_109 = lean_unsigned_to_nat(0u); +x_110 = lean_nat_dec_lt(x_109, x_108); +lean_dec(x_108); +if (x_110 == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_111 = lean_array_fget(x_36, x_109); +x_112 = lean_box(0); +x_113 = lean_array_fset(x_36, x_109, x_112); +x_114 = l_Lean_Delaborator_annotatePos___main(x_1, x_111); +x_115 = lean_array_fset(x_113, x_109, x_114); +lean_ctor_set(x_2, 1, x_115); +return x_2; +} +} +} +else +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +lean_dec(x_38); +lean_ctor_set(x_34, 1, x_49); +lean_ctor_set(x_33, 1, x_55); +lean_ctor_set(x_32, 1, x_72); +lean_ctor_set(x_31, 1, x_89); +x_116 = lean_array_get_size(x_36); +x_117 = lean_unsigned_to_nat(0u); +x_118 = lean_nat_dec_lt(x_117, x_116); +lean_dec(x_116); +if (x_118 == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_119 = lean_array_fget(x_36, x_117); +x_120 = lean_box(0); +x_121 = lean_array_fset(x_36, x_117, x_120); +x_122 = l_Lean_Delaborator_annotatePos___main(x_1, x_119); +x_123 = lean_array_fset(x_121, x_117, x_122); +lean_ctor_set(x_2, 1, x_123); +return x_2; +} +} +} +} +} +else +{ +lean_object* x_124; uint8_t x_125; +lean_dec(x_2); +x_124 = l_Lean_mkAppStx___closed__3; +x_125 = lean_string_dec_eq(x_44, x_124); +if (x_125 == 0) +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; +lean_ctor_set(x_34, 1, x_49); +lean_inc(x_36); +lean_inc(x_31); +x_126 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_126, 0, x_31); +lean_ctor_set(x_126, 1, x_36); +x_127 = l_Lean_Syntax_getArgs(x_126); +lean_dec(x_126); +x_128 = lean_unsigned_to_nat(0u); +x_129 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_127, x_128); +lean_dec(x_127); +if (lean_obj_tag(x_129) == 0) +{ +lean_object* x_130; +lean_dec(x_1); +x_130 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_130, 0, x_31); +lean_ctor_set(x_130, 1, x_36); +return x_130; +} +else +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_134; +x_131 = lean_ctor_get(x_129, 0); +lean_inc(x_131); +lean_dec(x_129); +x_132 = l_Lean_Delaborator_infoForPos(x_1); +x_133 = lean_array_get_size(x_36); +x_134 = lean_nat_dec_lt(x_131, x_133); +lean_dec(x_133); +if (x_134 == 0) +{ +lean_object* x_135; +lean_dec(x_132); +lean_dec(x_131); +x_135 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_135, 0, x_31); +lean_ctor_set(x_135, 1, x_36); +return x_135; +} +else +{ +lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +x_136 = lean_array_fget(x_36, x_131); +x_137 = lean_box(0); +x_138 = lean_array_fset(x_36, x_131, x_137); +x_139 = l_Lean_Syntax_setInfo(x_132, x_136); +x_140 = lean_array_fset(x_138, x_131, x_139); +lean_dec(x_131); +x_141 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_141, 0, x_31); +lean_ctor_set(x_141, 1, x_140); +return x_141; +} +} +} +else +{ +lean_object* x_142; uint8_t x_143; +lean_dec(x_44); +x_142 = l_Lean_mkAppStx___closed__5; +x_143 = lean_string_dec_eq(x_41, x_142); +if (x_143 == 0) +{ +lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; +lean_ctor_set(x_34, 1, x_49); +lean_ctor_set(x_33, 1, x_124); +lean_inc(x_36); +lean_inc(x_31); +x_144 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_144, 0, x_31); +lean_ctor_set(x_144, 1, x_36); +x_145 = l_Lean_Syntax_getArgs(x_144); +lean_dec(x_144); +x_146 = lean_unsigned_to_nat(0u); +x_147 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_145, x_146); +lean_dec(x_145); +if (lean_obj_tag(x_147) == 0) +{ +lean_object* x_148; +lean_dec(x_1); +x_148 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_148, 0, x_31); +lean_ctor_set(x_148, 1, x_36); +return x_148; +} +else +{ +lean_object* x_149; lean_object* x_150; lean_object* x_151; uint8_t x_152; +x_149 = lean_ctor_get(x_147, 0); +lean_inc(x_149); +lean_dec(x_147); +x_150 = l_Lean_Delaborator_infoForPos(x_1); +x_151 = lean_array_get_size(x_36); +x_152 = lean_nat_dec_lt(x_149, x_151); +lean_dec(x_151); +if (x_152 == 0) +{ +lean_object* x_153; +lean_dec(x_150); +lean_dec(x_149); +x_153 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_153, 0, x_31); +lean_ctor_set(x_153, 1, x_36); +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_object* x_159; +x_154 = lean_array_fget(x_36, x_149); +x_155 = lean_box(0); +x_156 = lean_array_fset(x_36, x_149, x_155); +x_157 = l_Lean_Syntax_setInfo(x_150, x_154); +x_158 = lean_array_fset(x_156, x_149, x_157); +lean_dec(x_149); +x_159 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_159, 0, x_31); +lean_ctor_set(x_159, 1, x_158); +return x_159; +} +} +} +else +{ +lean_object* x_160; uint8_t x_161; +lean_dec(x_41); +x_160 = l_Lean_mkTermIdFromIdent___closed__1; +x_161 = lean_string_dec_eq(x_38, x_160); +if (x_161 == 0) +{ +lean_object* x_162; uint8_t x_163; +x_162 = l_Lean_mkAppStx___closed__7; +x_163 = lean_string_dec_eq(x_38, x_162); +if (x_163 == 0) +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_ctor_set(x_34, 1, x_49); +lean_ctor_set(x_33, 1, x_124); +lean_ctor_set(x_32, 1, x_142); +lean_inc(x_36); +lean_inc(x_31); +x_164 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_164, 0, x_31); +lean_ctor_set(x_164, 1, x_36); +x_165 = l_Lean_Syntax_getArgs(x_164); +lean_dec(x_164); +x_166 = lean_unsigned_to_nat(0u); +x_167 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_165, x_166); +lean_dec(x_165); +if (lean_obj_tag(x_167) == 0) +{ +lean_object* x_168; +lean_dec(x_1); +x_168 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_168, 0, x_31); +lean_ctor_set(x_168, 1, x_36); +return x_168; +} +else +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; +x_169 = lean_ctor_get(x_167, 0); +lean_inc(x_169); +lean_dec(x_167); +x_170 = l_Lean_Delaborator_infoForPos(x_1); +x_171 = lean_array_get_size(x_36); +x_172 = lean_nat_dec_lt(x_169, x_171); +lean_dec(x_171); +if (x_172 == 0) +{ +lean_object* x_173; +lean_dec(x_170); +lean_dec(x_169); +x_173 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_173, 0, x_31); +lean_ctor_set(x_173, 1, x_36); +return x_173; +} +else +{ +lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; +x_174 = lean_array_fget(x_36, x_169); +x_175 = lean_box(0); +x_176 = lean_array_fset(x_36, x_169, x_175); +x_177 = l_Lean_Syntax_setInfo(x_170, x_174); +x_178 = lean_array_fset(x_176, x_169, x_177); +lean_dec(x_169); +x_179 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_179, 0, x_31); +lean_ctor_set(x_179, 1, x_178); +return x_179; +} +} +} +else +{ +lean_object* x_180; lean_object* x_181; uint8_t x_182; +lean_dec(x_38); +lean_ctor_set(x_34, 1, x_49); +lean_ctor_set(x_33, 1, x_124); +lean_ctor_set(x_32, 1, x_142); +lean_ctor_set(x_31, 1, x_162); +x_180 = lean_array_get_size(x_36); +x_181 = lean_unsigned_to_nat(0u); +x_182 = lean_nat_dec_lt(x_181, x_180); +lean_dec(x_180); +if (x_182 == 0) +{ +lean_object* x_183; +lean_dec(x_1); +x_183 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_183, 0, x_31); +lean_ctor_set(x_183, 1, x_36); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; +x_184 = lean_array_fget(x_36, x_181); +x_185 = lean_box(0); +x_186 = lean_array_fset(x_36, x_181, x_185); +x_187 = l_Lean_Delaborator_annotatePos___main(x_1, x_184); +x_188 = lean_array_fset(x_186, x_181, x_187); +x_189 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_189, 0, x_31); +lean_ctor_set(x_189, 1, x_188); +return x_189; +} +} +} +else +{ +lean_object* x_190; lean_object* x_191; uint8_t x_192; +lean_dec(x_38); +lean_ctor_set(x_34, 1, x_49); +lean_ctor_set(x_33, 1, x_124); +lean_ctor_set(x_32, 1, x_142); +lean_ctor_set(x_31, 1, x_160); +x_190 = lean_array_get_size(x_36); +x_191 = lean_unsigned_to_nat(0u); +x_192 = lean_nat_dec_lt(x_191, x_190); +lean_dec(x_190); +if (x_192 == 0) +{ +lean_object* x_193; +lean_dec(x_1); +x_193 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_193, 0, x_31); +lean_ctor_set(x_193, 1, x_36); +return x_193; +} +else +{ +lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; +x_194 = lean_array_fget(x_36, x_191); +x_195 = lean_box(0); +x_196 = lean_array_fset(x_36, x_191, x_195); +x_197 = l_Lean_Delaborator_annotatePos___main(x_1, x_194); +x_198 = lean_array_fset(x_196, x_191, x_197); +x_199 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_199, 0, x_31); +lean_ctor_set(x_199, 1, x_198); +return x_199; +} +} +} +} +} +} +} +else +{ +lean_object* x_200; size_t x_201; lean_object* x_202; uint8_t x_203; +x_200 = lean_ctor_get(x_34, 1); +x_201 = lean_ctor_get_usize(x_34, 2); +lean_inc(x_200); +lean_dec(x_34); +x_202 = l_Lean_mkAppStx___closed__1; +x_203 = lean_string_dec_eq(x_200, x_202); +lean_dec(x_200); +if (x_203 == 0) +{ +lean_object* x_204; +lean_free_object(x_33); +lean_dec(x_44); +lean_free_object(x_32); +lean_dec(x_41); +lean_free_object(x_31); +lean_dec(x_38); +lean_dec(x_36); +x_204 = lean_box(0); +x_3 = x_204; +goto block_30; +} +else +{ +lean_object* x_205; lean_object* x_206; uint8_t x_207; +if (lean_is_exclusive(x_2)) { + lean_ctor_release(x_2, 0); + lean_ctor_release(x_2, 1); + x_205 = x_2; +} else { + lean_dec_ref(x_2); + x_205 = lean_box(0); +} +x_206 = l_Lean_mkAppStx___closed__3; +x_207 = lean_string_dec_eq(x_44, x_206); +if (x_207 == 0) +{ +lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; +x_208 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_208, 0, x_35); +lean_ctor_set(x_208, 1, x_202); +lean_ctor_set_usize(x_208, 2, x_201); +lean_ctor_set(x_33, 0, x_208); +lean_inc(x_36); +lean_inc(x_31); +if (lean_is_scalar(x_205)) { + x_209 = lean_alloc_ctor(1, 2, 0); +} else { + x_209 = x_205; +} +lean_ctor_set(x_209, 0, x_31); +lean_ctor_set(x_209, 1, x_36); +x_210 = l_Lean_Syntax_getArgs(x_209); +lean_dec(x_209); +x_211 = lean_unsigned_to_nat(0u); +x_212 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_210, x_211); +lean_dec(x_210); +if (lean_obj_tag(x_212) == 0) +{ +lean_object* x_213; +lean_dec(x_1); +x_213 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_213, 0, x_31); +lean_ctor_set(x_213, 1, x_36); +return x_213; +} +else +{ +lean_object* x_214; lean_object* x_215; lean_object* x_216; uint8_t x_217; +x_214 = lean_ctor_get(x_212, 0); +lean_inc(x_214); +lean_dec(x_212); +x_215 = l_Lean_Delaborator_infoForPos(x_1); +x_216 = lean_array_get_size(x_36); +x_217 = lean_nat_dec_lt(x_214, x_216); +lean_dec(x_216); +if (x_217 == 0) +{ +lean_object* x_218; +lean_dec(x_215); +lean_dec(x_214); +x_218 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_218, 0, x_31); +lean_ctor_set(x_218, 1, x_36); +return x_218; +} +else +{ +lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; +x_219 = lean_array_fget(x_36, x_214); +x_220 = lean_box(0); +x_221 = lean_array_fset(x_36, x_214, x_220); +x_222 = l_Lean_Syntax_setInfo(x_215, x_219); +x_223 = lean_array_fset(x_221, x_214, x_222); +lean_dec(x_214); +x_224 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_224, 0, x_31); +lean_ctor_set(x_224, 1, x_223); +return x_224; +} +} +} +else +{ +lean_object* x_225; uint8_t x_226; +lean_dec(x_44); +x_225 = l_Lean_mkAppStx___closed__5; +x_226 = lean_string_dec_eq(x_41, x_225); +if (x_226 == 0) +{ +lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; +x_227 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_227, 0, x_35); +lean_ctor_set(x_227, 1, x_202); +lean_ctor_set_usize(x_227, 2, x_201); +lean_ctor_set(x_33, 1, x_206); +lean_ctor_set(x_33, 0, x_227); +lean_inc(x_36); +lean_inc(x_31); +if (lean_is_scalar(x_205)) { + x_228 = lean_alloc_ctor(1, 2, 0); +} else { + x_228 = x_205; +} +lean_ctor_set(x_228, 0, x_31); +lean_ctor_set(x_228, 1, x_36); +x_229 = l_Lean_Syntax_getArgs(x_228); +lean_dec(x_228); +x_230 = lean_unsigned_to_nat(0u); +x_231 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_229, x_230); +lean_dec(x_229); +if (lean_obj_tag(x_231) == 0) +{ +lean_object* x_232; +lean_dec(x_1); +x_232 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_232, 0, x_31); +lean_ctor_set(x_232, 1, x_36); +return x_232; +} +else +{ +lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; +x_233 = lean_ctor_get(x_231, 0); +lean_inc(x_233); +lean_dec(x_231); +x_234 = l_Lean_Delaborator_infoForPos(x_1); +x_235 = lean_array_get_size(x_36); +x_236 = lean_nat_dec_lt(x_233, x_235); +lean_dec(x_235); +if (x_236 == 0) +{ +lean_object* x_237; +lean_dec(x_234); +lean_dec(x_233); +x_237 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_237, 0, x_31); +lean_ctor_set(x_237, 1, x_36); +return x_237; +} +else +{ +lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; +x_238 = lean_array_fget(x_36, x_233); +x_239 = lean_box(0); +x_240 = lean_array_fset(x_36, x_233, x_239); +x_241 = l_Lean_Syntax_setInfo(x_234, x_238); +x_242 = lean_array_fset(x_240, x_233, x_241); +lean_dec(x_233); +x_243 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_243, 0, x_31); +lean_ctor_set(x_243, 1, x_242); +return x_243; +} +} +} +else +{ +lean_object* x_244; uint8_t x_245; +lean_dec(x_41); +x_244 = l_Lean_mkTermIdFromIdent___closed__1; +x_245 = lean_string_dec_eq(x_38, x_244); +if (x_245 == 0) +{ +lean_object* x_246; uint8_t x_247; +x_246 = l_Lean_mkAppStx___closed__7; +x_247 = lean_string_dec_eq(x_38, x_246); +if (x_247 == 0) +{ +lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; +x_248 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_248, 0, x_35); +lean_ctor_set(x_248, 1, x_202); +lean_ctor_set_usize(x_248, 2, x_201); +lean_ctor_set(x_33, 1, x_206); +lean_ctor_set(x_33, 0, x_248); +lean_ctor_set(x_32, 1, x_225); +lean_inc(x_36); +lean_inc(x_31); +if (lean_is_scalar(x_205)) { + x_249 = lean_alloc_ctor(1, 2, 0); +} else { + x_249 = x_205; +} +lean_ctor_set(x_249, 0, x_31); +lean_ctor_set(x_249, 1, x_36); +x_250 = l_Lean_Syntax_getArgs(x_249); +lean_dec(x_249); +x_251 = lean_unsigned_to_nat(0u); +x_252 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_250, x_251); +lean_dec(x_250); +if (lean_obj_tag(x_252) == 0) +{ +lean_object* x_253; +lean_dec(x_1); +x_253 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_253, 0, x_31); +lean_ctor_set(x_253, 1, x_36); +return x_253; +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; uint8_t x_257; +x_254 = lean_ctor_get(x_252, 0); +lean_inc(x_254); +lean_dec(x_252); +x_255 = l_Lean_Delaborator_infoForPos(x_1); +x_256 = lean_array_get_size(x_36); +x_257 = lean_nat_dec_lt(x_254, x_256); +lean_dec(x_256); +if (x_257 == 0) +{ +lean_object* x_258; +lean_dec(x_255); +lean_dec(x_254); +x_258 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_258, 0, x_31); +lean_ctor_set(x_258, 1, x_36); +return x_258; +} +else +{ +lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +x_259 = lean_array_fget(x_36, x_254); +x_260 = lean_box(0); +x_261 = lean_array_fset(x_36, x_254, x_260); +x_262 = l_Lean_Syntax_setInfo(x_255, x_259); +x_263 = lean_array_fset(x_261, x_254, x_262); +lean_dec(x_254); +x_264 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_264, 0, x_31); +lean_ctor_set(x_264, 1, x_263); +return x_264; +} +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; uint8_t x_268; +lean_dec(x_38); +x_265 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_265, 0, x_35); +lean_ctor_set(x_265, 1, x_202); +lean_ctor_set_usize(x_265, 2, x_201); +lean_ctor_set(x_33, 1, x_206); +lean_ctor_set(x_33, 0, x_265); +lean_ctor_set(x_32, 1, x_225); +lean_ctor_set(x_31, 1, x_246); +x_266 = lean_array_get_size(x_36); +x_267 = lean_unsigned_to_nat(0u); +x_268 = lean_nat_dec_lt(x_267, x_266); +lean_dec(x_266); +if (x_268 == 0) +{ +lean_object* x_269; +lean_dec(x_1); +if (lean_is_scalar(x_205)) { + x_269 = lean_alloc_ctor(1, 2, 0); +} else { + x_269 = x_205; +} +lean_ctor_set(x_269, 0, x_31); +lean_ctor_set(x_269, 1, x_36); +return x_269; +} +else +{ +lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; +x_270 = lean_array_fget(x_36, x_267); +x_271 = lean_box(0); +x_272 = lean_array_fset(x_36, x_267, x_271); +x_273 = l_Lean_Delaborator_annotatePos___main(x_1, x_270); +x_274 = lean_array_fset(x_272, x_267, x_273); +if (lean_is_scalar(x_205)) { + x_275 = lean_alloc_ctor(1, 2, 0); +} else { + x_275 = x_205; +} +lean_ctor_set(x_275, 0, x_31); +lean_ctor_set(x_275, 1, x_274); +return x_275; +} +} +} +else +{ +lean_object* x_276; lean_object* x_277; lean_object* x_278; uint8_t x_279; +lean_dec(x_38); +x_276 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_276, 0, x_35); +lean_ctor_set(x_276, 1, x_202); +lean_ctor_set_usize(x_276, 2, x_201); +lean_ctor_set(x_33, 1, x_206); +lean_ctor_set(x_33, 0, x_276); +lean_ctor_set(x_32, 1, x_225); +lean_ctor_set(x_31, 1, x_244); +x_277 = lean_array_get_size(x_36); +x_278 = lean_unsigned_to_nat(0u); +x_279 = lean_nat_dec_lt(x_278, x_277); +lean_dec(x_277); +if (x_279 == 0) +{ +lean_object* x_280; +lean_dec(x_1); +if (lean_is_scalar(x_205)) { + x_280 = lean_alloc_ctor(1, 2, 0); +} else { + x_280 = x_205; +} +lean_ctor_set(x_280, 0, x_31); +lean_ctor_set(x_280, 1, x_36); +return x_280; +} +else +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; +x_281 = lean_array_fget(x_36, x_278); +x_282 = lean_box(0); +x_283 = lean_array_fset(x_36, x_278, x_282); +x_284 = l_Lean_Delaborator_annotatePos___main(x_1, x_281); +x_285 = lean_array_fset(x_283, x_278, x_284); +if (lean_is_scalar(x_205)) { + x_286 = lean_alloc_ctor(1, 2, 0); +} else { + x_286 = x_205; +} +lean_ctor_set(x_286, 0, x_31); +lean_ctor_set(x_286, 1, x_285); +return x_286; +} +} +} +} +} +} +} +else +{ +lean_object* x_287; size_t x_288; lean_object* x_289; size_t x_290; lean_object* x_291; lean_object* x_292; uint8_t x_293; +x_287 = lean_ctor_get(x_33, 1); +x_288 = lean_ctor_get_usize(x_33, 2); +lean_inc(x_287); +lean_dec(x_33); +x_289 = lean_ctor_get(x_34, 1); +lean_inc(x_289); +x_290 = lean_ctor_get_usize(x_34, 2); +if (lean_is_exclusive(x_34)) { + lean_ctor_release(x_34, 0); + lean_ctor_release(x_34, 1); + x_291 = x_34; +} else { + lean_dec_ref(x_34); + x_291 = lean_box(0); +} +x_292 = l_Lean_mkAppStx___closed__1; +x_293 = lean_string_dec_eq(x_289, x_292); +lean_dec(x_289); +if (x_293 == 0) +{ +lean_object* x_294; +lean_dec(x_291); +lean_dec(x_287); +lean_free_object(x_32); +lean_dec(x_41); +lean_free_object(x_31); +lean_dec(x_38); +lean_dec(x_36); +x_294 = lean_box(0); +x_3 = x_294; +goto block_30; +} +else +{ +lean_object* x_295; lean_object* x_296; uint8_t x_297; +if (lean_is_exclusive(x_2)) { + lean_ctor_release(x_2, 0); + lean_ctor_release(x_2, 1); + x_295 = x_2; +} else { + lean_dec_ref(x_2); + x_295 = lean_box(0); +} +x_296 = l_Lean_mkAppStx___closed__3; +x_297 = lean_string_dec_eq(x_287, x_296); +if (x_297 == 0) +{ +lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; +if (lean_is_scalar(x_291)) { + x_298 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_298 = x_291; +} +lean_ctor_set(x_298, 0, x_35); +lean_ctor_set(x_298, 1, x_292); +lean_ctor_set_usize(x_298, 2, x_290); +x_299 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_299, 0, x_298); +lean_ctor_set(x_299, 1, x_287); +lean_ctor_set_usize(x_299, 2, x_288); +lean_ctor_set(x_32, 0, x_299); +lean_inc(x_36); +lean_inc(x_31); +if (lean_is_scalar(x_295)) { + x_300 = lean_alloc_ctor(1, 2, 0); +} else { + x_300 = x_295; +} +lean_ctor_set(x_300, 0, x_31); +lean_ctor_set(x_300, 1, x_36); +x_301 = l_Lean_Syntax_getArgs(x_300); +lean_dec(x_300); +x_302 = lean_unsigned_to_nat(0u); +x_303 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_301, x_302); +lean_dec(x_301); +if (lean_obj_tag(x_303) == 0) +{ +lean_object* x_304; +lean_dec(x_1); +x_304 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_304, 0, x_31); +lean_ctor_set(x_304, 1, x_36); +return x_304; +} +else +{ +lean_object* x_305; lean_object* x_306; lean_object* x_307; uint8_t x_308; +x_305 = lean_ctor_get(x_303, 0); +lean_inc(x_305); +lean_dec(x_303); +x_306 = l_Lean_Delaborator_infoForPos(x_1); +x_307 = lean_array_get_size(x_36); +x_308 = lean_nat_dec_lt(x_305, x_307); +lean_dec(x_307); +if (x_308 == 0) +{ +lean_object* x_309; +lean_dec(x_306); +lean_dec(x_305); +x_309 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_309, 0, x_31); +lean_ctor_set(x_309, 1, x_36); +return x_309; +} +else +{ +lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; +x_310 = lean_array_fget(x_36, x_305); +x_311 = lean_box(0); +x_312 = lean_array_fset(x_36, x_305, x_311); +x_313 = l_Lean_Syntax_setInfo(x_306, x_310); +x_314 = lean_array_fset(x_312, x_305, x_313); +lean_dec(x_305); +x_315 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_315, 0, x_31); +lean_ctor_set(x_315, 1, x_314); +return x_315; +} +} +} +else +{ +lean_object* x_316; uint8_t x_317; +lean_dec(x_287); +x_316 = l_Lean_mkAppStx___closed__5; +x_317 = lean_string_dec_eq(x_41, x_316); +if (x_317 == 0) +{ +lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; +if (lean_is_scalar(x_291)) { + x_318 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_318 = x_291; +} +lean_ctor_set(x_318, 0, x_35); +lean_ctor_set(x_318, 1, x_292); +lean_ctor_set_usize(x_318, 2, x_290); +x_319 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_319, 0, x_318); +lean_ctor_set(x_319, 1, x_296); +lean_ctor_set_usize(x_319, 2, x_288); +lean_ctor_set(x_32, 0, x_319); +lean_inc(x_36); +lean_inc(x_31); +if (lean_is_scalar(x_295)) { + x_320 = lean_alloc_ctor(1, 2, 0); +} else { + x_320 = x_295; +} +lean_ctor_set(x_320, 0, x_31); +lean_ctor_set(x_320, 1, x_36); +x_321 = l_Lean_Syntax_getArgs(x_320); +lean_dec(x_320); +x_322 = lean_unsigned_to_nat(0u); +x_323 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_321, x_322); +lean_dec(x_321); +if (lean_obj_tag(x_323) == 0) +{ +lean_object* x_324; +lean_dec(x_1); +x_324 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_324, 0, x_31); +lean_ctor_set(x_324, 1, x_36); +return x_324; +} +else +{ +lean_object* x_325; lean_object* x_326; lean_object* x_327; uint8_t x_328; +x_325 = lean_ctor_get(x_323, 0); +lean_inc(x_325); +lean_dec(x_323); +x_326 = l_Lean_Delaborator_infoForPos(x_1); +x_327 = lean_array_get_size(x_36); +x_328 = lean_nat_dec_lt(x_325, x_327); +lean_dec(x_327); +if (x_328 == 0) +{ +lean_object* x_329; +lean_dec(x_326); +lean_dec(x_325); +x_329 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_329, 0, x_31); +lean_ctor_set(x_329, 1, x_36); +return x_329; +} +else +{ +lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; +x_330 = lean_array_fget(x_36, x_325); +x_331 = lean_box(0); +x_332 = lean_array_fset(x_36, x_325, x_331); +x_333 = l_Lean_Syntax_setInfo(x_326, x_330); +x_334 = lean_array_fset(x_332, x_325, x_333); +lean_dec(x_325); +x_335 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_335, 0, x_31); +lean_ctor_set(x_335, 1, x_334); +return x_335; +} +} +} +else +{ +lean_object* x_336; uint8_t x_337; +lean_dec(x_41); +x_336 = l_Lean_mkTermIdFromIdent___closed__1; +x_337 = lean_string_dec_eq(x_38, x_336); +if (x_337 == 0) +{ +lean_object* x_338; uint8_t x_339; +x_338 = l_Lean_mkAppStx___closed__7; +x_339 = lean_string_dec_eq(x_38, x_338); +if (x_339 == 0) +{ +lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; +if (lean_is_scalar(x_291)) { + x_340 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_340 = x_291; +} +lean_ctor_set(x_340, 0, x_35); +lean_ctor_set(x_340, 1, x_292); +lean_ctor_set_usize(x_340, 2, x_290); +x_341 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_341, 0, x_340); +lean_ctor_set(x_341, 1, x_296); +lean_ctor_set_usize(x_341, 2, x_288); +lean_ctor_set(x_32, 1, x_316); +lean_ctor_set(x_32, 0, x_341); +lean_inc(x_36); +lean_inc(x_31); +if (lean_is_scalar(x_295)) { + x_342 = lean_alloc_ctor(1, 2, 0); +} else { + x_342 = x_295; +} +lean_ctor_set(x_342, 0, x_31); +lean_ctor_set(x_342, 1, x_36); +x_343 = l_Lean_Syntax_getArgs(x_342); +lean_dec(x_342); +x_344 = lean_unsigned_to_nat(0u); +x_345 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_343, x_344); +lean_dec(x_343); +if (lean_obj_tag(x_345) == 0) +{ +lean_object* x_346; +lean_dec(x_1); +x_346 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_346, 0, x_31); +lean_ctor_set(x_346, 1, x_36); +return x_346; +} +else +{ +lean_object* x_347; lean_object* x_348; lean_object* x_349; uint8_t x_350; +x_347 = lean_ctor_get(x_345, 0); +lean_inc(x_347); +lean_dec(x_345); +x_348 = l_Lean_Delaborator_infoForPos(x_1); +x_349 = lean_array_get_size(x_36); +x_350 = lean_nat_dec_lt(x_347, x_349); +lean_dec(x_349); +if (x_350 == 0) +{ +lean_object* x_351; +lean_dec(x_348); +lean_dec(x_347); +x_351 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_351, 0, x_31); +lean_ctor_set(x_351, 1, x_36); +return x_351; +} +else +{ +lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; +x_352 = lean_array_fget(x_36, x_347); +x_353 = lean_box(0); +x_354 = lean_array_fset(x_36, x_347, x_353); +x_355 = l_Lean_Syntax_setInfo(x_348, x_352); +x_356 = lean_array_fset(x_354, x_347, x_355); +lean_dec(x_347); +x_357 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_357, 0, x_31); +lean_ctor_set(x_357, 1, x_356); +return x_357; +} +} +} +else +{ +lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; +lean_dec(x_38); +if (lean_is_scalar(x_291)) { + x_358 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_358 = x_291; +} +lean_ctor_set(x_358, 0, x_35); +lean_ctor_set(x_358, 1, x_292); +lean_ctor_set_usize(x_358, 2, x_290); +x_359 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_359, 0, x_358); +lean_ctor_set(x_359, 1, x_296); +lean_ctor_set_usize(x_359, 2, x_288); +lean_ctor_set(x_32, 1, x_316); +lean_ctor_set(x_32, 0, x_359); +lean_ctor_set(x_31, 1, x_338); +x_360 = lean_array_get_size(x_36); +x_361 = lean_unsigned_to_nat(0u); +x_362 = lean_nat_dec_lt(x_361, x_360); +lean_dec(x_360); +if (x_362 == 0) +{ +lean_object* x_363; +lean_dec(x_1); +if (lean_is_scalar(x_295)) { + x_363 = lean_alloc_ctor(1, 2, 0); +} else { + x_363 = x_295; +} +lean_ctor_set(x_363, 0, x_31); +lean_ctor_set(x_363, 1, x_36); +return x_363; +} +else +{ +lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; +x_364 = lean_array_fget(x_36, x_361); +x_365 = lean_box(0); +x_366 = lean_array_fset(x_36, x_361, x_365); +x_367 = l_Lean_Delaborator_annotatePos___main(x_1, x_364); +x_368 = lean_array_fset(x_366, x_361, x_367); +if (lean_is_scalar(x_295)) { + x_369 = lean_alloc_ctor(1, 2, 0); +} else { + x_369 = x_295; +} +lean_ctor_set(x_369, 0, x_31); +lean_ctor_set(x_369, 1, x_368); +return x_369; +} +} +} +else +{ +lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; uint8_t x_374; +lean_dec(x_38); +if (lean_is_scalar(x_291)) { + x_370 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_370 = x_291; +} +lean_ctor_set(x_370, 0, x_35); +lean_ctor_set(x_370, 1, x_292); +lean_ctor_set_usize(x_370, 2, x_290); +x_371 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_371, 0, x_370); +lean_ctor_set(x_371, 1, x_296); +lean_ctor_set_usize(x_371, 2, x_288); +lean_ctor_set(x_32, 1, x_316); +lean_ctor_set(x_32, 0, x_371); +lean_ctor_set(x_31, 1, x_336); +x_372 = lean_array_get_size(x_36); +x_373 = lean_unsigned_to_nat(0u); +x_374 = lean_nat_dec_lt(x_373, x_372); +lean_dec(x_372); +if (x_374 == 0) +{ +lean_object* x_375; +lean_dec(x_1); +if (lean_is_scalar(x_295)) { + x_375 = lean_alloc_ctor(1, 2, 0); +} else { + x_375 = x_295; +} +lean_ctor_set(x_375, 0, x_31); +lean_ctor_set(x_375, 1, x_36); +return x_375; +} +else +{ +lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; +x_376 = lean_array_fget(x_36, x_373); +x_377 = lean_box(0); +x_378 = lean_array_fset(x_36, x_373, x_377); +x_379 = l_Lean_Delaborator_annotatePos___main(x_1, x_376); +x_380 = lean_array_fset(x_378, x_373, x_379); +if (lean_is_scalar(x_295)) { + x_381 = lean_alloc_ctor(1, 2, 0); +} else { + x_381 = x_295; +} +lean_ctor_set(x_381, 0, x_31); +lean_ctor_set(x_381, 1, x_380); +return x_381; +} +} +} +} +} +} +} +else +{ +lean_object* x_382; size_t x_383; lean_object* x_384; size_t x_385; lean_object* x_386; lean_object* x_387; size_t x_388; lean_object* x_389; lean_object* x_390; uint8_t x_391; +x_382 = lean_ctor_get(x_32, 1); +x_383 = lean_ctor_get_usize(x_32, 2); +lean_inc(x_382); +lean_dec(x_32); +x_384 = lean_ctor_get(x_33, 1); +lean_inc(x_384); +x_385 = lean_ctor_get_usize(x_33, 2); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_386 = x_33; +} else { + lean_dec_ref(x_33); + x_386 = lean_box(0); +} +x_387 = lean_ctor_get(x_34, 1); +lean_inc(x_387); +x_388 = lean_ctor_get_usize(x_34, 2); +if (lean_is_exclusive(x_34)) { + lean_ctor_release(x_34, 0); + lean_ctor_release(x_34, 1); + x_389 = x_34; +} else { + lean_dec_ref(x_34); + x_389 = lean_box(0); +} +x_390 = l_Lean_mkAppStx___closed__1; +x_391 = lean_string_dec_eq(x_387, x_390); +lean_dec(x_387); +if (x_391 == 0) +{ +lean_object* x_392; +lean_dec(x_389); +lean_dec(x_386); +lean_dec(x_384); +lean_dec(x_382); +lean_free_object(x_31); +lean_dec(x_38); +lean_dec(x_36); +x_392 = lean_box(0); +x_3 = x_392; +goto block_30; +} +else +{ +lean_object* x_393; lean_object* x_394; uint8_t x_395; +if (lean_is_exclusive(x_2)) { + lean_ctor_release(x_2, 0); + lean_ctor_release(x_2, 1); + x_393 = x_2; +} else { + lean_dec_ref(x_2); + x_393 = lean_box(0); +} +x_394 = l_Lean_mkAppStx___closed__3; +x_395 = lean_string_dec_eq(x_384, x_394); +if (x_395 == 0) +{ +lean_object* x_396; lean_object* x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; lean_object* x_401; lean_object* x_402; +if (lean_is_scalar(x_389)) { + x_396 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_396 = x_389; +} +lean_ctor_set(x_396, 0, x_35); +lean_ctor_set(x_396, 1, x_390); +lean_ctor_set_usize(x_396, 2, x_388); +if (lean_is_scalar(x_386)) { + x_397 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_397 = x_386; +} +lean_ctor_set(x_397, 0, x_396); +lean_ctor_set(x_397, 1, x_384); +lean_ctor_set_usize(x_397, 2, x_385); +x_398 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_398, 0, x_397); +lean_ctor_set(x_398, 1, x_382); +lean_ctor_set_usize(x_398, 2, x_383); +lean_ctor_set(x_31, 0, x_398); +lean_inc(x_36); +lean_inc(x_31); +if (lean_is_scalar(x_393)) { + x_399 = lean_alloc_ctor(1, 2, 0); +} else { + x_399 = x_393; +} +lean_ctor_set(x_399, 0, x_31); +lean_ctor_set(x_399, 1, x_36); +x_400 = l_Lean_Syntax_getArgs(x_399); +lean_dec(x_399); +x_401 = lean_unsigned_to_nat(0u); +x_402 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_400, x_401); +lean_dec(x_400); +if (lean_obj_tag(x_402) == 0) +{ +lean_object* x_403; +lean_dec(x_1); +x_403 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_403, 0, x_31); +lean_ctor_set(x_403, 1, x_36); +return x_403; +} +else +{ +lean_object* x_404; lean_object* x_405; lean_object* x_406; uint8_t x_407; +x_404 = lean_ctor_get(x_402, 0); +lean_inc(x_404); +lean_dec(x_402); +x_405 = l_Lean_Delaborator_infoForPos(x_1); +x_406 = lean_array_get_size(x_36); +x_407 = lean_nat_dec_lt(x_404, x_406); +lean_dec(x_406); +if (x_407 == 0) +{ +lean_object* x_408; +lean_dec(x_405); +lean_dec(x_404); +x_408 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_408, 0, x_31); +lean_ctor_set(x_408, 1, x_36); +return x_408; +} +else +{ +lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; +x_409 = lean_array_fget(x_36, x_404); +x_410 = lean_box(0); +x_411 = lean_array_fset(x_36, x_404, x_410); +x_412 = l_Lean_Syntax_setInfo(x_405, x_409); +x_413 = lean_array_fset(x_411, x_404, x_412); +lean_dec(x_404); +x_414 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_414, 0, x_31); +lean_ctor_set(x_414, 1, x_413); +return x_414; +} +} +} +else +{ +lean_object* x_415; uint8_t x_416; +lean_dec(x_384); +x_415 = l_Lean_mkAppStx___closed__5; +x_416 = lean_string_dec_eq(x_382, x_415); +if (x_416 == 0) +{ +lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; lean_object* x_422; lean_object* x_423; +if (lean_is_scalar(x_389)) { + x_417 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_417 = x_389; +} +lean_ctor_set(x_417, 0, x_35); +lean_ctor_set(x_417, 1, x_390); +lean_ctor_set_usize(x_417, 2, x_388); +if (lean_is_scalar(x_386)) { + x_418 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_418 = x_386; +} +lean_ctor_set(x_418, 0, x_417); +lean_ctor_set(x_418, 1, x_394); +lean_ctor_set_usize(x_418, 2, x_385); +x_419 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_419, 0, x_418); +lean_ctor_set(x_419, 1, x_382); +lean_ctor_set_usize(x_419, 2, x_383); +lean_ctor_set(x_31, 0, x_419); +lean_inc(x_36); +lean_inc(x_31); +if (lean_is_scalar(x_393)) { + x_420 = lean_alloc_ctor(1, 2, 0); +} else { + x_420 = x_393; +} +lean_ctor_set(x_420, 0, x_31); +lean_ctor_set(x_420, 1, x_36); +x_421 = l_Lean_Syntax_getArgs(x_420); +lean_dec(x_420); +x_422 = lean_unsigned_to_nat(0u); +x_423 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_421, x_422); +lean_dec(x_421); +if (lean_obj_tag(x_423) == 0) +{ +lean_object* x_424; +lean_dec(x_1); +x_424 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_424, 0, x_31); +lean_ctor_set(x_424, 1, x_36); +return x_424; +} +else +{ +lean_object* x_425; lean_object* x_426; lean_object* x_427; uint8_t x_428; +x_425 = lean_ctor_get(x_423, 0); +lean_inc(x_425); +lean_dec(x_423); +x_426 = l_Lean_Delaborator_infoForPos(x_1); +x_427 = lean_array_get_size(x_36); +x_428 = lean_nat_dec_lt(x_425, x_427); +lean_dec(x_427); +if (x_428 == 0) +{ +lean_object* x_429; +lean_dec(x_426); +lean_dec(x_425); +x_429 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_429, 0, x_31); +lean_ctor_set(x_429, 1, x_36); +return x_429; +} +else +{ +lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; +x_430 = lean_array_fget(x_36, x_425); +x_431 = lean_box(0); +x_432 = lean_array_fset(x_36, x_425, x_431); +x_433 = l_Lean_Syntax_setInfo(x_426, x_430); +x_434 = lean_array_fset(x_432, x_425, x_433); +lean_dec(x_425); +x_435 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_435, 0, x_31); +lean_ctor_set(x_435, 1, x_434); +return x_435; +} +} +} +else +{ +lean_object* x_436; uint8_t x_437; +lean_dec(x_382); +x_436 = l_Lean_mkTermIdFromIdent___closed__1; +x_437 = lean_string_dec_eq(x_38, x_436); +if (x_437 == 0) +{ +lean_object* x_438; uint8_t x_439; +x_438 = l_Lean_mkAppStx___closed__7; +x_439 = lean_string_dec_eq(x_38, x_438); +if (x_439 == 0) +{ +lean_object* x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; lean_object* x_446; +if (lean_is_scalar(x_389)) { + x_440 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_440 = x_389; +} +lean_ctor_set(x_440, 0, x_35); +lean_ctor_set(x_440, 1, x_390); +lean_ctor_set_usize(x_440, 2, x_388); +if (lean_is_scalar(x_386)) { + x_441 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_441 = x_386; +} +lean_ctor_set(x_441, 0, x_440); +lean_ctor_set(x_441, 1, x_394); +lean_ctor_set_usize(x_441, 2, x_385); +x_442 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_442, 0, x_441); +lean_ctor_set(x_442, 1, x_415); +lean_ctor_set_usize(x_442, 2, x_383); +lean_ctor_set(x_31, 0, x_442); +lean_inc(x_36); +lean_inc(x_31); +if (lean_is_scalar(x_393)) { + x_443 = lean_alloc_ctor(1, 2, 0); +} else { + x_443 = x_393; +} +lean_ctor_set(x_443, 0, x_31); +lean_ctor_set(x_443, 1, x_36); +x_444 = l_Lean_Syntax_getArgs(x_443); +lean_dec(x_443); +x_445 = lean_unsigned_to_nat(0u); +x_446 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_444, x_445); +lean_dec(x_444); +if (lean_obj_tag(x_446) == 0) +{ +lean_object* x_447; +lean_dec(x_1); +x_447 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_447, 0, x_31); +lean_ctor_set(x_447, 1, x_36); +return x_447; +} +else +{ +lean_object* x_448; lean_object* x_449; lean_object* x_450; uint8_t x_451; +x_448 = lean_ctor_get(x_446, 0); +lean_inc(x_448); +lean_dec(x_446); +x_449 = l_Lean_Delaborator_infoForPos(x_1); +x_450 = lean_array_get_size(x_36); +x_451 = lean_nat_dec_lt(x_448, x_450); +lean_dec(x_450); +if (x_451 == 0) +{ +lean_object* x_452; +lean_dec(x_449); +lean_dec(x_448); +x_452 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_452, 0, x_31); +lean_ctor_set(x_452, 1, x_36); +return x_452; +} +else +{ +lean_object* x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; +x_453 = lean_array_fget(x_36, x_448); +x_454 = lean_box(0); +x_455 = lean_array_fset(x_36, x_448, x_454); +x_456 = l_Lean_Syntax_setInfo(x_449, x_453); +x_457 = lean_array_fset(x_455, x_448, x_456); +lean_dec(x_448); +x_458 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_458, 0, x_31); +lean_ctor_set(x_458, 1, x_457); +return x_458; +} +} +} +else +{ +lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; uint8_t x_464; +lean_dec(x_38); +if (lean_is_scalar(x_389)) { + x_459 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_459 = x_389; +} +lean_ctor_set(x_459, 0, x_35); +lean_ctor_set(x_459, 1, x_390); +lean_ctor_set_usize(x_459, 2, x_388); +if (lean_is_scalar(x_386)) { + x_460 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_460 = x_386; +} +lean_ctor_set(x_460, 0, x_459); +lean_ctor_set(x_460, 1, x_394); +lean_ctor_set_usize(x_460, 2, x_385); +x_461 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_461, 0, x_460); +lean_ctor_set(x_461, 1, x_415); +lean_ctor_set_usize(x_461, 2, x_383); +lean_ctor_set(x_31, 1, x_438); +lean_ctor_set(x_31, 0, x_461); +x_462 = lean_array_get_size(x_36); +x_463 = lean_unsigned_to_nat(0u); +x_464 = lean_nat_dec_lt(x_463, x_462); +lean_dec(x_462); +if (x_464 == 0) +{ +lean_object* x_465; +lean_dec(x_1); +if (lean_is_scalar(x_393)) { + x_465 = lean_alloc_ctor(1, 2, 0); +} else { + x_465 = x_393; +} +lean_ctor_set(x_465, 0, x_31); +lean_ctor_set(x_465, 1, x_36); +return x_465; +} +else +{ +lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; +x_466 = lean_array_fget(x_36, x_463); +x_467 = lean_box(0); +x_468 = lean_array_fset(x_36, x_463, x_467); +x_469 = l_Lean_Delaborator_annotatePos___main(x_1, x_466); +x_470 = lean_array_fset(x_468, x_463, x_469); +if (lean_is_scalar(x_393)) { + x_471 = lean_alloc_ctor(1, 2, 0); +} else { + x_471 = x_393; +} +lean_ctor_set(x_471, 0, x_31); +lean_ctor_set(x_471, 1, x_470); +return x_471; +} +} +} +else +{ +lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; lean_object* x_476; uint8_t x_477; +lean_dec(x_38); +if (lean_is_scalar(x_389)) { + x_472 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_472 = x_389; +} +lean_ctor_set(x_472, 0, x_35); +lean_ctor_set(x_472, 1, x_390); +lean_ctor_set_usize(x_472, 2, x_388); +if (lean_is_scalar(x_386)) { + x_473 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_473 = x_386; +} +lean_ctor_set(x_473, 0, x_472); +lean_ctor_set(x_473, 1, x_394); +lean_ctor_set_usize(x_473, 2, x_385); +x_474 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_474, 0, x_473); +lean_ctor_set(x_474, 1, x_415); +lean_ctor_set_usize(x_474, 2, x_383); +lean_ctor_set(x_31, 1, x_436); +lean_ctor_set(x_31, 0, x_474); +x_475 = lean_array_get_size(x_36); +x_476 = lean_unsigned_to_nat(0u); +x_477 = lean_nat_dec_lt(x_476, x_475); +lean_dec(x_475); +if (x_477 == 0) +{ +lean_object* x_478; +lean_dec(x_1); +if (lean_is_scalar(x_393)) { + x_478 = lean_alloc_ctor(1, 2, 0); +} else { + x_478 = x_393; +} +lean_ctor_set(x_478, 0, x_31); +lean_ctor_set(x_478, 1, x_36); +return x_478; +} +else +{ +lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; +x_479 = lean_array_fget(x_36, x_476); +x_480 = lean_box(0); +x_481 = lean_array_fset(x_36, x_476, x_480); +x_482 = l_Lean_Delaborator_annotatePos___main(x_1, x_479); +x_483 = lean_array_fset(x_481, x_476, x_482); +if (lean_is_scalar(x_393)) { + x_484 = lean_alloc_ctor(1, 2, 0); +} else { + x_484 = x_393; +} +lean_ctor_set(x_484, 0, x_31); +lean_ctor_set(x_484, 1, x_483); +return x_484; +} +} +} +} +} +} +} +else +{ +lean_object* x_485; size_t x_486; lean_object* x_487; size_t x_488; lean_object* x_489; lean_object* x_490; size_t x_491; lean_object* x_492; lean_object* x_493; size_t x_494; lean_object* x_495; lean_object* x_496; uint8_t x_497; +x_485 = lean_ctor_get(x_31, 1); +x_486 = lean_ctor_get_usize(x_31, 2); +lean_inc(x_485); +lean_dec(x_31); +x_487 = lean_ctor_get(x_32, 1); +lean_inc(x_487); +x_488 = lean_ctor_get_usize(x_32, 2); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_489 = x_32; +} else { + lean_dec_ref(x_32); + x_489 = lean_box(0); +} +x_490 = lean_ctor_get(x_33, 1); +lean_inc(x_490); +x_491 = lean_ctor_get_usize(x_33, 2); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_492 = x_33; +} else { + lean_dec_ref(x_33); + x_492 = lean_box(0); +} +x_493 = lean_ctor_get(x_34, 1); +lean_inc(x_493); +x_494 = lean_ctor_get_usize(x_34, 2); +if (lean_is_exclusive(x_34)) { + lean_ctor_release(x_34, 0); + lean_ctor_release(x_34, 1); + x_495 = x_34; +} else { + lean_dec_ref(x_34); + x_495 = lean_box(0); +} +x_496 = l_Lean_mkAppStx___closed__1; +x_497 = lean_string_dec_eq(x_493, x_496); +lean_dec(x_493); +if (x_497 == 0) +{ +lean_object* x_498; +lean_dec(x_495); +lean_dec(x_492); +lean_dec(x_490); +lean_dec(x_489); +lean_dec(x_487); +lean_dec(x_485); +lean_dec(x_36); +x_498 = lean_box(0); +x_3 = x_498; +goto block_30; +} +else +{ +lean_object* x_499; lean_object* x_500; uint8_t x_501; +if (lean_is_exclusive(x_2)) { + lean_ctor_release(x_2, 0); + lean_ctor_release(x_2, 1); + x_499 = x_2; +} else { + lean_dec_ref(x_2); + x_499 = lean_box(0); +} +x_500 = l_Lean_mkAppStx___closed__3; +x_501 = lean_string_dec_eq(x_490, x_500); +if (x_501 == 0) +{ +lean_object* x_502; lean_object* x_503; lean_object* x_504; lean_object* x_505; lean_object* x_506; lean_object* x_507; lean_object* x_508; lean_object* x_509; +if (lean_is_scalar(x_495)) { + x_502 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_502 = x_495; +} +lean_ctor_set(x_502, 0, x_35); +lean_ctor_set(x_502, 1, x_496); +lean_ctor_set_usize(x_502, 2, x_494); +if (lean_is_scalar(x_492)) { + x_503 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_503 = x_492; +} +lean_ctor_set(x_503, 0, x_502); +lean_ctor_set(x_503, 1, x_490); +lean_ctor_set_usize(x_503, 2, x_491); +if (lean_is_scalar(x_489)) { + x_504 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_504 = x_489; +} +lean_ctor_set(x_504, 0, x_503); +lean_ctor_set(x_504, 1, x_487); +lean_ctor_set_usize(x_504, 2, x_488); +x_505 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_505, 0, x_504); +lean_ctor_set(x_505, 1, x_485); +lean_ctor_set_usize(x_505, 2, x_486); +lean_inc(x_36); +lean_inc(x_505); +if (lean_is_scalar(x_499)) { + x_506 = lean_alloc_ctor(1, 2, 0); +} else { + x_506 = x_499; +} +lean_ctor_set(x_506, 0, x_505); +lean_ctor_set(x_506, 1, x_36); +x_507 = l_Lean_Syntax_getArgs(x_506); +lean_dec(x_506); +x_508 = lean_unsigned_to_nat(0u); +x_509 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_507, x_508); +lean_dec(x_507); +if (lean_obj_tag(x_509) == 0) +{ +lean_object* x_510; +lean_dec(x_1); +x_510 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_510, 0, x_505); +lean_ctor_set(x_510, 1, x_36); +return x_510; +} +else +{ +lean_object* x_511; lean_object* x_512; lean_object* x_513; uint8_t x_514; +x_511 = lean_ctor_get(x_509, 0); +lean_inc(x_511); +lean_dec(x_509); +x_512 = l_Lean_Delaborator_infoForPos(x_1); +x_513 = lean_array_get_size(x_36); +x_514 = lean_nat_dec_lt(x_511, x_513); +lean_dec(x_513); +if (x_514 == 0) +{ +lean_object* x_515; +lean_dec(x_512); +lean_dec(x_511); +x_515 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_515, 0, x_505); +lean_ctor_set(x_515, 1, x_36); +return x_515; +} +else +{ +lean_object* x_516; lean_object* x_517; lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; +x_516 = lean_array_fget(x_36, x_511); +x_517 = lean_box(0); +x_518 = lean_array_fset(x_36, x_511, x_517); +x_519 = l_Lean_Syntax_setInfo(x_512, x_516); +x_520 = lean_array_fset(x_518, x_511, x_519); +lean_dec(x_511); +x_521 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_521, 0, x_505); +lean_ctor_set(x_521, 1, x_520); +return x_521; +} +} +} +else +{ +lean_object* x_522; uint8_t x_523; +lean_dec(x_490); +x_522 = l_Lean_mkAppStx___closed__5; +x_523 = lean_string_dec_eq(x_487, x_522); +if (x_523 == 0) +{ +lean_object* x_524; lean_object* x_525; lean_object* x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; lean_object* x_530; lean_object* x_531; +if (lean_is_scalar(x_495)) { + x_524 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_524 = x_495; +} +lean_ctor_set(x_524, 0, x_35); +lean_ctor_set(x_524, 1, x_496); +lean_ctor_set_usize(x_524, 2, x_494); +if (lean_is_scalar(x_492)) { + x_525 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_525 = x_492; +} +lean_ctor_set(x_525, 0, x_524); +lean_ctor_set(x_525, 1, x_500); +lean_ctor_set_usize(x_525, 2, x_491); +if (lean_is_scalar(x_489)) { + x_526 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_526 = x_489; +} +lean_ctor_set(x_526, 0, x_525); +lean_ctor_set(x_526, 1, x_487); +lean_ctor_set_usize(x_526, 2, x_488); +x_527 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_527, 0, x_526); +lean_ctor_set(x_527, 1, x_485); +lean_ctor_set_usize(x_527, 2, x_486); +lean_inc(x_36); +lean_inc(x_527); +if (lean_is_scalar(x_499)) { + x_528 = lean_alloc_ctor(1, 2, 0); +} else { + x_528 = x_499; +} +lean_ctor_set(x_528, 0, x_527); +lean_ctor_set(x_528, 1, x_36); +x_529 = l_Lean_Syntax_getArgs(x_528); +lean_dec(x_528); +x_530 = lean_unsigned_to_nat(0u); +x_531 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_529, x_530); +lean_dec(x_529); +if (lean_obj_tag(x_531) == 0) +{ +lean_object* x_532; +lean_dec(x_1); +x_532 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_532, 0, x_527); +lean_ctor_set(x_532, 1, x_36); +return x_532; +} +else +{ +lean_object* x_533; lean_object* x_534; lean_object* x_535; uint8_t x_536; +x_533 = lean_ctor_get(x_531, 0); +lean_inc(x_533); +lean_dec(x_531); +x_534 = l_Lean_Delaborator_infoForPos(x_1); +x_535 = lean_array_get_size(x_36); +x_536 = lean_nat_dec_lt(x_533, x_535); +lean_dec(x_535); +if (x_536 == 0) +{ +lean_object* x_537; +lean_dec(x_534); +lean_dec(x_533); +x_537 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_537, 0, x_527); +lean_ctor_set(x_537, 1, x_36); +return x_537; +} +else +{ +lean_object* x_538; lean_object* x_539; lean_object* x_540; lean_object* x_541; lean_object* x_542; lean_object* x_543; +x_538 = lean_array_fget(x_36, x_533); +x_539 = lean_box(0); +x_540 = lean_array_fset(x_36, x_533, x_539); +x_541 = l_Lean_Syntax_setInfo(x_534, x_538); +x_542 = lean_array_fset(x_540, x_533, x_541); +lean_dec(x_533); +x_543 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_543, 0, x_527); +lean_ctor_set(x_543, 1, x_542); +return x_543; +} +} +} +else +{ +lean_object* x_544; uint8_t x_545; +lean_dec(x_487); +x_544 = l_Lean_mkTermIdFromIdent___closed__1; +x_545 = lean_string_dec_eq(x_485, x_544); +if (x_545 == 0) +{ +lean_object* x_546; uint8_t x_547; +x_546 = l_Lean_mkAppStx___closed__7; +x_547 = lean_string_dec_eq(x_485, x_546); +if (x_547 == 0) +{ +lean_object* x_548; lean_object* x_549; lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; lean_object* x_554; lean_object* x_555; +if (lean_is_scalar(x_495)) { + x_548 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_548 = x_495; +} +lean_ctor_set(x_548, 0, x_35); +lean_ctor_set(x_548, 1, x_496); +lean_ctor_set_usize(x_548, 2, x_494); +if (lean_is_scalar(x_492)) { + x_549 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_549 = x_492; +} +lean_ctor_set(x_549, 0, x_548); +lean_ctor_set(x_549, 1, x_500); +lean_ctor_set_usize(x_549, 2, x_491); +if (lean_is_scalar(x_489)) { + x_550 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_550 = x_489; +} +lean_ctor_set(x_550, 0, x_549); +lean_ctor_set(x_550, 1, x_522); +lean_ctor_set_usize(x_550, 2, x_488); +x_551 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_551, 0, x_550); +lean_ctor_set(x_551, 1, x_485); +lean_ctor_set_usize(x_551, 2, x_486); +lean_inc(x_36); +lean_inc(x_551); +if (lean_is_scalar(x_499)) { + x_552 = lean_alloc_ctor(1, 2, 0); +} else { + x_552 = x_499; +} +lean_ctor_set(x_552, 0, x_551); +lean_ctor_set(x_552, 1, x_36); +x_553 = l_Lean_Syntax_getArgs(x_552); +lean_dec(x_552); +x_554 = lean_unsigned_to_nat(0u); +x_555 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_553, x_554); +lean_dec(x_553); +if (lean_obj_tag(x_555) == 0) +{ +lean_object* x_556; +lean_dec(x_1); +x_556 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_556, 0, x_551); +lean_ctor_set(x_556, 1, x_36); +return x_556; +} +else +{ +lean_object* x_557; lean_object* x_558; lean_object* x_559; uint8_t x_560; +x_557 = lean_ctor_get(x_555, 0); +lean_inc(x_557); +lean_dec(x_555); +x_558 = l_Lean_Delaborator_infoForPos(x_1); +x_559 = lean_array_get_size(x_36); +x_560 = lean_nat_dec_lt(x_557, x_559); +lean_dec(x_559); +if (x_560 == 0) +{ +lean_object* x_561; +lean_dec(x_558); +lean_dec(x_557); +x_561 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_561, 0, x_551); +lean_ctor_set(x_561, 1, x_36); +return x_561; +} +else +{ +lean_object* x_562; lean_object* x_563; lean_object* x_564; lean_object* x_565; lean_object* x_566; lean_object* x_567; +x_562 = lean_array_fget(x_36, x_557); +x_563 = lean_box(0); +x_564 = lean_array_fset(x_36, x_557, x_563); +x_565 = l_Lean_Syntax_setInfo(x_558, x_562); +x_566 = lean_array_fset(x_564, x_557, x_565); +lean_dec(x_557); +x_567 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_567, 0, x_551); +lean_ctor_set(x_567, 1, x_566); +return x_567; +} +} +} +else +{ +lean_object* x_568; lean_object* x_569; lean_object* x_570; lean_object* x_571; lean_object* x_572; lean_object* x_573; uint8_t x_574; +lean_dec(x_485); +if (lean_is_scalar(x_495)) { + x_568 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_568 = x_495; +} +lean_ctor_set(x_568, 0, x_35); +lean_ctor_set(x_568, 1, x_496); +lean_ctor_set_usize(x_568, 2, x_494); +if (lean_is_scalar(x_492)) { + x_569 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_569 = x_492; +} +lean_ctor_set(x_569, 0, x_568); +lean_ctor_set(x_569, 1, x_500); +lean_ctor_set_usize(x_569, 2, x_491); +if (lean_is_scalar(x_489)) { + x_570 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_570 = x_489; +} +lean_ctor_set(x_570, 0, x_569); +lean_ctor_set(x_570, 1, x_522); +lean_ctor_set_usize(x_570, 2, x_488); +x_571 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_571, 0, x_570); +lean_ctor_set(x_571, 1, x_546); +lean_ctor_set_usize(x_571, 2, x_486); +x_572 = lean_array_get_size(x_36); +x_573 = lean_unsigned_to_nat(0u); +x_574 = lean_nat_dec_lt(x_573, x_572); +lean_dec(x_572); +if (x_574 == 0) +{ +lean_object* x_575; +lean_dec(x_1); +if (lean_is_scalar(x_499)) { + x_575 = lean_alloc_ctor(1, 2, 0); +} else { + x_575 = x_499; +} +lean_ctor_set(x_575, 0, x_571); +lean_ctor_set(x_575, 1, x_36); +return x_575; +} +else +{ +lean_object* x_576; lean_object* x_577; lean_object* x_578; lean_object* x_579; lean_object* x_580; lean_object* x_581; +x_576 = lean_array_fget(x_36, x_573); +x_577 = lean_box(0); +x_578 = lean_array_fset(x_36, x_573, x_577); +x_579 = l_Lean_Delaborator_annotatePos___main(x_1, x_576); +x_580 = lean_array_fset(x_578, x_573, x_579); +if (lean_is_scalar(x_499)) { + x_581 = lean_alloc_ctor(1, 2, 0); +} else { + x_581 = x_499; +} +lean_ctor_set(x_581, 0, x_571); +lean_ctor_set(x_581, 1, x_580); +return x_581; +} +} +} +else +{ +lean_object* x_582; lean_object* x_583; lean_object* x_584; lean_object* x_585; lean_object* x_586; lean_object* x_587; uint8_t x_588; +lean_dec(x_485); +if (lean_is_scalar(x_495)) { + x_582 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_582 = x_495; +} +lean_ctor_set(x_582, 0, x_35); +lean_ctor_set(x_582, 1, x_496); +lean_ctor_set_usize(x_582, 2, x_494); +if (lean_is_scalar(x_492)) { + x_583 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_583 = x_492; +} +lean_ctor_set(x_583, 0, x_582); +lean_ctor_set(x_583, 1, x_500); +lean_ctor_set_usize(x_583, 2, x_491); +if (lean_is_scalar(x_489)) { + x_584 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +} else { + x_584 = x_489; +} +lean_ctor_set(x_584, 0, x_583); +lean_ctor_set(x_584, 1, x_522); +lean_ctor_set_usize(x_584, 2, x_488); +x_585 = lean_alloc_ctor(1, 2, sizeof(size_t)*1); +lean_ctor_set(x_585, 0, x_584); +lean_ctor_set(x_585, 1, x_544); +lean_ctor_set_usize(x_585, 2, x_486); +x_586 = lean_array_get_size(x_36); +x_587 = lean_unsigned_to_nat(0u); +x_588 = lean_nat_dec_lt(x_587, x_586); +lean_dec(x_586); +if (x_588 == 0) +{ +lean_object* x_589; +lean_dec(x_1); +if (lean_is_scalar(x_499)) { + x_589 = lean_alloc_ctor(1, 2, 0); +} else { + x_589 = x_499; +} +lean_ctor_set(x_589, 0, x_585); +lean_ctor_set(x_589, 1, x_36); +return x_589; +} +else +{ +lean_object* x_590; lean_object* x_591; lean_object* x_592; lean_object* x_593; lean_object* x_594; lean_object* x_595; +x_590 = lean_array_fget(x_36, x_587); +x_591 = lean_box(0); +x_592 = lean_array_fset(x_36, x_587, x_591); +x_593 = l_Lean_Delaborator_annotatePos___main(x_1, x_590); +x_594 = lean_array_fset(x_592, x_587, x_593); +if (lean_is_scalar(x_499)) { + x_595 = lean_alloc_ctor(1, 2, 0); +} else { + x_595 = x_499; +} +lean_ctor_set(x_595, 0, x_585); +lean_ctor_set(x_595, 1, x_594); +return x_595; +} +} +} +} +} +} +} +else +{ +lean_object* x_596; +lean_dec(x_35); +lean_dec(x_34); +lean_dec(x_33); +lean_dec(x_32); +lean_dec(x_31); +x_596 = lean_box(0); +x_3 = x_596; +goto block_30; +} +} +else +{ +lean_object* x_597; +lean_dec(x_34); +lean_dec(x_33); +lean_dec(x_32); +lean_dec(x_31); +x_597 = lean_box(0); +x_3 = x_597; +goto block_30; +} +} +else +{ +lean_object* x_598; +lean_dec(x_33); +lean_dec(x_32); +lean_dec(x_31); +x_598 = lean_box(0); +x_3 = x_598; +goto block_30; +} +} +else +{ +lean_object* x_599; +lean_dec(x_32); +lean_dec(x_31); +x_599 = lean_box(0); +x_3 = x_599; +goto block_30; +} +} +else +{ +lean_object* x_600; +lean_dec(x_31); +x_600 = lean_box(0); +x_3 = x_600; +goto block_30; +} +} +case 3: +{ +lean_object* x_601; lean_object* x_602; +x_601 = l_Lean_Delaborator_infoForPos(x_1); +x_602 = l_Lean_Syntax_setInfo(x_601, x_2); +return x_602; +} +default: +{ +lean_object* x_603; +x_603 = lean_box(0); +x_3 = x_603; +goto block_30; +} +} +block_30: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +lean_dec(x_3); +x_4 = l_Lean_Syntax_getArgs(x_2); +x_5 = lean_unsigned_to_nat(0u); +x_6 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_4, x_5); +lean_dec(x_4); +if (lean_obj_tag(x_6) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +if (lean_obj_tag(x_2) == 1) +{ +lean_object* x_7; uint8_t x_8; +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +lean_dec(x_6); +x_8 = !lean_is_exclusive(x_2); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_9 = lean_ctor_get(x_2, 1); +x_10 = l_Lean_Delaborator_infoForPos(x_1); +x_11 = lean_array_get_size(x_9); +x_12 = lean_nat_dec_lt(x_7, x_11); +lean_dec(x_11); +if (x_12 == 0) +{ +lean_dec(x_10); +lean_dec(x_7); +return x_2; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_13 = lean_array_fget(x_9, x_7); +x_14 = lean_box(0); +x_15 = lean_array_fset(x_9, x_7, x_14); +x_16 = l_Lean_Syntax_setInfo(x_10, x_13); +x_17 = lean_array_fset(x_15, x_7, x_16); +lean_dec(x_7); +lean_ctor_set(x_2, 1, x_17); +return x_2; +} +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_18 = lean_ctor_get(x_2, 0); +x_19 = lean_ctor_get(x_2, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_2); +x_20 = l_Lean_Delaborator_infoForPos(x_1); +x_21 = lean_array_get_size(x_19); +x_22 = lean_nat_dec_lt(x_7, x_21); +lean_dec(x_21); +if (x_22 == 0) +{ +lean_object* x_23; +lean_dec(x_20); +lean_dec(x_7); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_18); +lean_ctor_set(x_23, 1, x_19); +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_object* x_29; +x_24 = lean_array_fget(x_19, x_7); +x_25 = lean_box(0); +x_26 = lean_array_fset(x_19, x_7, x_25); +x_27 = l_Lean_Syntax_setInfo(x_20, x_24); +x_28 = lean_array_fset(x_26, x_7, x_27); +lean_dec(x_7); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_18); +lean_ctor_set(x_29, 1, x_28); +return x_29; +} +} +} +else +{ +lean_dec(x_6); +lean_dec(x_1); +return x_2; +} +} +} +} +} +lean_object* l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Array_findIdxAux___main___at_Lean_Delaborator_annotatePos___main___spec__1(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_Lean_Delaborator_annotatePos(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lean_Delaborator_annotatePos___main(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Delaborator_annotateCurPos(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_2, 1); +lean_inc(x_5); +lean_dec(x_2); +x_6 = l_Lean_Delaborator_annotatePos___main(x_5, x_1); +x_7 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_7, 0, x_6); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_4); +return x_8; +} +} +lean_object* l_Lean_Delaborator_annotateCurPos___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_Delaborator_annotateCurPos(x_1, x_2, x_3, x_4); +lean_dec(x_3); +return x_5; +} +} +lean_object* l_PersistentHashMap_findAtAux___main___at_Lean_Delaborator_delabFor___main___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; uint8_t x_7; +x_6 = lean_array_get_size(x_1); +x_7 = lean_nat_dec_lt(x_4, x_6); +lean_dec(x_6); +if (x_7 == 0) +{ +lean_object* x_8; +lean_dec(x_4); +x_8 = lean_box(0); +return x_8; +} +else +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_array_fget(x_1, x_4); +x_10 = lean_name_eq(x_5, x_9); +lean_dec(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_unsigned_to_nat(1u); +x_12 = lean_nat_add(x_4, x_11); +lean_dec(x_4); +x_3 = lean_box(0); +x_4 = x_12; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; +x_14 = lean_array_fget(x_2, x_4); +lean_dec(x_4); +x_15 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_15, 0, x_14); +return x_15; +} +} +} +} +lean_object* l_PersistentHashMap_findAux___main___at_Lean_Delaborator_delabFor___main___spec__3(lean_object* x_1, size_t x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_4; size_t x_5; size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +x_5 = 5; +x_6 = l_PersistentHashMap_insertAux___main___rarg___closed__2; +x_7 = x_2 & x_6; +x_8 = lean_usize_to_nat(x_7); +x_9 = lean_box(2); +x_10 = lean_array_get(x_9, x_4, x_8); +lean_dec(x_8); +lean_dec(x_4); +switch (lean_obj_tag(x_10)) { +case 0: +{ +lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_name_eq(x_3, x_11); +lean_dec(x_11); +if (x_13 == 0) +{ +lean_object* x_14; +lean_dec(x_12); +x_14 = lean_box(0); +return x_14; +} +else +{ +lean_object* x_15; +x_15 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_15, 0, x_12); +return x_15; +} +} +case 1: +{ +lean_object* x_16; size_t x_17; +x_16 = lean_ctor_get(x_10, 0); +lean_inc(x_16); +lean_dec(x_10); +x_17 = x_2 >> x_5; +x_1 = x_16; +x_2 = x_17; +goto _start; +} +default: +{ +lean_object* x_19; +x_19 = lean_box(0); +return x_19; +} +} +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_20 = lean_ctor_get(x_1, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_1, 1); +lean_inc(x_21); +lean_dec(x_1); +x_22 = lean_unsigned_to_nat(0u); +x_23 = l_PersistentHashMap_findAtAux___main___at_Lean_Delaborator_delabFor___main___spec__4(x_20, x_21, lean_box(0), x_22, x_3); +lean_dec(x_21); +lean_dec(x_20); +return x_23; +} +} +} +lean_object* l_PersistentHashMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; size_t x_4; lean_object* x_5; +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_findAux___main___at_Lean_Delaborator_delabFor___main___spec__3(x_3, x_4, x_2); +return x_5; +} +} +lean_object* l_AssocList_find_x3f___main___at_Lean_Delaborator_delabFor___main___spec__6(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; +x_3 = lean_box(0); +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_ctor_get(x_2, 2); +x_7 = lean_name_eq(x_4, x_1); +if (x_7 == 0) +{ +x_2 = x_6; +goto _start; +} +else +{ +lean_object* x_9; +lean_inc(x_5); +x_9 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_9, 0, x_5); +return x_9; +} +} +} +} +lean_object* l_HashMapImp_find_x3f___at_Lean_Delaborator_delabFor___main___spec__5(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_8; +x_3 = lean_ctor_get(x_1, 1); +x_4 = lean_array_get_size(x_3); +x_5 = l_Lean_Name_hash(x_2); +x_6 = lean_usize_modn(x_5, x_4); +lean_dec(x_4); +x_7 = lean_array_uget(x_3, x_6); +x_8 = l_AssocList_find_x3f___main___at_Lean_Delaborator_delabFor___main___spec__6(x_2, x_7); +lean_dec(x_7); +return x_8; +} +} +lean_object* l_Lean_SMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = lean_ctor_get_uint8(x_1, sizeof(void*)*2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = l_PersistentHashMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__2(x_5, x_2); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = l_HashMapImp_find_x3f___at_Lean_Delaborator_delabFor___main___spec__5(x_4, x_2); +lean_dec(x_4); +return x_7; +} +else +{ +lean_dec(x_4); +return x_6; +} +} +else +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +lean_dec(x_1); +x_9 = l_HashMapImp_find_x3f___at_Lean_Delaborator_delabFor___main___spec__5(x_8, x_2); +lean_dec(x_8); +return x_9; +} +} +} +lean_object* l_List_firstM___main___at_Lean_Delaborator_delabFor___main___spec__7(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_5; lean_object* x_6; +lean_dec(x_3); +lean_dec(x_2); +x_5 = lean_box(0); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_4); +return x_6; +} +else +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_1, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +lean_dec(x_1); +lean_inc(x_3); +lean_inc(x_2); +x_9 = lean_apply_3(x_7, x_2, x_3, x_4); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_1 = x_8; +x_4 = x_11; +goto _start; +} +else +{ +uint8_t x_13; +lean_dec(x_8); +lean_dec(x_3); +lean_dec(x_2); +x_13 = !lean_is_exclusive(x_9); +if (x_13 == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_9, 0); +lean_dec(x_14); +return x_9; +} +else +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_ctor_get(x_9, 1); +lean_inc(x_15); +lean_dec(x_9); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_10); +lean_ctor_set(x_16, 1, x_15); +return x_16; +} +} +} +else +{ +uint8_t x_17; +lean_dec(x_8); +lean_dec(x_3); +lean_dec(x_2); +x_17 = !lean_is_exclusive(x_9); +if (x_17 == 0) +{ +return x_9; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_9, 0); +x_19 = lean_ctor_get(x_9, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_9); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +return x_20; +} +} +} +} +} +lean_object* l_Lean_Delaborator_delabFor___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = l_Lean_Delaborator_delabAttribute; +x_7 = lean_ctor_get(x_6, 1); +lean_inc(x_7); +x_8 = l_Lean_PersistentEnvExtension_getState___rarg(x_7, x_5); +lean_dec(x_5); +lean_dec(x_7); +x_9 = lean_ctor_get(x_8, 1); +lean_inc(x_9); +lean_dec(x_8); +x_10 = l_Lean_SMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__1(x_9, x_1); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_26; +x_26 = lean_box(0); +x_11 = x_26; +x_12 = x_4; +goto block_25; +} +else +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_10, 0); +lean_inc(x_27); +lean_dec(x_10); +lean_inc(x_3); +lean_inc(x_2); +x_28 = l_List_firstM___main___at_Lean_Delaborator_delabFor___main___spec__7(x_27, x_2, x_3, x_4); +if (lean_obj_tag(x_28) == 0) +{ +lean_object* x_29; +x_29 = lean_ctor_get(x_28, 0); +lean_inc(x_29); +if (lean_obj_tag(x_29) == 0) +{ +lean_object* x_30; lean_object* x_31; +x_30 = lean_ctor_get(x_28, 1); +lean_inc(x_30); +lean_dec(x_28); +x_31 = lean_box(0); +x_11 = x_31; +x_12 = x_30; +goto block_25; +} +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_28, 1); +lean_inc(x_32); +lean_dec(x_28); +x_33 = lean_ctor_get(x_29, 0); +lean_inc(x_33); +lean_dec(x_29); +lean_inc(x_2); +x_34 = l_Lean_Delaborator_annotateCurPos(x_33, x_2, x_3, x_32); +x_35 = lean_ctor_get(x_34, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_34, 1); +lean_inc(x_36); +lean_dec(x_34); +x_11 = x_35; +x_12 = x_36; +goto block_25; +} +} +else +{ +uint8_t x_37; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_37 = !lean_is_exclusive(x_28); +if (x_37 == 0) +{ +return x_28; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_28, 0); +x_39 = lean_ctor_get(x_28, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_28); +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +return x_40; +} +} +} +block_25: +{ +if (lean_obj_tag(x_11) == 0) +{ +if (lean_obj_tag(x_1) == 1) +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +lean_dec(x_1); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; +lean_dec(x_3); +lean_dec(x_2); +x_14 = lean_box(0); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_12); +return x_15; +} +else +{ +lean_object* x_16; +x_16 = l_Lean_Name_getRoot___main(x_13); +lean_dec(x_13); +x_1 = x_16; +x_4 = x_12; +goto _start; +} +} +else +{ +lean_object* x_18; lean_object* x_19; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_18 = lean_box(0); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_12); +return x_19; +} +} +else +{ +uint8_t x_20; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_20 = !lean_is_exclusive(x_11); +if (x_20 == 0) +{ +lean_object* x_21; +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_12); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_11, 0); +lean_inc(x_22); +lean_dec(x_11); +x_23 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_23, 0, x_22); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_12); +return x_24; +} +} +} +} +} +lean_object* l_PersistentHashMap_findAtAux___main___at_Lean_Delaborator_delabFor___main___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_PersistentHashMap_findAtAux___main___at_Lean_Delaborator_delabFor___main___spec__4(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_5); +lean_dec(x_2); +lean_dec(x_1); +return x_6; +} +} +lean_object* l_PersistentHashMap_findAux___main___at_Lean_Delaborator_delabFor___main___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +size_t x_4; lean_object* x_5; +x_4 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_5 = l_PersistentHashMap_findAux___main___at_Lean_Delaborator_delabFor___main___spec__3(x_1, x_4, x_3); +lean_dec(x_3); +return x_5; +} +} +lean_object* l_PersistentHashMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_PersistentHashMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__2(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +lean_object* l_AssocList_find_x3f___main___at_Lean_Delaborator_delabFor___main___spec__6___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_AssocList_find_x3f___main___at_Lean_Delaborator_delabFor___main___spec__6(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_HashMapImp_find_x3f___at_Lean_Delaborator_delabFor___main___spec__5___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_HashMapImp_find_x3f___at_Lean_Delaborator_delabFor___main___spec__5(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_Lean_SMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lean_SMap_find_x3f___at_Lean_Delaborator_delabFor___main___spec__1(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +lean_object* l_Lean_Delaborator_delabFor(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_Delaborator_delabFor___main(x_1, x_2, x_3, x_4); +return x_5; +} +} +lean_object* _init_l_Lean_Delaborator_delab___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("don't know how to delaborate '"); +return x_1; +} +} +lean_object* l_Lean_Delaborator_delab(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; +x_4 = l_Lean_Delaborator_getExprKind(x_1, x_2, x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_4, 1); +lean_inc(x_6); +lean_dec(x_4); +x_7 = lean_ctor_get(x_5, 0); +lean_inc(x_7); +lean_dec(x_5); +x_8 = l_Lean_Name_toString___closed__1; +lean_inc(x_7); +x_9 = l_Lean_Name_toStringWithSep___main(x_8, x_7); +x_10 = l_Lean_Delaborator_delab___closed__1; +x_11 = lean_string_append(x_10, x_9); +lean_dec(x_9); +x_12 = l_Char_HasRepr___closed__1; +x_13 = lean_string_append(x_11, x_12); +x_14 = lean_alloc_ctor(21, 1, 0); +lean_ctor_set(x_14, 0, x_13); +x_15 = l_Lean_Delaborator_delabFor___main(x_7, x_1, x_2, x_6); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +x_17 = !lean_is_exclusive(x_15); +if (x_17 == 0) +{ +lean_object* x_18; +x_18 = lean_ctor_get(x_15, 0); +lean_dec(x_18); +lean_ctor_set_tag(x_15, 1); +lean_ctor_set(x_15, 0, x_14); +return x_15; +} +else +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_15, 1); +lean_inc(x_19); +lean_dec(x_15); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_14); +lean_ctor_set(x_20, 1, x_19); +return x_20; +} +} +else +{ +uint8_t x_21; +lean_dec(x_14); +x_21 = !lean_is_exclusive(x_15); +if (x_21 == 0) +{ +lean_object* x_22; uint8_t x_23; +x_22 = lean_ctor_get(x_15, 0); +lean_dec(x_22); +x_23 = !lean_is_exclusive(x_16); +if (x_23 == 0) +{ +return x_15; +} +else +{ +lean_object* x_24; lean_object* x_25; +x_24 = lean_ctor_get(x_16, 0); +lean_inc(x_24); +lean_dec(x_16); +x_25 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_15, 0, x_25); +return x_15; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_26 = lean_ctor_get(x_15, 1); +lean_inc(x_26); +lean_dec(x_15); +x_27 = lean_ctor_get(x_16, 0); +lean_inc(x_27); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + x_28 = x_16; +} else { + lean_dec_ref(x_16); + x_28 = lean_box(0); +} +if (lean_is_scalar(x_28)) { + x_29 = lean_alloc_ctor(1, 1, 0); +} else { + x_29 = x_28; +} +lean_ctor_set(x_29, 0, x_27); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_26); +return x_30; +} +} +} +else +{ +uint8_t x_31; +lean_dec(x_14); +x_31 = !lean_is_exclusive(x_15); +if (x_31 == 0) +{ +return x_15; +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_15, 0); +x_33 = lean_ctor_get(x_15, 1); +lean_inc(x_33); +lean_inc(x_32); +lean_dec(x_15); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set(x_34, 1, x_33); +return x_34; +} +} +} +} +lean_object* l_Lean_Delaborator_delabFVar(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = l_Lean_Delaborator_getExpr(x_1, x_2, x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_5, 0); +if (lean_obj_tag(x_7) == 1) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_dec(x_1); +x_8 = lean_ctor_get(x_4, 1); +lean_inc(x_8); +lean_dec(x_4); +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +lean_dec(x_7); +x_10 = l_Lean_Meta_getLocalDecl(x_9, x_2, x_8); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_ctor_get(x_10, 0); +x_13 = l_Lean_LocalDecl_userName(x_12); +lean_dec(x_12); +x_14 = lean_box(0); +x_15 = l_Lean_mkTermIdFrom(x_14, x_13); +lean_ctor_set(x_5, 0, x_15); +lean_ctor_set(x_10, 0, x_5); +return x_10; +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_16 = lean_ctor_get(x_10, 0); +x_17 = lean_ctor_get(x_10, 1); +lean_inc(x_17); +lean_inc(x_16); +lean_dec(x_10); +x_18 = l_Lean_LocalDecl_userName(x_16); +lean_dec(x_16); +x_19 = lean_box(0); +x_20 = l_Lean_mkTermIdFrom(x_19, x_18); +lean_ctor_set(x_5, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_5); +lean_ctor_set(x_21, 1, x_17); +return x_21; +} +} +else +{ +uint8_t x_22; +lean_free_object(x_5); +x_22 = !lean_is_exclusive(x_10); +if (x_22 == 0) +{ +return x_10; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_10, 0); +x_24 = lean_ctor_get(x_10, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_10); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +return x_25; +} +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +lean_free_object(x_5); +lean_dec(x_7); +x_26 = lean_ctor_get(x_4, 1); +lean_inc(x_26); +lean_dec(x_4); +x_27 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_28 = l_unreachable_x21___rarg(x_27); +x_29 = lean_apply_3(x_28, x_1, x_2, x_26); +return x_29; +} +} +else +{ +lean_object* x_30; +x_30 = lean_ctor_get(x_5, 0); +lean_inc(x_30); +lean_dec(x_5); +if (lean_obj_tag(x_30) == 1) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_dec(x_1); +x_31 = lean_ctor_get(x_4, 1); +lean_inc(x_31); +lean_dec(x_4); +x_32 = lean_ctor_get(x_30, 0); +lean_inc(x_32); +lean_dec(x_30); +x_33 = l_Lean_Meta_getLocalDecl(x_32, x_2, x_31); +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_object* x_39; lean_object* x_40; lean_object* x_41; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_36 = x_33; +} else { + lean_dec_ref(x_33); + x_36 = lean_box(0); +} +x_37 = l_Lean_LocalDecl_userName(x_34); +lean_dec(x_34); +x_38 = lean_box(0); +x_39 = l_Lean_mkTermIdFrom(x_38, x_37); +x_40 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_40, 0, x_39); +if (lean_is_scalar(x_36)) { + x_41 = lean_alloc_ctor(0, 2, 0); +} else { + x_41 = x_36; +} +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_35); +return x_41; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_42 = lean_ctor_get(x_33, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_33, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_44 = x_33; +} else { + lean_dec_ref(x_33); + x_44 = lean_box(0); +} +if (lean_is_scalar(x_44)) { + x_45 = lean_alloc_ctor(1, 2, 0); +} else { + x_45 = x_44; +} +lean_ctor_set(x_45, 0, x_42); +lean_ctor_set(x_45, 1, x_43); +return x_45; +} +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +lean_dec(x_30); +x_46 = lean_ctor_get(x_4, 1); +lean_inc(x_46); +lean_dec(x_4); +x_47 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_48 = l_unreachable_x21___rarg(x_47); +x_49 = lean_apply_3(x_48, x_1, x_2, x_46); +return x_49; +} +} +} +} +lean_object* _init_l___regBuiltin_Lean_Delaborator_delabFVar___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabFVar), 3, 0); +return x_1; +} +} +lean_object* l___regBuiltin_Lean_Delaborator_delabFVar(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_Lean_Delaborator_delabAttribute; +x_3 = l_Lean_Delaborator_getExprKind___closed__5; +x_4 = l___regBuiltin_Lean_Delaborator_delabFVar___closed__1; +x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); +return x_5; +} +} +lean_object* _init_l_Lean_Delaborator_delabMVar___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_FirstTokens_toStr___closed__3; +x_3 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabMVar___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Delaborator_delabMVar___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Delaborator_delabMVar(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = l_Lean_Delaborator_getExpr(x_1, x_2, x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_5, 0); +if (lean_obj_tag(x_7) == 2) +{ +uint8_t x_8; +lean_dec(x_2); +lean_dec(x_1); +x_8 = !lean_is_exclusive(x_4); +if (x_8 == 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; lean_object* x_15; +x_9 = lean_ctor_get(x_4, 0); +lean_dec(x_9); +x_10 = lean_ctor_get(x_7, 0); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_mk_syntax_ident(x_10); +x_12 = l_Lean_Delaborator_delabMVar___closed__2; +x_13 = lean_array_push(x_12, x_11); +x_14 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; +x_15 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_13); +lean_ctor_set(x_5, 0, x_15); +return x_4; +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_16 = lean_ctor_get(x_4, 1); +lean_inc(x_16); +lean_dec(x_4); +x_17 = lean_ctor_get(x_7, 0); +lean_inc(x_17); +lean_dec(x_7); +x_18 = lean_mk_syntax_ident(x_17); +x_19 = l_Lean_Delaborator_delabMVar___closed__2; +x_20 = lean_array_push(x_19, x_18); +x_21 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_20); +lean_ctor_set(x_5, 0, x_22); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_5); +lean_ctor_set(x_23, 1, x_16); +return x_23; +} +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_free_object(x_5); +lean_dec(x_7); +x_24 = lean_ctor_get(x_4, 1); +lean_inc(x_24); +lean_dec(x_4); +x_25 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_26 = l_unreachable_x21___rarg(x_25); +x_27 = lean_apply_3(x_26, x_1, x_2, x_24); +return x_27; +} +} +else +{ +lean_object* x_28; +x_28 = lean_ctor_get(x_5, 0); +lean_inc(x_28); +lean_dec(x_5); +if (lean_obj_tag(x_28) == 2) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_2); +lean_dec(x_1); +x_29 = lean_ctor_get(x_4, 1); +lean_inc(x_29); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_30 = x_4; +} else { + lean_dec_ref(x_4); + x_30 = lean_box(0); +} +x_31 = lean_ctor_get(x_28, 0); +lean_inc(x_31); +lean_dec(x_28); +x_32 = lean_mk_syntax_ident(x_31); +x_33 = l_Lean_Delaborator_delabMVar___closed__2; +x_34 = lean_array_push(x_33, x_32); +x_35 = l_Lean_Parser_Term_namedHole___elambda__1___closed__2; +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_34); +x_37 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_37, 0, x_36); +if (lean_is_scalar(x_30)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_30; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_29); +return x_38; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +lean_dec(x_28); +x_39 = lean_ctor_get(x_4, 1); +lean_inc(x_39); +lean_dec(x_4); +x_40 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_41 = l_unreachable_x21___rarg(x_40); +x_42 = lean_apply_3(x_41, x_1, x_2, x_39); +return x_42; +} +} +} +} +lean_object* _init_l___regBuiltin_Lean_Delaborator_delabMVar___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabMVar), 3, 0); +return x_1; +} +} +lean_object* l___regBuiltin_Lean_Delaborator_delabMVar(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_Lean_Delaborator_delabAttribute; +x_3 = l_Lean_Delaborator_getExprKind___closed__8; +x_4 = l___regBuiltin_Lean_Delaborator_delabMVar___closed__1; +x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); +return x_5; +} +} +lean_object* _init_l_Lean_Delaborator_delabSort___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_sort___elambda__1___closed__5; +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* _init_l_Lean_Delaborator_delabSort___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Delaborator_delabSort___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabSort___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Term_sort___elambda__1___closed__2; +x_2 = l_Lean_Delaborator_delabSort___closed__2; +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_Delaborator_delabSort___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Delaborator_delabSort___closed__3; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabSort___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_Term_prop___elambda__1___closed__5; +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* _init_l_Lean_Delaborator_delabSort___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Delaborator_delabSort___closed__5; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabSort___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Term_prop___elambda__1___closed__2; +x_2 = l_Lean_Delaborator_delabSort___closed__6; +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_Delaborator_delabSort___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_delabSort___closed__7; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_delabSort___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Parser_Term_type___elambda__1___closed__5; +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* _init_l_Lean_Delaborator_delabSort___closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Delaborator_delabSort___closed__9; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabSort___closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Term_type___elambda__1___closed__2; +x_2 = l_Lean_Delaborator_delabSort___closed__10; +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_Delaborator_delabSort___closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Delaborator_delabSort___closed__11; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Delaborator_delabSort___closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Delaborator_delabSort___closed__11; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Delaborator_delabSort(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_4 = l_Lean_Delaborator_getExpr(x_1, x_2, x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +if (lean_is_exclusive(x_5)) { + lean_ctor_release(x_5, 0); + x_7 = x_5; +} else { + lean_dec_ref(x_5); + x_7 = lean_box(0); +} +if (lean_obj_tag(x_6) == 3) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_2); +lean_dec(x_1); +x_8 = lean_ctor_get(x_4, 1); +lean_inc(x_8); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_9 = x_4; +} else { + lean_dec_ref(x_4); + x_9 = lean_box(0); +} +x_10 = lean_ctor_get(x_6, 0); +lean_inc(x_10); +lean_dec(x_6); +switch (lean_obj_tag(x_10)) { +case 0: +{ +lean_object* x_20; lean_object* x_21; +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_7); +x_20 = l_Lean_Delaborator_delabSort___closed__8; +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_8); +return x_21; +} +case 1: +{ +lean_object* x_22; +x_22 = lean_ctor_get(x_10, 0); +lean_inc(x_22); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; lean_object* x_24; +lean_dec(x_22); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_7); +x_23 = l_Lean_Delaborator_delabSort___closed__12; +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_8); +return x_24; +} +else +{ +lean_object* x_25; +lean_dec(x_22); +x_25 = l_Lean_Level_dec___main(x_10); +if (lean_obj_tag(x_25) == 0) +{ +lean_object* x_26; +x_26 = lean_box(0); +x_11 = x_26; +goto block_19; +} +else +{ +uint8_t x_27; +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_7); +x_27 = !lean_is_exclusive(x_25); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_28 = lean_ctor_get(x_25, 0); +x_29 = l_Lean_Level_quote___main(x_28); +x_30 = l_Lean_Delaborator_delabSort___closed__13; +x_31 = lean_array_push(x_30, x_29); +x_32 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2; +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_31); +lean_ctor_set(x_25, 0, x_33); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_25); +lean_ctor_set(x_34, 1, x_8); +return x_34; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_35 = lean_ctor_get(x_25, 0); +lean_inc(x_35); +lean_dec(x_25); +x_36 = l_Lean_Level_quote___main(x_35); +x_37 = l_Lean_Delaborator_delabSort___closed__13; +x_38 = lean_array_push(x_37, x_36); +x_39 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2; +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_38); +x_41 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_41, 0, x_40); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_8); +return x_42; +} +} +} +} +default: +{ +lean_object* x_43; +x_43 = l_Lean_Level_dec___main(x_10); +if (lean_obj_tag(x_43) == 0) +{ +lean_object* x_44; +x_44 = lean_box(0); +x_11 = x_44; +goto block_19; +} +else +{ +uint8_t x_45; +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_7); +x_45 = !lean_is_exclusive(x_43); +if (x_45 == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_46 = lean_ctor_get(x_43, 0); +x_47 = l_Lean_Level_quote___main(x_46); +x_48 = l_Lean_Delaborator_delabSort___closed__13; +x_49 = lean_array_push(x_48, x_47); +x_50 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2; +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_49); +lean_ctor_set(x_43, 0, x_51); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_43); +lean_ctor_set(x_52, 1, x_8); +return x_52; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_53 = lean_ctor_get(x_43, 0); +lean_inc(x_53); +lean_dec(x_43); +x_54 = l_Lean_Level_quote___main(x_53); +x_55 = l_Lean_Delaborator_delabSort___closed__13; +x_56 = lean_array_push(x_55, x_54); +x_57 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2; +x_58 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_56); +x_59 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_59, 0, x_58); +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_59); +lean_ctor_set(x_60, 1, x_8); +return x_60; +} +} +} +} +block_19: +{ +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_dec(x_11); +x_12 = l_Lean_Level_quote___main(x_10); +x_13 = l_Lean_Delaborator_delabSort___closed__4; +x_14 = lean_array_push(x_13, x_12); +x_15 = l_Lean_Parser_Term_sortApp___elambda__1___closed__2; +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_14); +if (lean_is_scalar(x_7)) { + x_17 = lean_alloc_ctor(1, 1, 0); +} else { + x_17 = x_7; +} +lean_ctor_set(x_17, 0, x_16); +if (lean_is_scalar(x_9)) { + x_18 = lean_alloc_ctor(0, 2, 0); +} else { + x_18 = x_9; +} +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_8); +return x_18; +} +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_7); +lean_dec(x_6); +x_61 = lean_ctor_get(x_4, 1); +lean_inc(x_61); +lean_dec(x_4); +x_62 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_63 = l_unreachable_x21___rarg(x_62); +x_64 = lean_apply_3(x_63, x_1, x_2, x_61); +return x_64; +} +} +} +lean_object* _init_l___regBuiltin_Lean_Delaborator_delabSort___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabSort), 3, 0); +return x_1; +} +} +lean_object* l___regBuiltin_Lean_Delaborator_delabSort(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_Lean_Delaborator_delabAttribute; +x_3 = l_Lean_Delaborator_getExprKind___closed__10; +x_4 = l___regBuiltin_Lean_Delaborator_delabSort___closed__1; +x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); +return x_5; +} +} +lean_object* l_Array_umapMAux___main___at_Lean_Delaborator_delabConst___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_array_get_size(x_2); +x_4 = lean_nat_dec_lt(x_1, x_3); +lean_dec(x_3); +if (x_4 == 0) +{ +lean_dec(x_1); +return x_2; +} +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; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_5 = lean_array_fget(x_2, x_1); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_array_fset(x_2, x_1, x_6); +x_8 = x_5; +x_9 = l_Lean_Level_quote___main(x_8); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +x_12 = x_9; +x_13 = lean_array_fset(x_7, x_1, x_12); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_13; +goto _start; +} +} +} +lean_object* _init_l_Lean_Delaborator_delabConst___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_getPPUniverses___boxed), 1, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_delabConst___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__5; +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* _init_l_Lean_Delaborator_delabConst___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Delaborator_delabConst___closed__2; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabConst___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_PersistentArray_Stats_toString___closed__4; +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* l_Lean_Delaborator_delabConst(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = l_Lean_Delaborator_getExpr(x_1, x_2, x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_5, 0); +if (lean_obj_tag(x_7) == 4) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_4); +if (x_8 == 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; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_31; +x_9 = lean_ctor_get(x_4, 1); +x_10 = lean_ctor_get(x_4, 0); +lean_dec(x_10); +x_11 = lean_ctor_get(x_7, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_7, 1); +lean_inc(x_12); +lean_dec(x_7); +x_13 = l_Lean_Delaborator_delabConst___closed__1; +x_14 = l_Lean_Delaborator_getPPOption(x_13, x_1, x_2, x_9); +lean_dec(x_2); +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_17 = x_14; +} else { + lean_dec_ref(x_14); + x_17 = lean_box(0); +} +x_18 = lean_ctor_get(x_15, 0); +lean_inc(x_18); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + x_19 = x_15; +} else { + lean_dec_ref(x_15); + x_19 = lean_box(0); +} +x_31 = l_List_isEmpty___rarg(x_12); +if (x_31 == 0) +{ +uint8_t x_32; +x_32 = lean_unbox(x_18); +lean_dec(x_18); +if (x_32 == 0) +{ +lean_object* x_33; +lean_dec(x_12); +lean_free_object(x_4); +lean_free_object(x_5); +x_33 = lean_box(0); +x_20 = x_33; +goto block_30; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 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; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +lean_dec(x_19); +lean_dec(x_17); +x_34 = lean_mk_syntax_ident(x_11); +x_35 = l_Array_empty___closed__1; +x_36 = lean_array_push(x_35, x_34); +x_37 = l_List_redLength___main___rarg(x_12); +x_38 = lean_mk_empty_array_with_capacity(x_37); +lean_dec(x_37); +x_39 = l_List_toArrayAux___main___rarg(x_12, x_38); +x_40 = x_39; +x_41 = lean_unsigned_to_nat(0u); +x_42 = l_Array_umapMAux___main___at_Lean_Delaborator_delabConst___spec__1(x_41, x_40); +x_43 = x_42; +x_44 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_43, x_43, x_41, x_35); +lean_dec(x_43); +x_45 = l_Lean_nullKind___closed__2; +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_44); +x_47 = l_Lean_Delaborator_delabConst___closed__3; +x_48 = lean_array_push(x_47, x_46); +x_49 = l_Lean_Delaborator_delabConst___closed__4; +x_50 = lean_array_push(x_48, x_49); +x_51 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; +x_52 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_array_push(x_35, x_52); +x_54 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_54, 0, x_45); +lean_ctor_set(x_54, 1, x_53); +x_55 = lean_array_push(x_36, x_54); +x_56 = l_Lean_mkTermIdFromIdent___closed__2; +x_57 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_55); +lean_ctor_set(x_5, 0, x_57); +lean_ctor_set(x_4, 1, x_16); +return x_4; +} +} +else +{ +lean_object* x_58; +lean_dec(x_18); +lean_dec(x_12); +lean_free_object(x_4); +lean_free_object(x_5); +x_58 = lean_box(0); +x_20 = x_58; +goto block_30; +} +block_30: +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +lean_dec(x_20); +x_21 = lean_mk_syntax_ident(x_11); +x_22 = l_Array_empty___closed__1; +x_23 = lean_array_push(x_22, x_21); +x_24 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_25 = lean_array_push(x_23, x_24); +x_26 = l_Lean_mkTermIdFromIdent___closed__2; +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_25); +if (lean_is_scalar(x_19)) { + x_28 = lean_alloc_ctor(1, 1, 0); +} else { + x_28 = x_19; +} +lean_ctor_set(x_28, 0, x_27); +if (lean_is_scalar(x_17)) { + x_29 = lean_alloc_ctor(0, 2, 0); +} else { + x_29 = x_17; +} +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_16); +return x_29; +} +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_80; +x_59 = lean_ctor_get(x_4, 1); +lean_inc(x_59); +lean_dec(x_4); +x_60 = lean_ctor_get(x_7, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_7, 1); +lean_inc(x_61); +lean_dec(x_7); +x_62 = l_Lean_Delaborator_delabConst___closed__1; +x_63 = l_Lean_Delaborator_getPPOption(x_62, x_1, x_2, x_59); +lean_dec(x_2); +x_64 = lean_ctor_get(x_63, 0); +lean_inc(x_64); +x_65 = lean_ctor_get(x_63, 1); +lean_inc(x_65); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + lean_ctor_release(x_63, 1); + x_66 = x_63; +} else { + lean_dec_ref(x_63); + x_66 = lean_box(0); +} +x_67 = lean_ctor_get(x_64, 0); +lean_inc(x_67); +if (lean_is_exclusive(x_64)) { + lean_ctor_release(x_64, 0); + x_68 = x_64; +} else { + lean_dec_ref(x_64); + x_68 = lean_box(0); +} +x_80 = l_List_isEmpty___rarg(x_61); +if (x_80 == 0) +{ +uint8_t x_81; +x_81 = lean_unbox(x_67); +lean_dec(x_67); +if (x_81 == 0) +{ +lean_object* x_82; +lean_dec(x_61); +lean_free_object(x_5); +x_82 = lean_box(0); +x_69 = x_82; +goto block_79; +} +else +{ +lean_object* x_83; 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_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_68); +lean_dec(x_66); +x_83 = lean_mk_syntax_ident(x_60); +x_84 = l_Array_empty___closed__1; +x_85 = lean_array_push(x_84, x_83); +x_86 = l_List_redLength___main___rarg(x_61); +x_87 = lean_mk_empty_array_with_capacity(x_86); +lean_dec(x_86); +x_88 = l_List_toArrayAux___main___rarg(x_61, x_87); +x_89 = x_88; +x_90 = lean_unsigned_to_nat(0u); +x_91 = l_Array_umapMAux___main___at_Lean_Delaborator_delabConst___spec__1(x_90, x_89); +x_92 = x_91; +x_93 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_92, x_92, x_90, x_84); +lean_dec(x_92); +x_94 = l_Lean_nullKind___closed__2; +x_95 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_93); +x_96 = l_Lean_Delaborator_delabConst___closed__3; +x_97 = lean_array_push(x_96, x_95); +x_98 = l_Lean_Delaborator_delabConst___closed__4; +x_99 = lean_array_push(x_97, x_98); +x_100 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_100); +lean_ctor_set(x_101, 1, x_99); +x_102 = lean_array_push(x_84, x_101); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_94); +lean_ctor_set(x_103, 1, x_102); +x_104 = lean_array_push(x_85, x_103); +x_105 = l_Lean_mkTermIdFromIdent___closed__2; +x_106 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_106, 0, x_105); +lean_ctor_set(x_106, 1, x_104); +lean_ctor_set(x_5, 0, x_106); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_5); +lean_ctor_set(x_107, 1, x_65); +return x_107; +} +} +else +{ +lean_object* x_108; +lean_dec(x_67); +lean_dec(x_61); +lean_free_object(x_5); +x_108 = lean_box(0); +x_69 = x_108; +goto block_79; +} +block_79: +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +lean_dec(x_69); +x_70 = lean_mk_syntax_ident(x_60); +x_71 = l_Array_empty___closed__1; +x_72 = lean_array_push(x_71, x_70); +x_73 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_74 = lean_array_push(x_72, x_73); +x_75 = l_Lean_mkTermIdFromIdent___closed__2; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_74); +if (lean_is_scalar(x_68)) { + x_77 = lean_alloc_ctor(1, 1, 0); +} else { + x_77 = x_68; +} +lean_ctor_set(x_77, 0, x_76); +if (lean_is_scalar(x_66)) { + x_78 = lean_alloc_ctor(0, 2, 0); +} else { + x_78 = x_66; +} +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_65); +return x_78; +} +} +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_free_object(x_5); +lean_dec(x_7); +x_109 = lean_ctor_get(x_4, 1); +lean_inc(x_109); +lean_dec(x_4); +x_110 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_111 = l_unreachable_x21___rarg(x_110); +x_112 = lean_apply_3(x_111, x_1, x_2, x_109); +return x_112; +} +} +else +{ +lean_object* x_113; +x_113 = lean_ctor_get(x_5, 0); +lean_inc(x_113); +lean_dec(x_5); +if (lean_obj_tag(x_113) == 4) +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_136; +x_114 = lean_ctor_get(x_4, 1); +lean_inc(x_114); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_115 = x_4; +} else { + lean_dec_ref(x_4); + x_115 = lean_box(0); +} +x_116 = lean_ctor_get(x_113, 0); +lean_inc(x_116); +x_117 = lean_ctor_get(x_113, 1); +lean_inc(x_117); +lean_dec(x_113); +x_118 = l_Lean_Delaborator_delabConst___closed__1; +x_119 = l_Lean_Delaborator_getPPOption(x_118, x_1, x_2, x_114); +lean_dec(x_2); +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_122 = x_119; +} else { + lean_dec_ref(x_119); + x_122 = lean_box(0); +} +x_123 = lean_ctor_get(x_120, 0); +lean_inc(x_123); +if (lean_is_exclusive(x_120)) { + lean_ctor_release(x_120, 0); + x_124 = x_120; +} else { + lean_dec_ref(x_120); + x_124 = lean_box(0); +} +x_136 = l_List_isEmpty___rarg(x_117); +if (x_136 == 0) +{ +uint8_t x_137; +x_137 = lean_unbox(x_123); +lean_dec(x_123); +if (x_137 == 0) +{ +lean_object* x_138; +lean_dec(x_117); +lean_dec(x_115); +x_138 = lean_box(0); +x_125 = x_138; +goto block_135; +} +else +{ +lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_124); +lean_dec(x_122); +x_139 = lean_mk_syntax_ident(x_116); +x_140 = l_Array_empty___closed__1; +x_141 = lean_array_push(x_140, x_139); +x_142 = l_List_redLength___main___rarg(x_117); +x_143 = lean_mk_empty_array_with_capacity(x_142); +lean_dec(x_142); +x_144 = l_List_toArrayAux___main___rarg(x_117, x_143); +x_145 = x_144; +x_146 = lean_unsigned_to_nat(0u); +x_147 = l_Array_umapMAux___main___at_Lean_Delaborator_delabConst___spec__1(x_146, x_145); +x_148 = x_147; +x_149 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_148, x_148, x_146, x_140); +lean_dec(x_148); +x_150 = l_Lean_nullKind___closed__2; +x_151 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_151, 0, x_150); +lean_ctor_set(x_151, 1, x_149); +x_152 = l_Lean_Delaborator_delabConst___closed__3; +x_153 = lean_array_push(x_152, x_151); +x_154 = l_Lean_Delaborator_delabConst___closed__4; +x_155 = lean_array_push(x_153, x_154); +x_156 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; +x_157 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_157, 0, x_156); +lean_ctor_set(x_157, 1, x_155); +x_158 = lean_array_push(x_140, x_157); +x_159 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_159, 0, x_150); +lean_ctor_set(x_159, 1, x_158); +x_160 = lean_array_push(x_141, x_159); +x_161 = l_Lean_mkTermIdFromIdent___closed__2; +x_162 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_160); +x_163 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_163, 0, x_162); +if (lean_is_scalar(x_115)) { + x_164 = lean_alloc_ctor(0, 2, 0); +} else { + x_164 = x_115; +} +lean_ctor_set(x_164, 0, x_163); +lean_ctor_set(x_164, 1, x_121); +return x_164; +} +} +else +{ +lean_object* x_165; +lean_dec(x_123); +lean_dec(x_117); +lean_dec(x_115); +x_165 = lean_box(0); +x_125 = x_165; +goto block_135; +} +block_135: +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +lean_dec(x_125); +x_126 = lean_mk_syntax_ident(x_116); +x_127 = l_Array_empty___closed__1; +x_128 = lean_array_push(x_127, x_126); +x_129 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_130 = lean_array_push(x_128, x_129); +x_131 = l_Lean_mkTermIdFromIdent___closed__2; +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_130); +if (lean_is_scalar(x_124)) { + x_133 = lean_alloc_ctor(1, 1, 0); +} else { + x_133 = x_124; +} +lean_ctor_set(x_133, 0, x_132); +if (lean_is_scalar(x_122)) { + x_134 = lean_alloc_ctor(0, 2, 0); +} else { + x_134 = x_122; +} +lean_ctor_set(x_134, 0, x_133); +lean_ctor_set(x_134, 1, x_121); +return x_134; +} +} +else +{ +lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; +lean_dec(x_113); +x_166 = lean_ctor_get(x_4, 1); +lean_inc(x_166); +lean_dec(x_4); +x_167 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_168 = l_unreachable_x21___rarg(x_167); +x_169 = lean_apply_3(x_168, x_1, x_2, x_166); +return x_169; +} +} +} +} +lean_object* _init_l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__1() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 1; +x_2 = lean_box(x_1); +x_3 = x_2; +return x_3; +} +} +lean_object* _init_l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__2() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 0; +x_2 = lean_box(x_1); +x_3 = x_2; +return x_3; +} +} +lean_object* l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1(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; +x_5 = lean_array_get_size(x_2); +x_6 = lean_nat_dec_lt(x_1, x_5); +lean_dec(x_5); +if (x_6 == 0) +{ +lean_object* x_7; +lean_dec(x_3); +lean_dec(x_1); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_2); +lean_ctor_set(x_7, 1, x_4); +return x_7; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_8 = lean_array_fget(x_2, x_1); +x_9 = lean_unsigned_to_nat(0u); +x_10 = lean_array_fset(x_2, x_1, x_9); +x_11 = x_8; +x_12 = l_Lean_Expr_fvarId_x21(x_11); +lean_dec(x_11); +lean_inc(x_3); +x_13 = l_Lean_Meta_getLocalDecl(x_12, x_3, x_4); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; uint8_t x_16; uint8_t x_17; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_13, 1); +lean_inc(x_15); +lean_dec(x_13); +x_16 = l_Lean_LocalDecl_binderInfo(x_14); +lean_dec(x_14); +x_17 = l_Lean_BinderInfo_isExplicit(x_16); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_18 = lean_unsigned_to_nat(1u); +x_19 = lean_nat_add(x_1, x_18); +x_20 = l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__1; +x_21 = lean_array_fset(x_10, x_1, x_20); +lean_dec(x_1); +x_1 = x_19; +x_2 = x_21; +x_4 = x_15; +goto _start; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_unsigned_to_nat(1u); +x_24 = lean_nat_add(x_1, x_23); +x_25 = l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__2; +x_26 = lean_array_fset(x_10, x_1, x_25); +lean_dec(x_1); +x_1 = x_24; +x_2 = x_26; +x_4 = x_15; +goto _start; +} +} +else +{ +uint8_t x_28; +lean_dec(x_10); +lean_dec(x_3); +lean_dec(x_1); +x_28 = !lean_is_exclusive(x_13); +if (x_28 == 0) +{ +return x_13; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_13, 0); +x_30 = lean_ctor_get(x_13, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_13); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +return x_31; +} +} +} +} +} +lean_object* l_Lean_Delaborator_getImplicitParams___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_5 = x_1; +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1), 4, 2); +lean_closure_set(x_7, 0, x_6); +lean_closure_set(x_7, 1, x_5); +x_8 = x_7; +x_9 = lean_apply_2(x_8, x_3, x_4); +return x_9; +} +} +lean_object* _init_l_Lean_Delaborator_getImplicitParams___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_getImplicitParams___lambda__1___boxed), 4, 0); +return x_1; +} +} +lean_object* l_Lean_Delaborator_getImplicitParams(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +lean_inc(x_2); +x_4 = l_Lean_Meta_inferType(x_1, x_2, 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; +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_4, 1); +lean_inc(x_6); +lean_dec(x_4); +x_7 = l_Lean_Delaborator_getImplicitParams___closed__1; +x_8 = l_Lean_Meta_forallTelescopeReducing___rarg(x_5, x_7, x_2, x_6); +return x_8; +} +else +{ +uint8_t x_9; +lean_dec(x_2); +x_9 = !lean_is_exclusive(x_4); +if (x_9 == 0) +{ +return x_4; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_4, 0); +x_11 = lean_ctor_get(x_4, 1); +lean_inc(x_11); +lean_inc(x_10); +lean_dec(x_4); +x_12 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_12, 0, x_10); +lean_ctor_set(x_12, 1, x_11); +return x_12; +} +} +} +} +lean_object* l_Lean_Delaborator_getImplicitParams___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lean_Delaborator_getImplicitParams___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +uint8_t l_Array_anyRangeMAux___main___at_Lean_Delaborator_delabAppExplicit___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_nat_dec_lt(x_4, x_3); +if (x_5 == 0) +{ +uint8_t x_6; +lean_dec(x_4); +x_6 = 0; +return x_6; +} +else +{ +lean_object* x_7; uint8_t x_8; +x_7 = lean_array_fget(x_2, x_4); +x_8 = lean_unbox(x_7); +lean_dec(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_unsigned_to_nat(1u); +x_10 = lean_nat_add(x_4, x_9); +lean_dec(x_4); +x_4 = x_10; +goto _start; +} +else +{ +lean_dec(x_4); +return x_8; +} +} +} +} +lean_object* l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +lean_inc(x_4); +lean_inc(x_3); +x_6 = lean_apply_3(x_1, x_3, x_4, x_5); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_6, 0); +lean_dec(x_9); +x_10 = lean_box(0); +lean_ctor_set(x_6, 0, x_10); +return x_6; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_6, 1); +lean_inc(x_11); +lean_dec(x_6); +x_12 = lean_box(0); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +return x_13; +} +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_6, 1); +lean_inc(x_14); +lean_dec(x_6); +x_15 = lean_ctor_get(x_7, 0); +lean_inc(x_15); +lean_dec(x_7); +x_16 = lean_apply_4(x_2, x_15, x_3, x_4, x_14); +return x_16; +} +} +else +{ +uint8_t x_17; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_17 = !lean_is_exclusive(x_6); +if (x_17 == 0) +{ +return x_6; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_6, 0); +x_19 = lean_ctor_get(x_6, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_6); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +return x_20; +} +} +} +} +lean_object* l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2___rarg), 5, 0); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppExplicit___lambda__1___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_namedPattern___elambda__1___closed__5; +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* _init_l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_empty___closed__1; +x_2 = l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Delaborator_delabAppExplicit___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; uint8_t x_69; +x_69 = l_Lean_Expr_isConst(x_1); +if (x_69 == 0) +{ +lean_object* x_70; +lean_inc(x_3); +x_70 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_70) == 0) +{ +lean_object* x_71; lean_object* x_72; +x_71 = lean_ctor_get(x_70, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_70, 1); +lean_inc(x_72); +lean_dec(x_70); +x_5 = x_71; +x_6 = x_72; +goto block_68; +} +else +{ +uint8_t x_73; +lean_dec(x_3); +lean_dec(x_1); +x_73 = !lean_is_exclusive(x_70); +if (x_73 == 0) +{ +return x_70; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_70, 0); +x_75 = lean_ctor_get(x_70, 1); +lean_inc(x_75); +lean_inc(x_74); +lean_dec(x_70); +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; +} +} +} +else +{ +lean_object* x_77; +lean_inc(x_3); +x_77 = l_Lean_Delaborator_delabConst(x_2, x_3, x_4); +if (lean_obj_tag(x_77) == 0) +{ +lean_object* x_78; lean_object* x_79; +x_78 = lean_ctor_get(x_77, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_77, 1); +lean_inc(x_79); +lean_dec(x_77); +x_5 = x_78; +x_6 = x_79; +goto block_68; +} +else +{ +uint8_t x_80; +lean_dec(x_3); +lean_dec(x_1); +x_80 = !lean_is_exclusive(x_77); +if (x_80 == 0) +{ +return x_77; +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_81 = lean_ctor_get(x_77, 0); +x_82 = lean_ctor_get(x_77, 1); +lean_inc(x_82); +lean_inc(x_81); +lean_dec(x_77); +x_83 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_83, 0, x_81); +lean_ctor_set(x_83, 1, x_82); +return x_83; +} +} +} +block_68: +{ +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_7; lean_object* x_8; +lean_dec(x_3); +lean_dec(x_1); +x_7 = lean_box(0); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_6); +return x_8; +} +else +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_5); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_5, 0); +x_11 = l_Lean_Delaborator_getImplicitParams(x_1, x_3, x_6); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_11); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_13 = lean_ctor_get(x_11, 0); +x_14 = lean_array_get_size(x_13); +x_15 = lean_unsigned_to_nat(0u); +x_16 = l_Array_anyRangeMAux___main___at_Lean_Delaborator_delabAppExplicit___spec__1(x_13, x_13, x_14, x_15); +lean_dec(x_14); +lean_dec(x_13); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = l_Array_empty___closed__1; +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_10); +lean_ctor_set(x_18, 1, x_17); +lean_ctor_set(x_5, 0, x_18); +lean_ctor_set(x_11, 0, x_5); +return x_11; +} +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; +x_19 = l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__2; +x_20 = lean_array_push(x_19, x_10); +x_21 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_20); +x_23 = l_Array_empty___closed__1; +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +lean_ctor_set(x_5, 0, x_24); +lean_ctor_set(x_11, 0, x_5); +return x_11; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; +x_25 = lean_ctor_get(x_11, 0); +x_26 = lean_ctor_get(x_11, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_11); +x_27 = lean_array_get_size(x_25); +x_28 = lean_unsigned_to_nat(0u); +x_29 = l_Array_anyRangeMAux___main___at_Lean_Delaborator_delabAppExplicit___spec__1(x_25, x_25, x_27, x_28); +lean_dec(x_27); +lean_dec(x_25); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = l_Array_empty___closed__1; +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_10); +lean_ctor_set(x_31, 1, x_30); +lean_ctor_set(x_5, 0, x_31); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_5); +lean_ctor_set(x_32, 1, x_26); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_33 = l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__2; +x_34 = lean_array_push(x_33, x_10); +x_35 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_34); +x_37 = l_Array_empty___closed__1; +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +lean_ctor_set(x_5, 0, x_38); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_5); +lean_ctor_set(x_39, 1, x_26); +return x_39; +} +} +} +else +{ +uint8_t x_40; +lean_free_object(x_5); +lean_dec(x_10); +x_40 = !lean_is_exclusive(x_11); +if (x_40 == 0) +{ +return x_11; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_11, 0); +x_42 = lean_ctor_get(x_11, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_11); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +else +{ +lean_object* x_44; lean_object* x_45; +x_44 = lean_ctor_get(x_5, 0); +lean_inc(x_44); +lean_dec(x_5); +x_45 = l_Lean_Delaborator_getImplicitParams(x_1, x_3, x_6); +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; uint8_t x_51; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +if (lean_is_exclusive(x_45)) { + lean_ctor_release(x_45, 0); + lean_ctor_release(x_45, 1); + x_48 = x_45; +} else { + lean_dec_ref(x_45); + x_48 = lean_box(0); +} +x_49 = lean_array_get_size(x_46); +x_50 = lean_unsigned_to_nat(0u); +x_51 = l_Array_anyRangeMAux___main___at_Lean_Delaborator_delabAppExplicit___spec__1(x_46, x_46, x_49, x_50); +lean_dec(x_49); +lean_dec(x_46); +if (x_51 == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = l_Array_empty___closed__1; +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_44); +lean_ctor_set(x_53, 1, x_52); +x_54 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_54, 0, x_53); +if (lean_is_scalar(x_48)) { + x_55 = lean_alloc_ctor(0, 2, 0); +} else { + x_55 = x_48; +} +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_47); +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; +x_56 = l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__2; +x_57 = lean_array_push(x_56, x_44); +x_58 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; +x_59 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_57); +x_60 = l_Array_empty___closed__1; +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_59); +lean_ctor_set(x_61, 1, x_60); +x_62 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_62, 0, x_61); +if (lean_is_scalar(x_48)) { + x_63 = lean_alloc_ctor(0, 2, 0); +} else { + x_63 = x_48; +} +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_47); +return x_63; +} +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; +lean_dec(x_44); +x_64 = lean_ctor_get(x_45, 0); +lean_inc(x_64); +x_65 = lean_ctor_get(x_45, 1); +lean_inc(x_65); +if (lean_is_exclusive(x_45)) { + lean_ctor_release(x_45, 0); + lean_ctor_release(x_45, 1); + x_66 = x_45; +} else { + lean_dec_ref(x_45); + x_66 = lean_box(0); +} +if (lean_is_scalar(x_66)) { + x_67 = lean_alloc_ctor(1, 2, 0); +} else { + x_67 = x_66; +} +lean_ctor_set(x_67, 0, x_64); +lean_ctor_set(x_67, 1, x_65); +return x_67; +} +} +} +} +} +} +lean_object* l_Lean_Delaborator_delabAppExplicit___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_1); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = lean_ctor_get(x_1, 0); +x_7 = lean_ctor_get(x_1, 1); +x_8 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +if (lean_obj_tag(x_9) == 0) +{ +uint8_t x_10; +lean_free_object(x_1); +lean_dec(x_7); +lean_dec(x_6); +x_10 = !lean_is_exclusive(x_8); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_8, 0); +lean_dec(x_11); +x_12 = lean_box(0); +lean_ctor_set(x_8, 0, x_12); +return x_8; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_13 = lean_ctor_get(x_8, 1); +lean_inc(x_13); +lean_dec(x_8); +x_14 = lean_box(0); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_13); +return x_15; +} +} +else +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_8); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_8, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_9); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_9, 0); +x_20 = lean_array_push(x_7, x_19); +lean_ctor_set(x_1, 1, x_20); +lean_ctor_set(x_9, 0, x_1); +return x_8; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_9, 0); +lean_inc(x_21); +lean_dec(x_9); +x_22 = lean_array_push(x_7, x_21); +lean_ctor_set(x_1, 1, x_22); +x_23 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_23, 0, x_1); +lean_ctor_set(x_8, 0, x_23); +return x_8; +} +} +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; +x_24 = lean_ctor_get(x_8, 1); +lean_inc(x_24); +lean_dec(x_8); +x_25 = lean_ctor_get(x_9, 0); +lean_inc(x_25); +if (lean_is_exclusive(x_9)) { + lean_ctor_release(x_9, 0); + x_26 = x_9; +} else { + lean_dec_ref(x_9); + x_26 = lean_box(0); +} +x_27 = lean_array_push(x_7, x_25); +lean_ctor_set(x_1, 1, x_27); +if (lean_is_scalar(x_26)) { + x_28 = lean_alloc_ctor(1, 1, 0); +} else { + x_28 = x_26; +} +lean_ctor_set(x_28, 0, x_1); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_24); +return x_29; +} +} +} +else +{ +uint8_t x_30; +lean_free_object(x_1); +lean_dec(x_7); +lean_dec(x_6); +x_30 = !lean_is_exclusive(x_8); +if (x_30 == 0) +{ +return x_8; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_8, 0); +x_32 = lean_ctor_get(x_8, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_8); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +return x_33; +} +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_1, 0); +x_35 = lean_ctor_get(x_1, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_1); +x_36 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_36) == 0) +{ +lean_object* x_37; +x_37 = lean_ctor_get(x_36, 0); +lean_inc(x_37); +if (lean_obj_tag(x_37) == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_dec(x_35); +lean_dec(x_34); +x_38 = lean_ctor_get(x_36, 1); +lean_inc(x_38); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_39 = x_36; +} else { + lean_dec_ref(x_36); + x_39 = lean_box(0); +} +x_40 = lean_box(0); +if (lean_is_scalar(x_39)) { + x_41 = lean_alloc_ctor(0, 2, 0); +} else { + x_41 = x_39; +} +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_38); +return x_41; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_42 = lean_ctor_get(x_36, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_43 = x_36; +} else { + lean_dec_ref(x_36); + x_43 = lean_box(0); +} +x_44 = lean_ctor_get(x_37, 0); +lean_inc(x_44); +if (lean_is_exclusive(x_37)) { + lean_ctor_release(x_37, 0); + x_45 = x_37; +} else { + lean_dec_ref(x_37); + x_45 = lean_box(0); +} +x_46 = lean_array_push(x_35, x_44); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_34); +lean_ctor_set(x_47, 1, x_46); +if (lean_is_scalar(x_45)) { + x_48 = lean_alloc_ctor(1, 1, 0); +} else { + x_48 = x_45; +} +lean_ctor_set(x_48, 0, x_47); +if (lean_is_scalar(x_43)) { + x_49 = lean_alloc_ctor(0, 2, 0); +} else { + x_49 = x_43; +} +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_42); +return x_49; +} +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +lean_dec(x_35); +lean_dec(x_34); +x_50 = lean_ctor_get(x_36, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_36, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_52 = x_36; +} else { + lean_dec_ref(x_36); + x_52 = lean_box(0); +} +if (lean_is_scalar(x_52)) { + x_53 = lean_alloc_ctor(1, 2, 0); +} else { + x_53 = x_52; +} +lean_ctor_set(x_53, 0, x_50); +lean_ctor_set(x_53, 1, x_51); +return x_53; +} +} +} +} +lean_object* _init_l_Lean_Delaborator_delabAppExplicit___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_getExpr___boxed), 3, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppExplicit___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabAppExplicit___lambda__1), 4, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppExplicit___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Delaborator_delabAppExplicit___closed__1; +x_2 = l_Lean_Delaborator_delabAppExplicit___closed__2; +x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2___rarg), 5, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppExplicit___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabAppExplicit___lambda__2), 4, 0); +return x_1; +} +} +lean_object* l_Lean_Delaborator_delabAppExplicit(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = l_Lean_Delaborator_delabAppExplicit___closed__3; +x_5 = l_Lean_Delaborator_delabAppExplicit___closed__4; +x_6 = l_Lean_Delaborator_withAppFnArgs___main___rarg(x_4, x_5, x_1, x_2, x_3); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_6, 0); +lean_dec(x_9); +x_10 = lean_box(0); +lean_ctor_set(x_6, 0, x_10); +return x_6; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_6, 1); +lean_inc(x_11); +lean_dec(x_6); +x_12 = lean_box(0); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +return x_13; +} +} +else +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_7); +if (x_14 == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_6); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_16 = lean_ctor_get(x_7, 0); +x_17 = lean_ctor_get(x_6, 0); +lean_dec(x_17); +x_18 = lean_ctor_get(x_16, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +lean_dec(x_16); +x_20 = l_Array_isEmpty___rarg(x_19); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_21 = l_Array_empty___closed__1; +x_22 = lean_array_push(x_21, x_18); +x_23 = lean_unsigned_to_nat(0u); +x_24 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_19, x_19, x_23, x_21); +lean_dec(x_19); +x_25 = l_Lean_nullKind___closed__2; +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_24); +x_27 = lean_array_push(x_22, x_26); +x_28 = l_Lean_mkAppStx___closed__8; +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_27); +lean_ctor_set(x_7, 0, x_29); +return x_6; +} +else +{ +lean_dec(x_19); +lean_ctor_set(x_7, 0, x_18); +return x_6; +} +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; +x_30 = lean_ctor_get(x_7, 0); +x_31 = lean_ctor_get(x_6, 1); +lean_inc(x_31); +lean_dec(x_6); +x_32 = lean_ctor_get(x_30, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_30, 1); +lean_inc(x_33); +lean_dec(x_30); +x_34 = l_Array_isEmpty___rarg(x_33); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_35 = l_Array_empty___closed__1; +x_36 = lean_array_push(x_35, x_32); +x_37 = lean_unsigned_to_nat(0u); +x_38 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_33, x_33, x_37, x_35); +lean_dec(x_33); +x_39 = l_Lean_nullKind___closed__2; +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_38); +x_41 = lean_array_push(x_36, x_40); +x_42 = l_Lean_mkAppStx___closed__8; +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_41); +lean_ctor_set(x_7, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_7); +lean_ctor_set(x_44, 1, x_31); +return x_44; +} +else +{ +lean_object* x_45; +lean_dec(x_33); +lean_ctor_set(x_7, 0, x_32); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_7); +lean_ctor_set(x_45, 1, x_31); +return x_45; +} +} +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; +x_46 = lean_ctor_get(x_7, 0); +lean_inc(x_46); +lean_dec(x_7); +x_47 = lean_ctor_get(x_6, 1); +lean_inc(x_47); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + lean_ctor_release(x_6, 1); + x_48 = x_6; +} else { + lean_dec_ref(x_6); + x_48 = lean_box(0); +} +x_49 = lean_ctor_get(x_46, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_46, 1); +lean_inc(x_50); +lean_dec(x_46); +x_51 = l_Array_isEmpty___rarg(x_50); +if (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_object* x_62; +x_52 = l_Array_empty___closed__1; +x_53 = lean_array_push(x_52, x_49); +x_54 = lean_unsigned_to_nat(0u); +x_55 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_50, x_50, x_54, x_52); +lean_dec(x_50); +x_56 = l_Lean_nullKind___closed__2; +x_57 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_55); +x_58 = lean_array_push(x_53, x_57); +x_59 = l_Lean_mkAppStx___closed__8; +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_59); +lean_ctor_set(x_60, 1, x_58); +x_61 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_61, 0, x_60); +if (lean_is_scalar(x_48)) { + x_62 = lean_alloc_ctor(0, 2, 0); +} else { + x_62 = x_48; +} +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_47); +return x_62; +} +else +{ +lean_object* x_63; lean_object* x_64; +lean_dec(x_50); +x_63 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_63, 0, x_49); +if (lean_is_scalar(x_48)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_48; +} +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_47); +return x_64; +} +} +} +} +else +{ +uint8_t x_65; +x_65 = !lean_is_exclusive(x_6); +if (x_65 == 0) +{ +return x_6; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_6, 0); +x_67 = lean_ctor_get(x_6, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_6); +x_68 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +return x_68; +} +} +} +} +lean_object* l_Array_anyRangeMAux___main___at_Lean_Delaborator_delabAppExplicit___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; +x_5 = l_Array_anyRangeMAux___main___at_Lean_Delaborator_delabAppExplicit___spec__1(x_1, x_2, x_3, x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_6 = lean_box(x_5); +return x_6; +} +} +lean_object* _init_l___regBuiltin_Lean_Delaborator_delabAppExplicit___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabAppExplicit), 3, 0); +return x_1; +} +} +lean_object* l___regBuiltin_Lean_Delaborator_delabAppExplicit(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_Lean_Delaborator_delabAttribute; +x_3 = l_Lean_Delaborator_getExprKind___closed__12; +x_4 = l___regBuiltin_Lean_Delaborator_delabAppExplicit___closed__1; +x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); +return x_5; +} +} +lean_object* l_Lean_Delaborator_delabAppImplicit___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = l_Lean_Expr_isConst(x_1); +if (x_5 == 0) +{ +lean_object* x_6; +lean_inc(x_3); +x_6 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +lean_dec(x_3); +lean_dec(x_1); +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_6, 0); +lean_dec(x_9); +x_10 = lean_box(0); +lean_ctor_set(x_6, 0, x_10); +return x_6; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_6, 1); +lean_inc(x_11); +lean_dec(x_6); +x_12 = lean_box(0); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +return x_13; +} +} +else +{ +lean_object* x_14; uint8_t x_15; +x_14 = lean_ctor_get(x_6, 1); +lean_inc(x_14); +lean_dec(x_6); +x_15 = !lean_is_exclusive(x_7); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_7, 0); +x_17 = l_Lean_Delaborator_getImplicitParams(x_1, x_3, x_14); +if (lean_obj_tag(x_17) == 0) +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_17); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_19 = lean_ctor_get(x_17, 0); +x_20 = l_Array_toList___rarg(x_19); +lean_dec(x_19); +x_21 = l_Array_empty___closed__1; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_16); +lean_ctor_set(x_23, 1, x_22); +lean_ctor_set(x_7, 0, x_23); +lean_ctor_set(x_17, 0, x_7); +return x_17; +} +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; +x_24 = lean_ctor_get(x_17, 0); +x_25 = lean_ctor_get(x_17, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_17); +x_26 = l_Array_toList___rarg(x_24); +lean_dec(x_24); +x_27 = l_Array_empty___closed__1; +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_27); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_16); +lean_ctor_set(x_29, 1, x_28); +lean_ctor_set(x_7, 0, x_29); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_7); +lean_ctor_set(x_30, 1, x_25); +return x_30; +} +} +else +{ +uint8_t x_31; +lean_free_object(x_7); +lean_dec(x_16); +x_31 = !lean_is_exclusive(x_17); +if (x_31 == 0) +{ +return x_17; +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_17, 0); +x_33 = lean_ctor_get(x_17, 1); +lean_inc(x_33); +lean_inc(x_32); +lean_dec(x_17); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set(x_34, 1, x_33); +return x_34; +} +} +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_ctor_get(x_7, 0); +lean_inc(x_35); +lean_dec(x_7); +x_36 = l_Lean_Delaborator_getImplicitParams(x_1, x_3, x_14); +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; lean_object* x_44; lean_object* x_45; +x_37 = lean_ctor_get(x_36, 0); +lean_inc(x_37); +x_38 = lean_ctor_get(x_36, 1); +lean_inc(x_38); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_39 = x_36; +} else { + lean_dec_ref(x_36); + x_39 = lean_box(0); +} +x_40 = l_Array_toList___rarg(x_37); +lean_dec(x_37); +x_41 = l_Array_empty___closed__1; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set(x_42, 1, x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_35); +lean_ctor_set(x_43, 1, x_42); +x_44 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_44, 0, x_43); +if (lean_is_scalar(x_39)) { + x_45 = lean_alloc_ctor(0, 2, 0); +} else { + x_45 = x_39; +} +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_38); +return x_45; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +lean_dec(x_35); +x_46 = lean_ctor_get(x_36, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_36, 1); +lean_inc(x_47); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_48 = x_36; +} else { + lean_dec_ref(x_36); + x_48 = lean_box(0); +} +if (lean_is_scalar(x_48)) { + x_49 = lean_alloc_ctor(1, 2, 0); +} else { + x_49 = x_48; +} +lean_ctor_set(x_49, 0, x_46); +lean_ctor_set(x_49, 1, x_47); +return x_49; +} +} +} +} +else +{ +uint8_t x_50; +lean_dec(x_3); +lean_dec(x_1); +x_50 = !lean_is_exclusive(x_6); +if (x_50 == 0) +{ +return x_6; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_6, 0); +x_52 = lean_ctor_get(x_6, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_6); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; +} +} +} +else +{ +lean_object* x_54; +lean_inc(x_3); +x_54 = l_Lean_Delaborator_delabConst(x_2, x_3, x_4); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +if (lean_obj_tag(x_55) == 0) +{ +uint8_t x_56; +lean_dec(x_3); +lean_dec(x_1); +x_56 = !lean_is_exclusive(x_54); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; +x_57 = lean_ctor_get(x_54, 0); +lean_dec(x_57); +x_58 = lean_box(0); +lean_ctor_set(x_54, 0, x_58); +return x_54; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_54, 1); +lean_inc(x_59); +lean_dec(x_54); +x_60 = lean_box(0); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_59); +return x_61; +} +} +else +{ +lean_object* x_62; uint8_t x_63; +x_62 = lean_ctor_get(x_54, 1); +lean_inc(x_62); +lean_dec(x_54); +x_63 = !lean_is_exclusive(x_55); +if (x_63 == 0) +{ +lean_object* x_64; lean_object* x_65; +x_64 = lean_ctor_get(x_55, 0); +x_65 = l_Lean_Delaborator_getImplicitParams(x_1, x_3, x_62); +if (lean_obj_tag(x_65) == 0) +{ +uint8_t x_66; +x_66 = !lean_is_exclusive(x_65); +if (x_66 == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_67 = lean_ctor_get(x_65, 0); +x_68 = l_Array_toList___rarg(x_67); +lean_dec(x_67); +x_69 = l_Array_empty___closed__1; +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_68); +lean_ctor_set(x_70, 1, x_69); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_64); +lean_ctor_set(x_71, 1, x_70); +lean_ctor_set(x_55, 0, x_71); +lean_ctor_set(x_65, 0, x_55); +return x_65; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_72 = lean_ctor_get(x_65, 0); +x_73 = lean_ctor_get(x_65, 1); +lean_inc(x_73); +lean_inc(x_72); +lean_dec(x_65); +x_74 = l_Array_toList___rarg(x_72); +lean_dec(x_72); +x_75 = l_Array_empty___closed__1; +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_64); +lean_ctor_set(x_77, 1, x_76); +lean_ctor_set(x_55, 0, x_77); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_55); +lean_ctor_set(x_78, 1, x_73); +return x_78; +} +} +else +{ +uint8_t x_79; +lean_free_object(x_55); +lean_dec(x_64); +x_79 = !lean_is_exclusive(x_65); +if (x_79 == 0) +{ +return x_65; +} +else +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_80 = lean_ctor_get(x_65, 0); +x_81 = lean_ctor_get(x_65, 1); +lean_inc(x_81); +lean_inc(x_80); +lean_dec(x_65); +x_82 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_82, 0, x_80); +lean_ctor_set(x_82, 1, x_81); +return x_82; +} +} +} +else +{ +lean_object* x_83; lean_object* x_84; +x_83 = lean_ctor_get(x_55, 0); +lean_inc(x_83); +lean_dec(x_55); +x_84 = l_Lean_Delaborator_getImplicitParams(x_1, x_3, x_62); +if (lean_obj_tag(x_84) == 0) +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_85 = lean_ctor_get(x_84, 0); +lean_inc(x_85); +x_86 = lean_ctor_get(x_84, 1); +lean_inc(x_86); +if (lean_is_exclusive(x_84)) { + lean_ctor_release(x_84, 0); + lean_ctor_release(x_84, 1); + x_87 = x_84; +} else { + lean_dec_ref(x_84); + x_87 = lean_box(0); +} +x_88 = l_Array_toList___rarg(x_85); +lean_dec(x_85); +x_89 = l_Array_empty___closed__1; +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_88); +lean_ctor_set(x_90, 1, x_89); +x_91 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_91, 0, x_83); +lean_ctor_set(x_91, 1, x_90); +x_92 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_92, 0, x_91); +if (lean_is_scalar(x_87)) { + x_93 = lean_alloc_ctor(0, 2, 0); +} else { + x_93 = x_87; +} +lean_ctor_set(x_93, 0, x_92); +lean_ctor_set(x_93, 1, x_86); +return x_93; +} +else +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +lean_dec(x_83); +x_94 = lean_ctor_get(x_84, 0); +lean_inc(x_94); +x_95 = lean_ctor_get(x_84, 1); +lean_inc(x_95); +if (lean_is_exclusive(x_84)) { + lean_ctor_release(x_84, 0); + lean_ctor_release(x_84, 1); + x_96 = x_84; +} else { + lean_dec_ref(x_84); + x_96 = lean_box(0); +} +if (lean_is_scalar(x_96)) { + x_97 = lean_alloc_ctor(1, 2, 0); +} else { + x_97 = x_96; +} +lean_ctor_set(x_97, 0, x_94); +lean_ctor_set(x_97, 1, x_95); +return x_97; +} +} +} +} +else +{ +uint8_t x_98; +lean_dec(x_3); +lean_dec(x_1); +x_98 = !lean_is_exclusive(x_54); +if (x_98 == 0) +{ +return x_54; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_54, 0); +x_100 = lean_ctor_get(x_54, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_54); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +return x_101; +} +} +} +} +} +lean_object* l_Lean_Delaborator_delabAppImplicit___lambda__2(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; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_1); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_dec(x_9); +x_10 = !lean_is_exclusive(x_5); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_5, 1); +x_12 = lean_ctor_get(x_5, 0); +lean_dec(x_12); +x_13 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +lean_free_object(x_5); +lean_dec(x_11); +lean_free_object(x_1); +lean_dec(x_8); +x_15 = !lean_is_exclusive(x_13); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_13, 0); +lean_dec(x_16); +x_17 = lean_box(0); +lean_ctor_set(x_13, 0, x_17); +return x_13; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_13, 1); +lean_inc(x_18); +lean_dec(x_13); +x_19 = lean_box(0); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_18); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_13); +if (x_21 == 0) +{ +lean_object* x_22; uint8_t x_23; +x_22 = lean_ctor_get(x_13, 0); +lean_dec(x_22); +x_23 = !lean_is_exclusive(x_14); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_14, 0); +x_25 = l_List_tailD___rarg(x_6, x_6); +x_26 = lean_array_push(x_11, x_24); +lean_ctor_set(x_5, 1, x_26); +lean_ctor_set(x_5, 0, x_25); +lean_ctor_set(x_14, 0, x_1); +return x_13; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_27 = lean_ctor_get(x_14, 0); +lean_inc(x_27); +lean_dec(x_14); +x_28 = l_List_tailD___rarg(x_6, x_6); +x_29 = lean_array_push(x_11, x_27); +lean_ctor_set(x_5, 1, x_29); +lean_ctor_set(x_5, 0, x_28); +x_30 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_30, 0, x_1); +lean_ctor_set(x_13, 0, x_30); +return x_13; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_31 = lean_ctor_get(x_13, 1); +lean_inc(x_31); +lean_dec(x_13); +x_32 = lean_ctor_get(x_14, 0); +lean_inc(x_32); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + x_33 = x_14; +} else { + lean_dec_ref(x_14); + x_33 = lean_box(0); +} +x_34 = l_List_tailD___rarg(x_6, x_6); +x_35 = lean_array_push(x_11, x_32); +lean_ctor_set(x_5, 1, x_35); +lean_ctor_set(x_5, 0, x_34); +if (lean_is_scalar(x_33)) { + x_36 = lean_alloc_ctor(1, 1, 0); +} else { + x_36 = x_33; +} +lean_ctor_set(x_36, 0, x_1); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_31); +return x_37; +} +} +} +else +{ +uint8_t x_38; +lean_free_object(x_5); +lean_dec(x_11); +lean_free_object(x_1); +lean_dec(x_8); +x_38 = !lean_is_exclusive(x_13); +if (x_38 == 0) +{ +return x_13; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_39 = lean_ctor_get(x_13, 0); +x_40 = lean_ctor_get(x_13, 1); +lean_inc(x_40); +lean_inc(x_39); +lean_dec(x_13); +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set(x_41, 1, x_40); +return x_41; +} +} +} +else +{ +lean_object* x_42; lean_object* x_43; +x_42 = lean_ctor_get(x_5, 1); +lean_inc(x_42); +lean_dec(x_5); +x_43 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_43) == 0) +{ +lean_object* x_44; +x_44 = lean_ctor_get(x_43, 0); +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_dec(x_42); +lean_free_object(x_1); +lean_dec(x_8); +x_45 = lean_ctor_get(x_43, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_46 = x_43; +} else { + lean_dec_ref(x_43); + x_46 = lean_box(0); +} +x_47 = lean_box(0); +if (lean_is_scalar(x_46)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_46; +} +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_45); +return x_48; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_49 = lean_ctor_get(x_43, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_50 = x_43; +} else { + lean_dec_ref(x_43); + x_50 = lean_box(0); +} +x_51 = lean_ctor_get(x_44, 0); +lean_inc(x_51); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + x_52 = x_44; +} else { + lean_dec_ref(x_44); + x_52 = lean_box(0); +} +x_53 = l_List_tailD___rarg(x_6, x_6); +x_54 = lean_array_push(x_42, x_51); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +lean_ctor_set(x_1, 1, x_55); +if (lean_is_scalar(x_52)) { + x_56 = lean_alloc_ctor(1, 1, 0); +} else { + x_56 = x_52; +} +lean_ctor_set(x_56, 0, x_1); +if (lean_is_scalar(x_50)) { + x_57 = lean_alloc_ctor(0, 2, 0); +} else { + x_57 = x_50; +} +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_49); +return x_57; +} +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +lean_dec(x_42); +lean_free_object(x_1); +lean_dec(x_8); +x_58 = lean_ctor_get(x_43, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_43, 1); +lean_inc(x_59); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_60 = x_43; +} else { + lean_dec_ref(x_43); + x_60 = lean_box(0); +} +if (lean_is_scalar(x_60)) { + x_61 = lean_alloc_ctor(1, 2, 0); +} else { + x_61 = x_60; +} +lean_ctor_set(x_61, 0, x_58); +lean_ctor_set(x_61, 1, x_59); +return x_61; +} +} +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_62 = lean_ctor_get(x_1, 0); +lean_inc(x_62); +lean_dec(x_1); +x_63 = lean_ctor_get(x_5, 1); +lean_inc(x_63); +if (lean_is_exclusive(x_5)) { + lean_ctor_release(x_5, 0); + lean_ctor_release(x_5, 1); + x_64 = x_5; +} else { + lean_dec_ref(x_5); + x_64 = lean_box(0); +} +x_65 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; +x_66 = lean_ctor_get(x_65, 0); +lean_inc(x_66); +if (lean_obj_tag(x_66) == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_dec(x_64); +lean_dec(x_63); +lean_dec(x_62); +x_67 = lean_ctor_get(x_65, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_68 = x_65; +} else { + lean_dec_ref(x_65); + x_68 = lean_box(0); +} +x_69 = lean_box(0); +if (lean_is_scalar(x_68)) { + x_70 = lean_alloc_ctor(0, 2, 0); +} else { + x_70 = x_68; +} +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +return x_70; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_71 = lean_ctor_get(x_65, 1); +lean_inc(x_71); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_72 = x_65; +} else { + lean_dec_ref(x_65); + x_72 = lean_box(0); +} +x_73 = lean_ctor_get(x_66, 0); +lean_inc(x_73); +if (lean_is_exclusive(x_66)) { + lean_ctor_release(x_66, 0); + x_74 = x_66; +} else { + lean_dec_ref(x_66); + x_74 = lean_box(0); +} +x_75 = l_List_tailD___rarg(x_6, x_6); +x_76 = lean_array_push(x_63, x_73); +if (lean_is_scalar(x_64)) { + x_77 = lean_alloc_ctor(0, 2, 0); +} else { + x_77 = x_64; +} +lean_ctor_set(x_77, 0, x_75); +lean_ctor_set(x_77, 1, x_76); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_62); +lean_ctor_set(x_78, 1, x_77); +if (lean_is_scalar(x_74)) { + x_79 = lean_alloc_ctor(1, 1, 0); +} else { + x_79 = x_74; +} +lean_ctor_set(x_79, 0, x_78); +if (lean_is_scalar(x_72)) { + x_80 = lean_alloc_ctor(0, 2, 0); +} else { + x_80 = x_72; +} +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_71); +return x_80; +} +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; +lean_dec(x_64); +lean_dec(x_63); +lean_dec(x_62); +x_81 = lean_ctor_get(x_65, 0); +lean_inc(x_81); +x_82 = lean_ctor_get(x_65, 1); +lean_inc(x_82); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_83 = x_65; +} else { + lean_dec_ref(x_65); + x_83 = lean_box(0); +} +if (lean_is_scalar(x_83)) { + x_84 = lean_alloc_ctor(1, 2, 0); +} else { + x_84 = x_83; +} +lean_ctor_set(x_84, 0, x_81); +lean_ctor_set(x_84, 1, x_82); +return x_84; +} +} +} +else +{ +lean_object* x_85; uint8_t x_86; +x_85 = lean_ctor_get(x_6, 0); +lean_inc(x_85); +x_86 = lean_unbox(x_85); +lean_dec(x_85); +if (x_86 == 0) +{ +uint8_t x_87; +x_87 = !lean_is_exclusive(x_1); +if (x_87 == 0) +{ +lean_object* x_88; lean_object* x_89; uint8_t x_90; +x_88 = lean_ctor_get(x_1, 0); +x_89 = lean_ctor_get(x_1, 1); +lean_dec(x_89); +x_90 = !lean_is_exclusive(x_5); +if (x_90 == 0) +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_91 = lean_ctor_get(x_5, 1); +x_92 = lean_ctor_get(x_5, 0); +lean_dec(x_92); +x_93 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_93) == 0) +{ +lean_object* x_94; +x_94 = lean_ctor_get(x_93, 0); +lean_inc(x_94); +if (lean_obj_tag(x_94) == 0) +{ +uint8_t x_95; +lean_free_object(x_5); +lean_dec(x_91); +lean_free_object(x_1); +lean_dec(x_88); +lean_dec(x_6); +x_95 = !lean_is_exclusive(x_93); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; +x_96 = lean_ctor_get(x_93, 0); +lean_dec(x_96); +x_97 = lean_box(0); +lean_ctor_set(x_93, 0, x_97); +return x_93; +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_98 = lean_ctor_get(x_93, 1); +lean_inc(x_98); +lean_dec(x_93); +x_99 = lean_box(0); +x_100 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_100, 0, x_99); +lean_ctor_set(x_100, 1, x_98); +return x_100; +} +} +else +{ +uint8_t x_101; +x_101 = !lean_is_exclusive(x_93); +if (x_101 == 0) +{ +lean_object* x_102; uint8_t x_103; +x_102 = lean_ctor_get(x_93, 0); +lean_dec(x_102); +x_103 = !lean_is_exclusive(x_94); +if (x_103 == 0) +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_104 = lean_ctor_get(x_94, 0); +x_105 = lean_box(0); +x_106 = l_List_tailD___rarg(x_6, x_105); +lean_dec(x_6); +x_107 = lean_array_push(x_91, x_104); +lean_ctor_set(x_5, 1, x_107); +lean_ctor_set(x_5, 0, x_106); +lean_ctor_set(x_94, 0, x_1); +return x_93; +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_108 = lean_ctor_get(x_94, 0); +lean_inc(x_108); +lean_dec(x_94); +x_109 = lean_box(0); +x_110 = l_List_tailD___rarg(x_6, x_109); +lean_dec(x_6); +x_111 = lean_array_push(x_91, x_108); +lean_ctor_set(x_5, 1, x_111); +lean_ctor_set(x_5, 0, x_110); +x_112 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_112, 0, x_1); +lean_ctor_set(x_93, 0, x_112); +return x_93; +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_113 = lean_ctor_get(x_93, 1); +lean_inc(x_113); +lean_dec(x_93); +x_114 = lean_ctor_get(x_94, 0); +lean_inc(x_114); +if (lean_is_exclusive(x_94)) { + lean_ctor_release(x_94, 0); + x_115 = x_94; +} else { + lean_dec_ref(x_94); + x_115 = lean_box(0); +} +x_116 = lean_box(0); +x_117 = l_List_tailD___rarg(x_6, x_116); +lean_dec(x_6); +x_118 = lean_array_push(x_91, x_114); +lean_ctor_set(x_5, 1, x_118); +lean_ctor_set(x_5, 0, x_117); +if (lean_is_scalar(x_115)) { + x_119 = lean_alloc_ctor(1, 1, 0); +} else { + x_119 = x_115; +} +lean_ctor_set(x_119, 0, x_1); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +return x_120; +} +} +} +else +{ +uint8_t x_121; +lean_free_object(x_5); +lean_dec(x_91); +lean_free_object(x_1); +lean_dec(x_88); +lean_dec(x_6); +x_121 = !lean_is_exclusive(x_93); +if (x_121 == 0) +{ +return x_93; +} +else +{ +lean_object* x_122; lean_object* x_123; lean_object* x_124; +x_122 = lean_ctor_get(x_93, 0); +x_123 = lean_ctor_get(x_93, 1); +lean_inc(x_123); +lean_inc(x_122); +lean_dec(x_93); +x_124 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_124, 0, x_122); +lean_ctor_set(x_124, 1, x_123); +return x_124; +} +} +} +else +{ +lean_object* x_125; lean_object* x_126; +x_125 = lean_ctor_get(x_5, 1); +lean_inc(x_125); +lean_dec(x_5); +x_126 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_126) == 0) +{ +lean_object* x_127; +x_127 = lean_ctor_get(x_126, 0); +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_dec(x_125); +lean_free_object(x_1); +lean_dec(x_88); +lean_dec(x_6); +x_128 = lean_ctor_get(x_126, 1); +lean_inc(x_128); +if (lean_is_exclusive(x_126)) { + lean_ctor_release(x_126, 0); + lean_ctor_release(x_126, 1); + x_129 = x_126; +} else { + lean_dec_ref(x_126); + x_129 = lean_box(0); +} +x_130 = lean_box(0); +if (lean_is_scalar(x_129)) { + x_131 = lean_alloc_ctor(0, 2, 0); +} else { + x_131 = x_129; +} +lean_ctor_set(x_131, 0, x_130); +lean_ctor_set(x_131, 1, x_128); +return x_131; +} +else +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +x_132 = lean_ctor_get(x_126, 1); +lean_inc(x_132); +if (lean_is_exclusive(x_126)) { + lean_ctor_release(x_126, 0); + lean_ctor_release(x_126, 1); + x_133 = x_126; +} else { + lean_dec_ref(x_126); + x_133 = lean_box(0); +} +x_134 = lean_ctor_get(x_127, 0); +lean_inc(x_134); +if (lean_is_exclusive(x_127)) { + lean_ctor_release(x_127, 0); + x_135 = x_127; +} else { + lean_dec_ref(x_127); + x_135 = lean_box(0); +} +x_136 = lean_box(0); +x_137 = l_List_tailD___rarg(x_6, x_136); +lean_dec(x_6); +x_138 = lean_array_push(x_125, x_134); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_137); +lean_ctor_set(x_139, 1, x_138); +lean_ctor_set(x_1, 1, x_139); +if (lean_is_scalar(x_135)) { + x_140 = lean_alloc_ctor(1, 1, 0); +} else { + x_140 = x_135; +} +lean_ctor_set(x_140, 0, x_1); +if (lean_is_scalar(x_133)) { + x_141 = lean_alloc_ctor(0, 2, 0); +} else { + x_141 = x_133; +} +lean_ctor_set(x_141, 0, x_140); +lean_ctor_set(x_141, 1, x_132); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; +lean_dec(x_125); +lean_free_object(x_1); +lean_dec(x_88); +lean_dec(x_6); +x_142 = lean_ctor_get(x_126, 0); +lean_inc(x_142); +x_143 = lean_ctor_get(x_126, 1); +lean_inc(x_143); +if (lean_is_exclusive(x_126)) { + lean_ctor_release(x_126, 0); + lean_ctor_release(x_126, 1); + x_144 = x_126; +} else { + lean_dec_ref(x_126); + x_144 = lean_box(0); +} +if (lean_is_scalar(x_144)) { + x_145 = lean_alloc_ctor(1, 2, 0); +} else { + x_145 = x_144; +} +lean_ctor_set(x_145, 0, x_142); +lean_ctor_set(x_145, 1, x_143); +return x_145; +} +} +} +else +{ +lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; +x_146 = lean_ctor_get(x_1, 0); +lean_inc(x_146); +lean_dec(x_1); +x_147 = lean_ctor_get(x_5, 1); +lean_inc(x_147); +if (lean_is_exclusive(x_5)) { + lean_ctor_release(x_5, 0); + lean_ctor_release(x_5, 1); + x_148 = x_5; +} else { + lean_dec_ref(x_5); + x_148 = lean_box(0); +} +x_149 = l_Lean_Delaborator_delab(x_2, x_3, x_4); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; +x_150 = lean_ctor_get(x_149, 0); +lean_inc(x_150); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; +lean_dec(x_148); +lean_dec(x_147); +lean_dec(x_146); +lean_dec(x_6); +x_151 = lean_ctor_get(x_149, 1); +lean_inc(x_151); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_152 = x_149; +} else { + lean_dec_ref(x_149); + x_152 = lean_box(0); +} +x_153 = lean_box(0); +if (lean_is_scalar(x_152)) { + x_154 = lean_alloc_ctor(0, 2, 0); +} else { + x_154 = x_152; +} +lean_ctor_set(x_154, 0, x_153); +lean_ctor_set(x_154, 1, x_151); +return x_154; +} +else +{ +lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; +x_155 = lean_ctor_get(x_149, 1); +lean_inc(x_155); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_156 = x_149; +} else { + lean_dec_ref(x_149); + x_156 = lean_box(0); +} +x_157 = lean_ctor_get(x_150, 0); +lean_inc(x_157); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + x_158 = x_150; +} else { + lean_dec_ref(x_150); + x_158 = lean_box(0); +} +x_159 = lean_box(0); +x_160 = l_List_tailD___rarg(x_6, x_159); +lean_dec(x_6); +x_161 = lean_array_push(x_147, x_157); +if (lean_is_scalar(x_148)) { + x_162 = lean_alloc_ctor(0, 2, 0); +} else { + x_162 = x_148; +} +lean_ctor_set(x_162, 0, x_160); +lean_ctor_set(x_162, 1, x_161); +x_163 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_163, 0, x_146); +lean_ctor_set(x_163, 1, x_162); +if (lean_is_scalar(x_158)) { + x_164 = lean_alloc_ctor(1, 1, 0); +} else { + x_164 = x_158; +} +lean_ctor_set(x_164, 0, x_163); +if (lean_is_scalar(x_156)) { + x_165 = lean_alloc_ctor(0, 2, 0); +} else { + x_165 = x_156; +} +lean_ctor_set(x_165, 0, x_164); +lean_ctor_set(x_165, 1, x_155); +return x_165; +} +} +else +{ +lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; +lean_dec(x_148); +lean_dec(x_147); +lean_dec(x_146); +lean_dec(x_6); +x_166 = lean_ctor_get(x_149, 0); +lean_inc(x_166); +x_167 = lean_ctor_get(x_149, 1); +lean_inc(x_167); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_168 = x_149; +} else { + lean_dec_ref(x_149); + x_168 = lean_box(0); +} +if (lean_is_scalar(x_168)) { + x_169 = lean_alloc_ctor(1, 2, 0); +} else { + x_169 = x_168; +} +lean_ctor_set(x_169, 0, x_166); +lean_ctor_set(x_169, 1, x_167); +return x_169; +} +} +} +else +{ +uint8_t x_170; +lean_dec(x_3); +lean_dec(x_2); +x_170 = !lean_is_exclusive(x_1); +if (x_170 == 0) +{ +lean_object* x_171; uint8_t x_172; +x_171 = lean_ctor_get(x_1, 1); +lean_dec(x_171); +x_172 = !lean_is_exclusive(x_5); +if (x_172 == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; +x_173 = lean_ctor_get(x_5, 0); +lean_dec(x_173); +x_174 = lean_ctor_get(x_6, 1); +lean_inc(x_174); +lean_dec(x_6); +lean_ctor_set(x_5, 0, x_174); +x_175 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_175, 0, x_1); +x_176 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_176, 0, x_175); +lean_ctor_set(x_176, 1, x_4); +return x_176; +} +else +{ +lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_177 = lean_ctor_get(x_5, 1); +lean_inc(x_177); +lean_dec(x_5); +x_178 = lean_ctor_get(x_6, 1); +lean_inc(x_178); +lean_dec(x_6); +x_179 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_179, 0, x_178); +lean_ctor_set(x_179, 1, x_177); +lean_ctor_set(x_1, 1, x_179); +x_180 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_180, 0, x_1); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_4); +return x_181; +} +} +else +{ +lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; +x_182 = lean_ctor_get(x_1, 0); +lean_inc(x_182); +lean_dec(x_1); +x_183 = lean_ctor_get(x_5, 1); +lean_inc(x_183); +if (lean_is_exclusive(x_5)) { + lean_ctor_release(x_5, 0); + lean_ctor_release(x_5, 1); + x_184 = x_5; +} else { + lean_dec_ref(x_5); + x_184 = lean_box(0); +} +x_185 = lean_ctor_get(x_6, 1); +lean_inc(x_185); +lean_dec(x_6); +if (lean_is_scalar(x_184)) { + x_186 = lean_alloc_ctor(0, 2, 0); +} else { + x_186 = x_184; +} +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_183); +x_187 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_187, 0, x_182); +lean_ctor_set(x_187, 1, x_186); +x_188 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_188, 0, x_187); +x_189 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_189, 0, x_188); +lean_ctor_set(x_189, 1, x_4); +return x_189; +} +} +} +} +} +lean_object* l_Lean_Delaborator_delabAppImplicit___lambda__3(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; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +x_6 = lean_ctor_get(x_1, 0); +lean_inc(x_6); +lean_dec(x_1); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +lean_dec(x_5); +x_8 = l_Array_isEmpty___rarg(x_7); +if (x_8 == 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; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_9 = l_Array_empty___closed__1; +x_10 = lean_array_push(x_9, x_6); +x_11 = lean_unsigned_to_nat(0u); +x_12 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_7, x_7, x_11, x_9); +lean_dec(x_7); +x_13 = l_Lean_nullKind___closed__2; +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_12); +x_15 = lean_array_push(x_10, x_14); +x_16 = l_Lean_mkAppStx___closed__8; +x_17 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +x_18 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_18, 0, x_17); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_4); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; +lean_dec(x_7); +x_20 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_20, 0, x_6); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_4); +return x_21; +} +} +} +lean_object* _init_l_Lean_Delaborator_delabAppImplicit___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabAppImplicit___lambda__1), 4, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppImplicit___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Delaborator_delabAppExplicit___closed__1; +x_2 = l_Lean_Delaborator_delabAppImplicit___closed__1; +x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2___rarg), 5, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppImplicit___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabAppImplicit___lambda__2), 4, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppImplicit___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Delaborator_delabAppImplicit___closed__2; +x_2 = l_Lean_Delaborator_delabAppImplicit___closed__3; +x_3 = lean_alloc_closure((void*)(l_Lean_Delaborator_withAppFnArgs___rarg), 5, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppImplicit___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabAppImplicit___lambda__3___boxed), 4, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppImplicit___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Delaborator_delabAppImplicit___closed__4; +x_2 = l_Lean_Delaborator_delabAppImplicit___closed__5; +x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2___rarg), 5, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Delaborator_delabAppImplicit___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_getPPExplicit___boxed), 1, 0); +return x_1; +} +} +lean_object* l_Lean_Delaborator_delabAppImplicit(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = l_Lean_Delaborator_delabAppImplicit___closed__7; +x_5 = l_Lean_Delaborator_delabAppImplicit___closed__6; +x_6 = l_Lean_Delaborator_whenNotPPOption(x_4, x_5, x_1, x_2, x_3); +return x_6; +} +} +lean_object* l_Lean_Delaborator_delabAppImplicit___lambda__3___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_Delaborator_delabAppImplicit___lambda__3(x_1, x_2, x_3, x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_5; +} +} +lean_object* _init_l___regBuiltin_Lean_Delaborator_delabAppImplicit___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabAppImplicit), 3, 0); +return x_1; +} +} +lean_object* l___regBuiltin_Lean_Delaborator_delabAppImplicit(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_Lean_Delaborator_delabAttribute; +x_3 = l_Lean_Delaborator_getExprKind___closed__12; +x_4 = l___regBuiltin_Lean_Delaborator_delabAppImplicit___closed__1; +x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); +return x_5; +} +} +lean_object* _init_l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_getPPBinderTypes___boxed), 1, 0); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__1; +x_2 = lean_alloc_closure((void*)(l_Lean_Delaborator_getPPOption___boxed), 4, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 0; +x_2 = lean_box(x_1); +x_3 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_3, 0, x_2); +return x_3; +} +} +lean_object* l___private_Init_Lean_Delaborator_1__shouldGroupWithNext(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_4 = l_Lean_Delaborator_getExpr(x_1, x_2, x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_4, 1); +lean_inc(x_6); +lean_dec(x_4); +x_7 = lean_ctor_get(x_5, 0); +lean_inc(x_7); +lean_dec(x_5); +x_8 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__1; +lean_inc(x_1); +x_9 = l_Lean_Delaborator_getPPOption(x_8, x_1, x_2, x_6); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +switch (lean_obj_tag(x_7)) { +case 6: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_7, 2); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 6) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_9); +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_9, 1); +x_14 = lean_ctor_get(x_9, 0); +lean_dec(x_14); +x_15 = lean_ctor_get(x_10, 0); +lean_inc(x_15); +lean_dec(x_10); +x_16 = l_Lean_Meta_mkAuxName___closed__1; +x_17 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__2; +x_18 = l_Lean_Delaborator_withBindingBody___rarg(x_16, x_17, x_1, x_2, x_13); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +uint8_t x_20; +lean_dec(x_15); +lean_free_object(x_9); +lean_dec(x_11); +lean_dec(x_7); +x_20 = !lean_is_exclusive(x_18); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_18, 0); +lean_dec(x_21); +x_22 = lean_box(0); +lean_ctor_set(x_18, 0, x_22); +return x_18; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_18, 1); +lean_inc(x_23); +lean_dec(x_18); +x_24 = lean_box(0); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_23); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; uint8_t x_31; uint8_t x_32; uint8_t x_43; +x_26 = lean_ctor_get(x_18, 1); +lean_inc(x_26); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + lean_ctor_release(x_18, 1); + x_27 = x_18; +} else { + lean_dec_ref(x_18); + x_27 = lean_box(0); +} +x_28 = lean_ctor_get(x_19, 0); +lean_inc(x_28); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + x_29 = x_19; +} else { + lean_dec_ref(x_19); + x_29 = lean_box(0); +} +x_30 = l_Lean_Expr_binderInfo(x_7); +x_31 = l_Lean_Expr_binderInfo(x_11); +x_43 = l_Lean_BinderInfo_beq(x_30, x_31); +if (x_43 == 0) +{ +lean_object* x_44; +lean_dec(x_29); +lean_dec(x_28); +lean_dec(x_27); +lean_dec(x_15); +lean_dec(x_11); +lean_dec(x_7); +x_44 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +lean_ctor_set(x_9, 1, x_26); +lean_ctor_set(x_9, 0, x_44); +return x_9; +} +else +{ +lean_object* x_45; lean_object* x_46; uint8_t x_47; +x_45 = l_Lean_Expr_bindingDomain_x21(x_7); +lean_dec(x_7); +x_46 = l_Lean_Expr_bindingDomain_x21(x_11); +lean_dec(x_11); +x_47 = lean_expr_eqv(x_45, x_46); +lean_dec(x_46); +lean_dec(x_45); +if (x_47 == 0) +{ +lean_object* x_48; +lean_dec(x_29); +lean_dec(x_28); +lean_dec(x_27); +lean_dec(x_15); +x_48 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +lean_ctor_set(x_9, 1, x_26); +lean_ctor_set(x_9, 0, x_48); +return x_9; +} +else +{ +uint8_t x_49; uint8_t x_50; +x_49 = 3; +x_50 = l_Lean_BinderInfo_beq(x_31, x_49); +if (x_50 == 0) +{ +uint8_t x_51; +lean_free_object(x_9); +x_51 = lean_unbox(x_15); +lean_dec(x_15); +if (x_51 == 0) +{ +uint8_t x_52; +x_52 = lean_unbox(x_28); +if (x_52 == 0) +{ +uint8_t x_53; +x_53 = 1; +x_32 = x_53; +goto block_42; +} +else +{ +uint8_t x_54; +x_54 = 0; +x_32 = x_54; +goto block_42; +} +} +else +{ +uint8_t x_55; +x_55 = lean_unbox(x_28); +if (x_55 == 0) +{ +uint8_t x_56; +x_56 = 0; +x_32 = x_56; +goto block_42; +} +else +{ +uint8_t x_57; +x_57 = 1; +x_32 = x_57; +goto block_42; +} +} +} +else +{ +lean_object* x_58; +lean_dec(x_29); +lean_dec(x_28); +lean_dec(x_27); +lean_dec(x_15); +x_58 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +lean_ctor_set(x_9, 1, x_26); +lean_ctor_set(x_9, 0, x_58); +return x_9; +} +} +} +block_42: +{ +if (x_32 == 0) +{ +lean_object* x_33; lean_object* x_34; +lean_dec(x_29); +lean_dec(x_28); +x_33 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +if (lean_is_scalar(x_27)) { + x_34 = lean_alloc_ctor(0, 2, 0); +} else { + x_34 = x_27; +} +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_26); +return x_34; +} +else +{ +uint8_t x_35; uint8_t x_36; +x_35 = 0; +x_36 = l_Lean_BinderInfo_beq(x_31, x_35); +if (x_36 == 0) +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +lean_dec(x_28); +x_37 = lean_box(x_32); +if (lean_is_scalar(x_29)) { + x_38 = lean_alloc_ctor(1, 1, 0); +} else { + x_38 = x_29; +} +lean_ctor_set(x_38, 0, x_37); +if (lean_is_scalar(x_27)) { + x_39 = lean_alloc_ctor(0, 2, 0); +} else { + x_39 = x_27; +} +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_26); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; +if (lean_is_scalar(x_29)) { + x_40 = lean_alloc_ctor(1, 1, 0); +} else { + x_40 = x_29; +} +lean_ctor_set(x_40, 0, x_28); +if (lean_is_scalar(x_27)) { + x_41 = lean_alloc_ctor(0, 2, 0); +} else { + x_41 = x_27; +} +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_26); +return x_41; +} +} +} +} +} +else +{ +uint8_t x_59; +lean_dec(x_15); +lean_free_object(x_9); +lean_dec(x_11); +lean_dec(x_7); +x_59 = !lean_is_exclusive(x_18); +if (x_59 == 0) +{ +return x_18; +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_60 = lean_ctor_get(x_18, 0); +x_61 = lean_ctor_get(x_18, 1); +lean_inc(x_61); +lean_inc(x_60); +lean_dec(x_18); +x_62 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set(x_62, 1, x_61); +return x_62; +} +} +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_63 = lean_ctor_get(x_9, 1); +lean_inc(x_63); +lean_dec(x_9); +x_64 = lean_ctor_get(x_10, 0); +lean_inc(x_64); +lean_dec(x_10); +x_65 = l_Lean_Meta_mkAuxName___closed__1; +x_66 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__2; +x_67 = l_Lean_Delaborator_withBindingBody___rarg(x_65, x_66, x_1, x_2, x_63); +if (lean_obj_tag(x_67) == 0) +{ +lean_object* x_68; +x_68 = lean_ctor_get(x_67, 0); +lean_inc(x_68); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +lean_dec(x_64); +lean_dec(x_11); +lean_dec(x_7); +x_69 = lean_ctor_get(x_67, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_70 = x_67; +} else { + lean_dec_ref(x_67); + x_70 = lean_box(0); +} +x_71 = lean_box(0); +if (lean_is_scalar(x_70)) { + x_72 = lean_alloc_ctor(0, 2, 0); +} else { + x_72 = x_70; +} +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_69); +return x_72; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; uint8_t x_77; uint8_t x_78; uint8_t x_79; uint8_t x_90; +x_73 = lean_ctor_get(x_67, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_74 = x_67; +} else { + lean_dec_ref(x_67); + x_74 = lean_box(0); +} +x_75 = lean_ctor_get(x_68, 0); +lean_inc(x_75); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + x_76 = x_68; +} else { + lean_dec_ref(x_68); + x_76 = lean_box(0); +} +x_77 = l_Lean_Expr_binderInfo(x_7); +x_78 = l_Lean_Expr_binderInfo(x_11); +x_90 = l_Lean_BinderInfo_beq(x_77, x_78); +if (x_90 == 0) +{ +lean_object* x_91; lean_object* x_92; +lean_dec(x_76); +lean_dec(x_75); +lean_dec(x_74); +lean_dec(x_64); +lean_dec(x_11); +lean_dec(x_7); +x_91 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +x_92 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_92, 0, x_91); +lean_ctor_set(x_92, 1, x_73); +return x_92; +} +else +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = l_Lean_Expr_bindingDomain_x21(x_7); +lean_dec(x_7); +x_94 = l_Lean_Expr_bindingDomain_x21(x_11); +lean_dec(x_11); +x_95 = lean_expr_eqv(x_93, x_94); +lean_dec(x_94); +lean_dec(x_93); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; +lean_dec(x_76); +lean_dec(x_75); +lean_dec(x_74); +lean_dec(x_64); +x_96 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +x_97 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_97, 0, x_96); +lean_ctor_set(x_97, 1, x_73); +return x_97; +} +else +{ +uint8_t x_98; uint8_t x_99; +x_98 = 3; +x_99 = l_Lean_BinderInfo_beq(x_78, x_98); +if (x_99 == 0) +{ +uint8_t x_100; +x_100 = lean_unbox(x_64); +lean_dec(x_64); +if (x_100 == 0) +{ +uint8_t x_101; +x_101 = lean_unbox(x_75); +if (x_101 == 0) +{ +uint8_t x_102; +x_102 = 1; +x_79 = x_102; +goto block_89; +} +else +{ +uint8_t x_103; +x_103 = 0; +x_79 = x_103; +goto block_89; +} +} +else +{ +uint8_t x_104; +x_104 = lean_unbox(x_75); +if (x_104 == 0) +{ +uint8_t x_105; +x_105 = 0; +x_79 = x_105; +goto block_89; +} +else +{ +uint8_t x_106; +x_106 = 1; +x_79 = x_106; +goto block_89; +} +} +} +else +{ +lean_object* x_107; lean_object* x_108; +lean_dec(x_76); +lean_dec(x_75); +lean_dec(x_74); +lean_dec(x_64); +x_107 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +x_108 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_108, 0, x_107); +lean_ctor_set(x_108, 1, x_73); +return x_108; +} +} +} +block_89: +{ +if (x_79 == 0) +{ +lean_object* x_80; lean_object* x_81; +lean_dec(x_76); +lean_dec(x_75); +x_80 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +if (lean_is_scalar(x_74)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_74; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_73); +return x_81; +} +else +{ +uint8_t x_82; uint8_t x_83; +x_82 = 0; +x_83 = l_Lean_BinderInfo_beq(x_78, x_82); +if (x_83 == 0) +{ +lean_object* x_84; lean_object* x_85; lean_object* x_86; +lean_dec(x_75); +x_84 = lean_box(x_79); +if (lean_is_scalar(x_76)) { + x_85 = lean_alloc_ctor(1, 1, 0); +} else { + x_85 = x_76; +} +lean_ctor_set(x_85, 0, x_84); +if (lean_is_scalar(x_74)) { + x_86 = lean_alloc_ctor(0, 2, 0); +} else { + x_86 = x_74; +} +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_73); +return x_86; +} +else +{ +lean_object* x_87; lean_object* x_88; +if (lean_is_scalar(x_76)) { + x_87 = lean_alloc_ctor(1, 1, 0); +} else { + x_87 = x_76; +} +lean_ctor_set(x_87, 0, x_75); +if (lean_is_scalar(x_74)) { + x_88 = lean_alloc_ctor(0, 2, 0); +} else { + x_88 = x_74; +} +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_73); +return x_88; +} +} +} +} +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_64); +lean_dec(x_11); +lean_dec(x_7); +x_109 = lean_ctor_get(x_67, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_67, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_111 = x_67; +} else { + lean_dec_ref(x_67); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_7); +lean_dec(x_2); +lean_dec(x_1); +x_113 = !lean_is_exclusive(x_9); +if (x_113 == 0) +{ +lean_object* x_114; lean_object* x_115; +x_114 = lean_ctor_get(x_9, 0); +lean_dec(x_114); +x_115 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +lean_ctor_set(x_9, 0, x_115); +return x_9; +} +else +{ +lean_object* x_116; lean_object* x_117; lean_object* x_118; +x_116 = lean_ctor_get(x_9, 1); +lean_inc(x_116); +lean_dec(x_9); +x_117 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +x_118 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_116); +return x_118; +} +} +} +case 7: +{ +lean_object* x_119; +x_119 = lean_ctor_get(x_7, 2); +lean_inc(x_119); +if (lean_obj_tag(x_119) == 7) +{ +uint8_t x_120; +x_120 = !lean_is_exclusive(x_9); +if (x_120 == 0) +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; +x_121 = lean_ctor_get(x_9, 1); +x_122 = lean_ctor_get(x_9, 0); +lean_dec(x_122); +x_123 = lean_ctor_get(x_10, 0); +lean_inc(x_123); +lean_dec(x_10); +x_124 = l_Lean_Meta_mkAuxName___closed__1; +x_125 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__2; +x_126 = l_Lean_Delaborator_withBindingBody___rarg(x_124, x_125, x_1, x_2, x_121); +if (lean_obj_tag(x_126) == 0) +{ +lean_object* x_127; +x_127 = lean_ctor_get(x_126, 0); +lean_inc(x_127); +if (lean_obj_tag(x_127) == 0) +{ +uint8_t x_128; +lean_dec(x_123); +lean_free_object(x_9); +lean_dec(x_119); +lean_dec(x_7); +x_128 = !lean_is_exclusive(x_126); +if (x_128 == 0) +{ +lean_object* x_129; lean_object* x_130; +x_129 = lean_ctor_get(x_126, 0); +lean_dec(x_129); +x_130 = lean_box(0); +lean_ctor_set(x_126, 0, x_130); +return x_126; +} +else +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; +x_131 = lean_ctor_get(x_126, 1); +lean_inc(x_131); +lean_dec(x_126); +x_132 = lean_box(0); +x_133 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_133, 0, x_132); +lean_ctor_set(x_133, 1, x_131); +return x_133; +} +} +else +{ +lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; uint8_t x_138; uint8_t x_139; uint8_t x_140; uint8_t x_151; +x_134 = lean_ctor_get(x_126, 1); +lean_inc(x_134); +if (lean_is_exclusive(x_126)) { + lean_ctor_release(x_126, 0); + lean_ctor_release(x_126, 1); + x_135 = x_126; +} else { + lean_dec_ref(x_126); + x_135 = lean_box(0); +} +x_136 = lean_ctor_get(x_127, 0); +lean_inc(x_136); +if (lean_is_exclusive(x_127)) { + lean_ctor_release(x_127, 0); + x_137 = x_127; +} else { + lean_dec_ref(x_127); + x_137 = lean_box(0); +} +x_138 = l_Lean_Expr_binderInfo(x_7); +x_139 = l_Lean_Expr_binderInfo(x_119); +x_151 = l_Lean_BinderInfo_beq(x_138, x_139); +if (x_151 == 0) +{ +lean_object* x_152; +lean_dec(x_137); +lean_dec(x_136); +lean_dec(x_135); +lean_dec(x_123); +lean_dec(x_119); +lean_dec(x_7); +x_152 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +lean_ctor_set(x_9, 1, x_134); +lean_ctor_set(x_9, 0, x_152); +return x_9; +} +else +{ +lean_object* x_153; lean_object* x_154; uint8_t x_155; +x_153 = l_Lean_Expr_bindingDomain_x21(x_7); +lean_dec(x_7); +x_154 = l_Lean_Expr_bindingDomain_x21(x_119); +lean_dec(x_119); +x_155 = lean_expr_eqv(x_153, x_154); +lean_dec(x_154); +lean_dec(x_153); +if (x_155 == 0) +{ +lean_object* x_156; +lean_dec(x_137); +lean_dec(x_136); +lean_dec(x_135); +lean_dec(x_123); +x_156 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +lean_ctor_set(x_9, 1, x_134); +lean_ctor_set(x_9, 0, x_156); +return x_9; +} +else +{ +uint8_t x_157; uint8_t x_158; +x_157 = 3; +x_158 = l_Lean_BinderInfo_beq(x_139, x_157); +if (x_158 == 0) +{ +uint8_t x_159; +lean_free_object(x_9); +x_159 = lean_unbox(x_123); +lean_dec(x_123); +if (x_159 == 0) +{ +uint8_t x_160; +x_160 = lean_unbox(x_136); +if (x_160 == 0) +{ +uint8_t x_161; +x_161 = 1; +x_140 = x_161; +goto block_150; +} +else +{ +uint8_t x_162; +x_162 = 0; +x_140 = x_162; +goto block_150; +} +} +else +{ +uint8_t x_163; +x_163 = lean_unbox(x_136); +if (x_163 == 0) +{ +uint8_t x_164; +x_164 = 0; +x_140 = x_164; +goto block_150; +} +else +{ +uint8_t x_165; +x_165 = 1; +x_140 = x_165; +goto block_150; +} +} +} +else +{ +lean_object* x_166; +lean_dec(x_137); +lean_dec(x_136); +lean_dec(x_135); +lean_dec(x_123); +x_166 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +lean_ctor_set(x_9, 1, x_134); +lean_ctor_set(x_9, 0, x_166); +return x_9; +} +} +} +block_150: +{ +if (x_140 == 0) +{ +lean_object* x_141; lean_object* x_142; +lean_dec(x_137); +lean_dec(x_136); +x_141 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +if (lean_is_scalar(x_135)) { + x_142 = lean_alloc_ctor(0, 2, 0); +} else { + x_142 = x_135; +} +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_134); +return x_142; +} +else +{ +uint8_t x_143; uint8_t x_144; +x_143 = 0; +x_144 = l_Lean_BinderInfo_beq(x_139, x_143); +if (x_144 == 0) +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +lean_dec(x_136); +x_145 = lean_box(x_140); +if (lean_is_scalar(x_137)) { + x_146 = lean_alloc_ctor(1, 1, 0); +} else { + x_146 = x_137; +} +lean_ctor_set(x_146, 0, x_145); +if (lean_is_scalar(x_135)) { + x_147 = lean_alloc_ctor(0, 2, 0); +} else { + x_147 = x_135; +} +lean_ctor_set(x_147, 0, x_146); +lean_ctor_set(x_147, 1, x_134); +return x_147; +} +else +{ +lean_object* x_148; lean_object* x_149; +if (lean_is_scalar(x_137)) { + x_148 = lean_alloc_ctor(1, 1, 0); +} else { + x_148 = x_137; +} +lean_ctor_set(x_148, 0, x_136); +if (lean_is_scalar(x_135)) { + x_149 = lean_alloc_ctor(0, 2, 0); +} else { + x_149 = x_135; +} +lean_ctor_set(x_149, 0, x_148); +lean_ctor_set(x_149, 1, x_134); +return x_149; +} +} +} +} +} +else +{ +uint8_t x_167; +lean_dec(x_123); +lean_free_object(x_9); +lean_dec(x_119); +lean_dec(x_7); +x_167 = !lean_is_exclusive(x_126); +if (x_167 == 0) +{ +return x_126; +} +else +{ +lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_168 = lean_ctor_get(x_126, 0); +x_169 = lean_ctor_get(x_126, 1); +lean_inc(x_169); +lean_inc(x_168); +lean_dec(x_126); +x_170 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_170, 0, x_168); +lean_ctor_set(x_170, 1, x_169); +return x_170; +} +} +} +else +{ +lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; +x_171 = lean_ctor_get(x_9, 1); +lean_inc(x_171); +lean_dec(x_9); +x_172 = lean_ctor_get(x_10, 0); +lean_inc(x_172); +lean_dec(x_10); +x_173 = l_Lean_Meta_mkAuxName___closed__1; +x_174 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__2; +x_175 = l_Lean_Delaborator_withBindingBody___rarg(x_173, x_174, x_1, x_2, x_171); +if (lean_obj_tag(x_175) == 0) +{ +lean_object* x_176; +x_176 = lean_ctor_get(x_175, 0); +lean_inc(x_176); +if (lean_obj_tag(x_176) == 0) +{ +lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; +lean_dec(x_172); +lean_dec(x_119); +lean_dec(x_7); +x_177 = lean_ctor_get(x_175, 1); +lean_inc(x_177); +if (lean_is_exclusive(x_175)) { + lean_ctor_release(x_175, 0); + lean_ctor_release(x_175, 1); + x_178 = x_175; +} else { + lean_dec_ref(x_175); + x_178 = lean_box(0); +} +x_179 = lean_box(0); +if (lean_is_scalar(x_178)) { + x_180 = lean_alloc_ctor(0, 2, 0); +} else { + x_180 = x_178; +} +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_177); +return x_180; +} +else +{ +lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; uint8_t x_185; uint8_t x_186; uint8_t x_187; uint8_t x_198; +x_181 = lean_ctor_get(x_175, 1); +lean_inc(x_181); +if (lean_is_exclusive(x_175)) { + lean_ctor_release(x_175, 0); + lean_ctor_release(x_175, 1); + x_182 = x_175; +} else { + lean_dec_ref(x_175); + x_182 = lean_box(0); +} +x_183 = lean_ctor_get(x_176, 0); +lean_inc(x_183); +if (lean_is_exclusive(x_176)) { + lean_ctor_release(x_176, 0); + x_184 = x_176; +} else { + lean_dec_ref(x_176); + x_184 = lean_box(0); +} +x_185 = l_Lean_Expr_binderInfo(x_7); +x_186 = l_Lean_Expr_binderInfo(x_119); +x_198 = l_Lean_BinderInfo_beq(x_185, x_186); +if (x_198 == 0) +{ +lean_object* x_199; lean_object* x_200; +lean_dec(x_184); +lean_dec(x_183); +lean_dec(x_182); +lean_dec(x_172); +lean_dec(x_119); +lean_dec(x_7); +x_199 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_199); +lean_ctor_set(x_200, 1, x_181); +return x_200; +} +else +{ +lean_object* x_201; lean_object* x_202; uint8_t x_203; +x_201 = l_Lean_Expr_bindingDomain_x21(x_7); +lean_dec(x_7); +x_202 = l_Lean_Expr_bindingDomain_x21(x_119); +lean_dec(x_119); +x_203 = lean_expr_eqv(x_201, x_202); +lean_dec(x_202); +lean_dec(x_201); +if (x_203 == 0) +{ +lean_object* x_204; lean_object* x_205; +lean_dec(x_184); +lean_dec(x_183); +lean_dec(x_182); +lean_dec(x_172); +x_204 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +x_205 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_205, 0, x_204); +lean_ctor_set(x_205, 1, x_181); +return x_205; +} +else +{ +uint8_t x_206; uint8_t x_207; +x_206 = 3; +x_207 = l_Lean_BinderInfo_beq(x_186, x_206); +if (x_207 == 0) +{ +uint8_t x_208; +x_208 = lean_unbox(x_172); +lean_dec(x_172); +if (x_208 == 0) +{ +uint8_t x_209; +x_209 = lean_unbox(x_183); +if (x_209 == 0) +{ +uint8_t x_210; +x_210 = 1; +x_187 = x_210; +goto block_197; +} +else +{ +uint8_t x_211; +x_211 = 0; +x_187 = x_211; +goto block_197; +} +} +else +{ +uint8_t x_212; +x_212 = lean_unbox(x_183); +if (x_212 == 0) +{ +uint8_t x_213; +x_213 = 0; +x_187 = x_213; +goto block_197; +} +else +{ +uint8_t x_214; +x_214 = 1; +x_187 = x_214; +goto block_197; +} +} +} +else +{ +lean_object* x_215; lean_object* x_216; +lean_dec(x_184); +lean_dec(x_183); +lean_dec(x_182); +lean_dec(x_172); +x_215 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +x_216 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_216, 0, x_215); +lean_ctor_set(x_216, 1, x_181); +return x_216; +} +} +} +block_197: +{ +if (x_187 == 0) +{ +lean_object* x_188; lean_object* x_189; +lean_dec(x_184); +lean_dec(x_183); +x_188 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +if (lean_is_scalar(x_182)) { + x_189 = lean_alloc_ctor(0, 2, 0); +} else { + x_189 = x_182; +} +lean_ctor_set(x_189, 0, x_188); +lean_ctor_set(x_189, 1, x_181); +return x_189; +} +else +{ +uint8_t x_190; uint8_t x_191; +x_190 = 0; +x_191 = l_Lean_BinderInfo_beq(x_186, x_190); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; +lean_dec(x_183); +x_192 = lean_box(x_187); +if (lean_is_scalar(x_184)) { + x_193 = lean_alloc_ctor(1, 1, 0); +} else { + x_193 = x_184; +} +lean_ctor_set(x_193, 0, x_192); +if (lean_is_scalar(x_182)) { + x_194 = lean_alloc_ctor(0, 2, 0); +} else { + x_194 = x_182; +} +lean_ctor_set(x_194, 0, x_193); +lean_ctor_set(x_194, 1, x_181); +return x_194; +} +else +{ +lean_object* x_195; lean_object* x_196; +if (lean_is_scalar(x_184)) { + x_195 = lean_alloc_ctor(1, 1, 0); +} else { + x_195 = x_184; +} +lean_ctor_set(x_195, 0, x_183); +if (lean_is_scalar(x_182)) { + x_196 = lean_alloc_ctor(0, 2, 0); +} else { + x_196 = x_182; +} +lean_ctor_set(x_196, 0, x_195); +lean_ctor_set(x_196, 1, x_181); +return x_196; +} +} +} +} +} +else +{ +lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; +lean_dec(x_172); +lean_dec(x_119); +lean_dec(x_7); +x_217 = lean_ctor_get(x_175, 0); +lean_inc(x_217); +x_218 = lean_ctor_get(x_175, 1); +lean_inc(x_218); +if (lean_is_exclusive(x_175)) { + lean_ctor_release(x_175, 0); + lean_ctor_release(x_175, 1); + x_219 = x_175; +} else { + lean_dec_ref(x_175); + x_219 = lean_box(0); +} +if (lean_is_scalar(x_219)) { + x_220 = lean_alloc_ctor(1, 2, 0); +} else { + x_220 = x_219; +} +lean_ctor_set(x_220, 0, x_217); +lean_ctor_set(x_220, 1, x_218); +return x_220; +} +} +} +else +{ +uint8_t x_221; +lean_dec(x_119); +lean_dec(x_10); +lean_dec(x_7); +lean_dec(x_2); +lean_dec(x_1); +x_221 = !lean_is_exclusive(x_9); +if (x_221 == 0) +{ +lean_object* x_222; lean_object* x_223; +x_222 = lean_ctor_get(x_9, 0); +lean_dec(x_222); +x_223 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +lean_ctor_set(x_9, 0, x_223); +return x_9; +} +else +{ +lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_224 = lean_ctor_get(x_9, 1); +lean_inc(x_224); +lean_dec(x_9); +x_225 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +x_226 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_226, 0, x_225); +lean_ctor_set(x_226, 1, x_224); +return x_226; +} +} +} +default: +{ +uint8_t x_227; +lean_dec(x_10); +lean_dec(x_7); +lean_dec(x_2); +lean_dec(x_1); +x_227 = !lean_is_exclusive(x_9); +if (x_227 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_ctor_get(x_9, 0); +lean_dec(x_228); +x_229 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +lean_ctor_set(x_9, 0, x_229); +return x_9; +} +else +{ +lean_object* x_230; lean_object* x_231; lean_object* x_232; +x_230 = lean_ctor_get(x_9, 1); +lean_inc(x_230); +lean_dec(x_9); +x_231 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3; +x_232 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_230); +return x_232; +} +} +} +} +} +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Delaborator_2__delabLamAux___main___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_array_get_size(x_2); +x_4 = lean_nat_dec_lt(x_1, x_3); +lean_dec(x_3); +if (x_4 == 0) +{ +lean_dec(x_1); +return x_2; +} +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; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_5 = lean_array_fget(x_2, x_1); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_array_fset(x_2, x_1, x_6); +x_8 = x_5; +x_9 = l_Lean_mkTermIdFromIdent(x_8); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +x_12 = x_9; +x_13 = lean_array_fset(x_7, x_1, x_12); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_13; +goto _start; +} +} +} +lean_object* l___private_Init_Lean_Delaborator_2__delabLamAux___main___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_6 = lean_unsigned_to_nat(0u); +x_7 = l_Array_empty___closed__1; +x_8 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_1, x_1, x_6, x_7); +x_9 = l_Lean_nullKind___closed__2; +x_10 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_8); +x_11 = l_Lean_Elab_Term_expandCDot_x3f___closed__2; +x_12 = lean_array_push(x_11, x_10); +x_13 = l_Lean_Elab_Term_expandCDot_x3f___closed__3; +x_14 = lean_array_push(x_12, x_13); +x_15 = lean_array_push(x_14, x_2); +x_16 = l_Lean_Parser_Term_fun___elambda__1___closed__2; +x_17 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +x_18 = lean_array_push(x_7, x_17); +x_19 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_20 = lean_array_push(x_18, x_19); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_9); +lean_ctor_set(x_21, 1, x_20); +x_22 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; +x_23 = lean_array_push(x_22, x_21); +x_24 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; +x_25 = lean_array_push(x_23, x_24); +x_26 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_25); +x_28 = l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__2; +x_29 = lean_array_push(x_28, x_27); +x_30 = l_Lean_Parser_Term_explicit___elambda__1___closed__2; +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_29); +x_32 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_32, 0, x_31); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_5); +return x_33; +} +} +lean_object* _init_l___private_Init_Lean_Delaborator_2__delabLamAux___main___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delab), 3, 0); +return x_1; +} +} +lean_object* l___private_Init_Lean_Delaborator_2__delabLamAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_6 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__1; +lean_inc(x_3); +x_7 = l_Lean_Delaborator_getPPOption(x_6, x_3, x_4, x_5); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_7, 1); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +lean_dec(x_8); +x_11 = l_Lean_Delaborator_getExpr(x_3, x_4, x_9); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +lean_dec(x_12); +if (lean_obj_tag(x_13) == 6) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_14 = lean_ctor_get(x_11, 1); +lean_inc(x_14); +lean_dec(x_11); +x_15 = lean_ctor_get(x_13, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_13, 2); +lean_inc(x_16); +x_17 = lean_ctor_get(x_4, 1); +lean_inc(x_17); +x_18 = lean_local_ctx_get_unused_name(x_17, x_15); +lean_inc(x_18); +x_19 = lean_mk_syntax_ident(x_18); +lean_inc(x_3); +x_20 = l_Lean_Delaborator_annotateCurPos(x_19, x_3, x_4, x_14); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +x_22 = lean_ctor_get(x_20, 1); +lean_inc(x_22); +lean_dec(x_20); +x_23 = lean_ctor_get(x_21, 0); +lean_inc(x_23); +lean_dec(x_21); +lean_inc(x_23); +x_24 = lean_array_push(x_2, x_23); +lean_inc(x_4); +lean_inc(x_3); +x_25 = l___private_Init_Lean_Delaborator_1__shouldGroupWithNext(x_3, x_4, x_22); +if (lean_obj_tag(x_25) == 0) +{ +lean_object* x_26; +x_26 = lean_ctor_get(x_25, 0); +lean_inc(x_26); +if (lean_obj_tag(x_26) == 0) +{ +uint8_t x_27; +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_18); +lean_dec(x_16); +lean_dec(x_13); +lean_dec(x_10); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_27 = !lean_is_exclusive(x_25); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; +x_28 = lean_ctor_get(x_25, 0); +lean_dec(x_28); +x_29 = lean_box(0); +lean_ctor_set(x_25, 0, x_29); +return x_25; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = lean_ctor_get(x_25, 1); +lean_inc(x_30); +lean_dec(x_25); +x_31 = lean_box(0); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_30); +return x_32; +} +} +else +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_26, 0); +lean_inc(x_33); +lean_dec(x_26); +x_34 = lean_unbox(x_33); +lean_dec(x_33); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_25, 1); +lean_inc(x_35); +lean_dec(x_25); +x_36 = l___private_Init_Lean_Delaborator_2__delabLamAux___main___closed__1; +lean_inc(x_4); +lean_inc(x_3); +x_37 = l_Lean_Delaborator_withBindingDomain___rarg(x_36, x_3, x_4, x_35); +if (lean_obj_tag(x_37) == 0) +{ +lean_object* x_38; +x_38 = lean_ctor_get(x_37, 0); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) +{ +uint8_t x_39; +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_18); +lean_dec(x_16); +lean_dec(x_13); +lean_dec(x_10); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_39 = !lean_is_exclusive(x_37); +if (x_39 == 0) +{ +lean_object* x_40; lean_object* x_41; +x_40 = lean_ctor_get(x_37, 0); +lean_dec(x_40); +x_41 = lean_box(0); +lean_ctor_set(x_37, 0, x_41); +return x_37; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_42 = lean_ctor_get(x_37, 1); +lean_inc(x_42); +lean_dec(x_37); +x_43 = lean_box(0); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_42); +return x_44; +} +} +else +{ +lean_object* x_45; lean_object* x_46; uint8_t x_47; +x_45 = lean_ctor_get(x_37, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_37)) { + lean_ctor_release(x_37, 0); + lean_ctor_release(x_37, 1); + x_46 = x_37; +} else { + lean_dec_ref(x_37); + x_46 = lean_box(0); +} +x_47 = !lean_is_exclusive(x_38); +if (x_47 == 0) +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_63; lean_object* x_64; +x_48 = lean_ctor_get(x_38, 0); +x_63 = l_Lean_Expr_binderInfo(x_13); +lean_dec(x_13); +x_64 = lean_box(x_63); +switch (lean_obj_tag(x_64)) { +case 0: +{ +uint8_t x_65; +x_65 = lean_unbox(x_10); +lean_dec(x_10); +if (x_65 == 0) +{ +lean_object* x_66; +lean_dec(x_48); +lean_dec(x_24); +x_66 = l_Lean_mkTermIdFromIdent(x_23); +lean_ctor_set(x_38, 0, x_66); +x_49 = x_38; +x_50 = x_45; +goto block_62; +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; uint8_t x_73; +lean_dec(x_23); +x_67 = x_24; +x_68 = lean_unsigned_to_nat(0u); +x_69 = l_Array_umapMAux___main___at___private_Init_Lean_Delaborator_2__delabLamAux___main___spec__1(x_68, x_67); +x_70 = x_69; +x_71 = lean_array_get_size(x_70); +x_72 = lean_unsigned_to_nat(1u); +x_73 = lean_nat_dec_lt(x_72, x_71); +lean_dec(x_71); +if (x_73 == 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; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_74 = l_Lean_Syntax_inhabited; +x_75 = lean_array_get(x_74, x_70, x_68); +lean_dec(x_70); +x_76 = l_Array_empty___closed__1; +x_77 = lean_array_push(x_76, x_75); +x_78 = l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__2; +x_79 = lean_array_push(x_78, x_48); +x_80 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__2; +x_81 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_79); +x_82 = lean_array_push(x_76, x_81); +x_83 = l_Lean_nullKind___closed__2; +x_84 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_84, 0, x_83); +lean_ctor_set(x_84, 1, x_82); +x_85 = lean_array_push(x_77, x_84); +x_86 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_86, 0, x_83); +lean_ctor_set(x_86, 1, x_85); +x_87 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; +x_88 = lean_array_push(x_87, x_86); +x_89 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; +x_90 = lean_array_push(x_88, x_89); +x_91 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_92 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_92, 0, x_91); +lean_ctor_set(x_92, 1, x_90); +lean_ctor_set(x_38, 0, x_92); +x_49 = x_38; +x_50 = x_45; +goto block_62; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; 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_object* x_118; +x_93 = l_Lean_Syntax_inhabited; +x_94 = lean_array_get(x_93, x_70, x_68); +x_95 = l_Array_empty___closed__1; +x_96 = lean_array_push(x_95, x_94); +x_97 = l_Array_eraseIdx___rarg(x_70, x_68); +x_98 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_97, x_97, x_68, x_95); +lean_dec(x_97); +x_99 = l_Lean_nullKind___closed__2; +x_100 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_100, 0, x_99); +lean_ctor_set(x_100, 1, x_98); +x_101 = lean_array_push(x_96, x_100); +x_102 = l_Lean_mkAppStx___closed__8; +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_101); +x_104 = lean_array_push(x_95, x_103); +x_105 = l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__2; +x_106 = lean_array_push(x_105, x_48); +x_107 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__2; +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_107); +lean_ctor_set(x_108, 1, x_106); +x_109 = lean_array_push(x_95, x_108); +x_110 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_110, 0, x_99); +lean_ctor_set(x_110, 1, x_109); +x_111 = lean_array_push(x_104, x_110); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_99); +lean_ctor_set(x_112, 1, x_111); +x_113 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; +x_114 = lean_array_push(x_113, x_112); +x_115 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; +x_116 = lean_array_push(x_114, x_115); +x_117 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_118 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_116); +lean_ctor_set(x_38, 0, x_118); +x_49 = x_38; +x_50 = x_45; +goto block_62; +} +} +} +case 1: +{ +uint8_t x_119; +lean_dec(x_23); +x_119 = lean_unbox(x_10); +lean_dec(x_10); +if (x_119 == 0) +{ +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_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; +lean_dec(x_48); +x_120 = lean_unsigned_to_nat(0u); +x_121 = l_Array_empty___closed__1; +x_122 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_24, x_24, x_120, x_121); +lean_dec(x_24); +x_123 = l_Lean_nullKind___closed__2; +x_124 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_124, 0, x_123); +lean_ctor_set(x_124, 1, x_122); +x_125 = l___private_Init_Lean_Elab_DoNotation_7__expandDoElemsAux___main___closed__2; +x_126 = lean_array_push(x_125, x_124); +x_127 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_128 = lean_array_push(x_126, x_127); +x_129 = l_Lean_Delaborator_delabConst___closed__4; +x_130 = lean_array_push(x_128, x_129); +x_131 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2; +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_130); +lean_ctor_set(x_38, 0, x_132); +x_49 = x_38; +x_50 = x_45; +goto block_62; +} +else +{ +lean_object* x_133; 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; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_133 = lean_unsigned_to_nat(0u); +x_134 = l_Array_empty___closed__1; +x_135 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_24, x_24, x_133, x_134); +lean_dec(x_24); +x_136 = l_Lean_nullKind___closed__2; +x_137 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_135); +x_138 = l___private_Init_Lean_Elab_DoNotation_7__expandDoElemsAux___main___closed__2; +x_139 = lean_array_push(x_138, x_137); +x_140 = l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__2; +x_141 = lean_array_push(x_140, x_48); +x_142 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_142, 0, x_136); +lean_ctor_set(x_142, 1, x_141); +x_143 = lean_array_push(x_139, x_142); +x_144 = l_Lean_Delaborator_delabConst___closed__4; +x_145 = lean_array_push(x_143, x_144); +x_146 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2; +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_146); +lean_ctor_set(x_147, 1, x_145); +lean_ctor_set(x_38, 0, x_147); +x_49 = x_38; +x_50 = x_45; +goto block_62; +} +} +case 3: +{ +lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_24); +lean_dec(x_10); +x_148 = l_Array_empty___closed__1; +x_149 = lean_array_push(x_148, x_23); +x_150 = l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__1; +x_151 = lean_array_push(x_149, x_150); +x_152 = l_Lean_nullKind___closed__2; +x_153 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_153, 0, x_152); +lean_ctor_set(x_153, 1, x_151); +x_154 = l_Lean_Elab_Term_elabArrayLit___closed__10; +x_155 = lean_array_push(x_154, x_153); +x_156 = lean_array_push(x_155, x_48); +x_157 = l_Lean_Elab_Term_elabArrayLit___closed__11; +x_158 = lean_array_push(x_156, x_157); +x_159 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2; +x_160 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_158); +lean_ctor_set(x_38, 0, x_160); +x_49 = x_38; +x_50 = x_45; +goto block_62; +} +default: +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +lean_dec(x_64); +lean_free_object(x_38); +lean_dec(x_48); +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_10); +x_161 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_162 = l_unreachable_x21___rarg(x_161); +lean_inc(x_4); +lean_inc(x_3); +x_163 = lean_apply_3(x_162, x_3, x_4, x_45); +if (lean_obj_tag(x_163) == 0) +{ +lean_object* x_164; lean_object* x_165; +x_164 = lean_ctor_get(x_163, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_163, 1); +lean_inc(x_165); +lean_dec(x_163); +x_49 = x_164; +x_50 = x_165; +goto block_62; +} +else +{ +uint8_t x_166; +lean_dec(x_46); +lean_dec(x_18); +lean_dec(x_16); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_166 = !lean_is_exclusive(x_163); +if (x_166 == 0) +{ +return x_163; +} +else +{ +lean_object* x_167; lean_object* x_168; lean_object* x_169; +x_167 = lean_ctor_get(x_163, 0); +x_168 = lean_ctor_get(x_163, 1); +lean_inc(x_168); +lean_inc(x_167); +lean_dec(x_163); +x_169 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_169, 0, x_167); +lean_ctor_set(x_169, 1, x_168); +return x_169; +} +} +} +} +block_62: +{ +if (lean_obj_tag(x_49) == 0) +{ +lean_object* x_51; lean_object* x_52; +lean_dec(x_18); +lean_dec(x_16); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_51 = lean_box(0); +if (lean_is_scalar(x_46)) { + x_52 = lean_alloc_ctor(0, 2, 0); +} else { + x_52 = x_46; +} +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_50); +return x_52; +} +else +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +lean_dec(x_46); +x_53 = lean_ctor_get(x_49, 0); +lean_inc(x_53); +lean_dec(x_49); +x_54 = lean_array_push(x_1, x_53); +x_55 = l_Lean_Expr_isLambda(x_16); +lean_dec(x_16); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_alloc_closure((void*)(l___private_Init_Lean_Delaborator_2__delabLamAux___main___lambda__1___boxed), 5, 1); +lean_closure_set(x_56, 0, x_54); +x_57 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2___rarg), 5, 2); +lean_closure_set(x_57, 0, x_36); +lean_closure_set(x_57, 1, x_56); +x_58 = l_Lean_Delaborator_withBindingBody___rarg(x_18, x_57, x_3, x_4, x_50); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = l_Array_empty___closed__1; +x_60 = lean_alloc_closure((void*)(l___private_Init_Lean_Delaborator_2__delabLamAux___main), 5, 2); +lean_closure_set(x_60, 0, x_54); +lean_closure_set(x_60, 1, x_59); +x_61 = l_Lean_Delaborator_withBindingBody___rarg(x_18, x_60, x_3, x_4, x_50); +return x_61; +} +} +} +} +else +{ +lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_185; lean_object* x_186; +x_170 = lean_ctor_get(x_38, 0); +lean_inc(x_170); +lean_dec(x_38); +x_185 = l_Lean_Expr_binderInfo(x_13); +lean_dec(x_13); +x_186 = lean_box(x_185); +switch (lean_obj_tag(x_186)) { +case 0: +{ +uint8_t x_187; +x_187 = lean_unbox(x_10); +lean_dec(x_10); +if (x_187 == 0) +{ +lean_object* x_188; lean_object* x_189; +lean_dec(x_170); +lean_dec(x_24); +x_188 = l_Lean_mkTermIdFromIdent(x_23); +x_189 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_189, 0, x_188); +x_171 = x_189; +x_172 = x_45; +goto block_184; +} +else +{ +lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; uint8_t x_196; +lean_dec(x_23); +x_190 = x_24; +x_191 = lean_unsigned_to_nat(0u); +x_192 = l_Array_umapMAux___main___at___private_Init_Lean_Delaborator_2__delabLamAux___main___spec__1(x_191, x_190); +x_193 = x_192; +x_194 = lean_array_get_size(x_193); +x_195 = lean_unsigned_to_nat(1u); +x_196 = lean_nat_dec_lt(x_195, x_194); +lean_dec(x_194); +if (x_196 == 0) +{ +lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; +x_197 = l_Lean_Syntax_inhabited; +x_198 = lean_array_get(x_197, x_193, x_191); +lean_dec(x_193); +x_199 = l_Array_empty___closed__1; +x_200 = lean_array_push(x_199, x_198); +x_201 = l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__2; +x_202 = lean_array_push(x_201, x_170); +x_203 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__2; +x_204 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_204, 0, x_203); +lean_ctor_set(x_204, 1, x_202); +x_205 = lean_array_push(x_199, x_204); +x_206 = l_Lean_nullKind___closed__2; +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_206); +lean_ctor_set(x_207, 1, x_205); +x_208 = lean_array_push(x_200, x_207); +x_209 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_209, 0, x_206); +lean_ctor_set(x_209, 1, x_208); +x_210 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; +x_211 = lean_array_push(x_210, x_209); +x_212 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; +x_213 = lean_array_push(x_211, x_212); +x_214 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_214); +lean_ctor_set(x_215, 1, x_213); +x_216 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_216, 0, x_215); +x_171 = x_216; +x_172 = x_45; +goto block_184; +} +else +{ +lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; +x_217 = l_Lean_Syntax_inhabited; +x_218 = lean_array_get(x_217, x_193, x_191); +x_219 = l_Array_empty___closed__1; +x_220 = lean_array_push(x_219, x_218); +x_221 = l_Array_eraseIdx___rarg(x_193, x_191); +x_222 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_221, x_221, x_191, x_219); +lean_dec(x_221); +x_223 = l_Lean_nullKind___closed__2; +x_224 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_224, 0, x_223); +lean_ctor_set(x_224, 1, x_222); +x_225 = lean_array_push(x_220, x_224); +x_226 = l_Lean_mkAppStx___closed__8; +x_227 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_227, 0, x_226); +lean_ctor_set(x_227, 1, x_225); +x_228 = lean_array_push(x_219, x_227); +x_229 = l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__2; +x_230 = lean_array_push(x_229, x_170); +x_231 = l_Lean_Parser_Term_typeAscription___elambda__1___closed__2; +x_232 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_230); +x_233 = lean_array_push(x_219, x_232); +x_234 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_234, 0, x_223); +lean_ctor_set(x_234, 1, x_233); +x_235 = lean_array_push(x_228, x_234); +x_236 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_236, 0, x_223); +lean_ctor_set(x_236, 1, x_235); +x_237 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; +x_238 = lean_array_push(x_237, x_236); +x_239 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; +x_240 = lean_array_push(x_238, x_239); +x_241 = l_Lean_Parser_Term_paren___elambda__1___closed__1; +x_242 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_242, 0, x_241); +lean_ctor_set(x_242, 1, x_240); +x_243 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_243, 0, x_242); +x_171 = x_243; +x_172 = x_45; +goto block_184; +} +} +} +case 1: +{ +uint8_t x_244; +lean_dec(x_23); +x_244 = lean_unbox(x_10); +lean_dec(x_10); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; +lean_dec(x_170); +x_245 = lean_unsigned_to_nat(0u); +x_246 = l_Array_empty___closed__1; +x_247 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_24, x_24, x_245, x_246); +lean_dec(x_24); +x_248 = l_Lean_nullKind___closed__2; +x_249 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_247); +x_250 = l___private_Init_Lean_Elab_DoNotation_7__expandDoElemsAux___main___closed__2; +x_251 = lean_array_push(x_250, x_249); +x_252 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; +x_253 = lean_array_push(x_251, x_252); +x_254 = l_Lean_Delaborator_delabConst___closed__4; +x_255 = lean_array_push(x_253, x_254); +x_256 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2; +x_257 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_257, 0, x_256); +lean_ctor_set(x_257, 1, x_255); +x_258 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_258, 0, x_257); +x_171 = x_258; +x_172 = x_45; +goto block_184; +} +else +{ +lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; +x_259 = lean_unsigned_to_nat(0u); +x_260 = l_Array_empty___closed__1; +x_261 = l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(x_24, x_24, x_259, x_260); +lean_dec(x_24); +x_262 = l_Lean_nullKind___closed__2; +x_263 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_263, 0, x_262); +lean_ctor_set(x_263, 1, x_261); +x_264 = l___private_Init_Lean_Elab_DoNotation_7__expandDoElemsAux___main___closed__2; +x_265 = lean_array_push(x_264, x_263); +x_266 = l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__2; +x_267 = lean_array_push(x_266, x_170); +x_268 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_268, 0, x_262); +lean_ctor_set(x_268, 1, x_267); +x_269 = lean_array_push(x_265, x_268); +x_270 = l_Lean_Delaborator_delabConst___closed__4; +x_271 = lean_array_push(x_269, x_270); +x_272 = l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2; +x_273 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_273, 0, x_272); +lean_ctor_set(x_273, 1, x_271); +x_274 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_274, 0, x_273); +x_171 = x_274; +x_172 = x_45; +goto block_184; +} +} +case 3: +{ +lean_object* x_275; 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_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; +lean_dec(x_24); +lean_dec(x_10); +x_275 = l_Array_empty___closed__1; +x_276 = lean_array_push(x_275, x_23); +x_277 = l___private_Init_Lean_Elab_Match_2__expandSimpleMatchWithType___closed__1; +x_278 = lean_array_push(x_276, x_277); +x_279 = l_Lean_nullKind___closed__2; +x_280 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_280, 0, x_279); +lean_ctor_set(x_280, 1, x_278); +x_281 = l_Lean_Elab_Term_elabArrayLit___closed__10; +x_282 = lean_array_push(x_281, x_280); +x_283 = lean_array_push(x_282, x_170); +x_284 = l_Lean_Elab_Term_elabArrayLit___closed__11; +x_285 = lean_array_push(x_283, x_284); +x_286 = l_Lean_Parser_Term_instBinder___elambda__1___closed__2; +x_287 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_287, 0, x_286); +lean_ctor_set(x_287, 1, x_285); +x_288 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_288, 0, x_287); +x_171 = x_288; +x_172 = x_45; +goto block_184; +} +default: +{ +lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_186); +lean_dec(x_170); +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_10); +x_289 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_290 = l_unreachable_x21___rarg(x_289); +lean_inc(x_4); +lean_inc(x_3); +x_291 = lean_apply_3(x_290, x_3, x_4, x_45); +if (lean_obj_tag(x_291) == 0) +{ +lean_object* x_292; lean_object* x_293; +x_292 = lean_ctor_get(x_291, 0); +lean_inc(x_292); +x_293 = lean_ctor_get(x_291, 1); +lean_inc(x_293); +lean_dec(x_291); +x_171 = x_292; +x_172 = x_293; +goto block_184; +} +else +{ +lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; +lean_dec(x_46); +lean_dec(x_18); +lean_dec(x_16); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_294 = lean_ctor_get(x_291, 0); +lean_inc(x_294); +x_295 = lean_ctor_get(x_291, 1); +lean_inc(x_295); +if (lean_is_exclusive(x_291)) { + lean_ctor_release(x_291, 0); + lean_ctor_release(x_291, 1); + x_296 = x_291; +} else { + lean_dec_ref(x_291); + x_296 = lean_box(0); +} +if (lean_is_scalar(x_296)) { + x_297 = lean_alloc_ctor(1, 2, 0); +} else { + x_297 = x_296; +} +lean_ctor_set(x_297, 0, x_294); +lean_ctor_set(x_297, 1, x_295); +return x_297; +} +} +} +block_184: +{ +if (lean_obj_tag(x_171) == 0) +{ +lean_object* x_173; lean_object* x_174; +lean_dec(x_18); +lean_dec(x_16); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_173 = lean_box(0); +if (lean_is_scalar(x_46)) { + x_174 = lean_alloc_ctor(0, 2, 0); +} else { + x_174 = x_46; +} +lean_ctor_set(x_174, 0, x_173); +lean_ctor_set(x_174, 1, x_172); +return x_174; +} +else +{ +lean_object* x_175; lean_object* x_176; uint8_t x_177; +lean_dec(x_46); +x_175 = lean_ctor_get(x_171, 0); +lean_inc(x_175); +lean_dec(x_171); +x_176 = lean_array_push(x_1, x_175); +x_177 = l_Lean_Expr_isLambda(x_16); +lean_dec(x_16); +if (x_177 == 0) +{ +lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_178 = lean_alloc_closure((void*)(l___private_Init_Lean_Delaborator_2__delabLamAux___main___lambda__1___boxed), 5, 1); +lean_closure_set(x_178, 0, x_176); +x_179 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Delaborator_delabAppExplicit___spec__2___rarg), 5, 2); +lean_closure_set(x_179, 0, x_36); +lean_closure_set(x_179, 1, x_178); +x_180 = l_Lean_Delaborator_withBindingBody___rarg(x_18, x_179, x_3, x_4, x_172); +return x_180; +} +else +{ +lean_object* x_181; lean_object* x_182; lean_object* x_183; +x_181 = l_Array_empty___closed__1; +x_182 = lean_alloc_closure((void*)(l___private_Init_Lean_Delaborator_2__delabLamAux___main), 5, 2); +lean_closure_set(x_182, 0, x_176); +lean_closure_set(x_182, 1, x_181); +x_183 = l_Lean_Delaborator_withBindingBody___rarg(x_18, x_182, x_3, x_4, x_172); +return x_183; +} +} +} +} +} +} +else +{ +uint8_t x_298; +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_18); +lean_dec(x_16); +lean_dec(x_13); +lean_dec(x_10); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_298 = !lean_is_exclusive(x_37); +if (x_298 == 0) +{ +return x_37; +} +else +{ +lean_object* x_299; lean_object* x_300; lean_object* x_301; +x_299 = lean_ctor_get(x_37, 0); +x_300 = lean_ctor_get(x_37, 1); +lean_inc(x_300); +lean_inc(x_299); +lean_dec(x_37); +x_301 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_301, 0, x_299); +lean_ctor_set(x_301, 1, x_300); +return x_301; +} +} +} +else +{ +lean_object* x_302; lean_object* x_303; lean_object* x_304; +lean_dec(x_23); +lean_dec(x_16); +lean_dec(x_13); +lean_dec(x_10); +x_302 = lean_ctor_get(x_25, 1); +lean_inc(x_302); +lean_dec(x_25); +x_303 = lean_alloc_closure((void*)(l___private_Init_Lean_Delaborator_2__delabLamAux___main), 5, 2); +lean_closure_set(x_303, 0, x_1); +lean_closure_set(x_303, 1, x_24); +x_304 = l_Lean_Delaborator_withBindingBody___rarg(x_18, x_303, x_3, x_4, x_302); +return x_304; +} +} +} +else +{ +uint8_t x_305; +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_18); +lean_dec(x_16); +lean_dec(x_13); +lean_dec(x_10); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_305 = !lean_is_exclusive(x_25); +if (x_305 == 0) +{ +return x_25; +} +else +{ +lean_object* x_306; lean_object* x_307; lean_object* x_308; +x_306 = lean_ctor_get(x_25, 0); +x_307 = lean_ctor_get(x_25, 1); +lean_inc(x_307); +lean_inc(x_306); +lean_dec(x_25); +x_308 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_308, 0, x_306); +lean_ctor_set(x_308, 1, x_307); +return x_308; +} +} +} +else +{ +lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; +lean_dec(x_13); +lean_dec(x_10); +lean_dec(x_2); +lean_dec(x_1); +x_309 = lean_ctor_get(x_11, 1); +lean_inc(x_309); +lean_dec(x_11); +x_310 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_311 = l_unreachable_x21___rarg(x_310); +x_312 = lean_apply_3(x_311, x_3, x_4, x_309); +return x_312; +} +} +} +lean_object* l___private_Init_Lean_Delaborator_2__delabLamAux___main___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l___private_Init_Lean_Delaborator_2__delabLamAux___main___lambda__1(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +return x_6; +} +} +lean_object* l___private_Init_Lean_Delaborator_2__delabLamAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l___private_Init_Lean_Delaborator_2__delabLamAux___main(x_1, x_2, x_3, x_4, x_5); +return x_6; +} +} +lean_object* l_Lean_Delaborator_delabExplicitLam(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +x_4 = l_Array_empty___closed__1; +x_5 = l___private_Init_Lean_Delaborator_2__delabLamAux___main(x_4, x_4, x_1, x_2, x_3); +return x_5; +} +} +lean_object* _init_l___regBuiltin_Lean_Delaborator_delabExplicitLam___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabExplicitLam), 3, 0); +return x_1; +} +} +lean_object* l___regBuiltin_Lean_Delaborator_delabExplicitLam(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_Lean_Delaborator_delabAttribute; +x_3 = l_Lean_Delaborator_getExprKind___closed__15; +x_4 = l___regBuiltin_Lean_Delaborator_delabExplicitLam___closed__1; +x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); +return x_5; +} +} +lean_object* l_Lean_Delaborator_delabLit(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = l_Lean_Delaborator_getExpr(x_1, x_2, x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_5, 0); +if (lean_obj_tag(x_7) == 9) +{ +lean_object* x_8; +lean_dec(x_2); +lean_dec(x_1); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +lean_dec(x_7); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_4); +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; +x_10 = lean_ctor_get(x_4, 0); +lean_dec(x_10); +x_11 = lean_ctor_get(x_8, 0); +lean_inc(x_11); +lean_dec(x_8); +x_12 = l_Nat_repr(x_11); +x_13 = lean_box(0); +x_14 = l_Lean_numLitKind; +x_15 = l_Lean_mkStxLit(x_14, x_12, x_13); +x_16 = l_Lean_mkOptionalNode___closed__2; +x_17 = lean_array_push(x_16, x_15); +x_18 = l_Lean_Nat_HasQuote___closed__2; +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_17); +lean_ctor_set(x_5, 0, x_19); +return x_4; +} +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_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_20 = lean_ctor_get(x_4, 1); +lean_inc(x_20); +lean_dec(x_4); +x_21 = lean_ctor_get(x_8, 0); +lean_inc(x_21); +lean_dec(x_8); +x_22 = l_Nat_repr(x_21); +x_23 = lean_box(0); +x_24 = l_Lean_numLitKind; +x_25 = l_Lean_mkStxLit(x_24, x_22, x_23); +x_26 = l_Lean_mkOptionalNode___closed__2; +x_27 = lean_array_push(x_26, x_25); +x_28 = l_Lean_Nat_HasQuote___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_27); +lean_ctor_set(x_5, 0, x_29); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_5); +lean_ctor_set(x_30, 1, x_20); +return x_30; +} +} +else +{ +uint8_t x_31; +x_31 = !lean_is_exclusive(x_4); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_32 = lean_ctor_get(x_4, 0); +lean_dec(x_32); +x_33 = lean_ctor_get(x_8, 0); +lean_inc(x_33); +lean_dec(x_8); +x_34 = lean_box(0); +x_35 = l_Lean_mkStxStrLit(x_33, x_34); +x_36 = l_Lean_mkOptionalNode___closed__2; +x_37 = lean_array_push(x_36, x_35); +x_38 = l_Lean_String_HasQuote___closed__2; +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_37); +lean_ctor_set(x_5, 0, x_39); +return x_4; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_40 = lean_ctor_get(x_4, 1); +lean_inc(x_40); +lean_dec(x_4); +x_41 = lean_ctor_get(x_8, 0); +lean_inc(x_41); +lean_dec(x_8); +x_42 = lean_box(0); +x_43 = l_Lean_mkStxStrLit(x_41, x_42); +x_44 = l_Lean_mkOptionalNode___closed__2; +x_45 = lean_array_push(x_44, x_43); +x_46 = l_Lean_String_HasQuote___closed__2; +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_45); +lean_ctor_set(x_5, 0, x_47); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_5); +lean_ctor_set(x_48, 1, x_40); +return x_48; +} +} +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +lean_free_object(x_5); +lean_dec(x_7); +x_49 = lean_ctor_get(x_4, 1); +lean_inc(x_49); +lean_dec(x_4); +x_50 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_51 = l_unreachable_x21___rarg(x_50); +x_52 = lean_apply_3(x_51, x_1, x_2, x_49); +return x_52; +} +} +else +{ +lean_object* x_53; +x_53 = lean_ctor_get(x_5, 0); +lean_inc(x_53); +lean_dec(x_5); +if (lean_obj_tag(x_53) == 9) +{ +lean_object* x_54; +lean_dec(x_2); +lean_dec(x_1); +x_54 = lean_ctor_get(x_53, 0); +lean_inc(x_54); +lean_dec(x_53); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_55 = lean_ctor_get(x_4, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_56 = x_4; +} else { + lean_dec_ref(x_4); + x_56 = lean_box(0); +} +x_57 = lean_ctor_get(x_54, 0); +lean_inc(x_57); +lean_dec(x_54); +x_58 = l_Nat_repr(x_57); +x_59 = lean_box(0); +x_60 = l_Lean_numLitKind; +x_61 = l_Lean_mkStxLit(x_60, x_58, x_59); +x_62 = l_Lean_mkOptionalNode___closed__2; +x_63 = lean_array_push(x_62, x_61); +x_64 = l_Lean_Nat_HasQuote___closed__2; +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_63); +x_66 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_66, 0, x_65); +if (lean_is_scalar(x_56)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_56; +} +lean_ctor_set(x_67, 0, x_66); +lean_ctor_set(x_67, 1, x_55); +return x_67; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_68 = lean_ctor_get(x_4, 1); +lean_inc(x_68); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_69 = x_4; +} else { + lean_dec_ref(x_4); + x_69 = lean_box(0); +} +x_70 = lean_ctor_get(x_54, 0); +lean_inc(x_70); +lean_dec(x_54); +x_71 = lean_box(0); +x_72 = l_Lean_mkStxStrLit(x_70, x_71); +x_73 = l_Lean_mkOptionalNode___closed__2; +x_74 = lean_array_push(x_73, x_72); +x_75 = l_Lean_String_HasQuote___closed__2; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_74); +x_77 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_77, 0, x_76); +if (lean_is_scalar(x_69)) { + x_78 = lean_alloc_ctor(0, 2, 0); +} else { + x_78 = x_69; +} +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_68); +return x_78; +} +} +else +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +lean_dec(x_53); +x_79 = lean_ctor_get(x_4, 1); +lean_inc(x_79); +lean_dec(x_4); +x_80 = l_Lean_Delaborator_DelabM_inhabited___closed__1; +x_81 = l_unreachable_x21___rarg(x_80); +x_82 = lean_apply_3(x_81, x_1, x_2, x_79); +return x_82; +} +} +} +} +lean_object* _init_l___regBuiltin_Lean_Delaborator_delabLit___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lean_Delaborator_delabLit), 3, 0); +return x_1; +} +} +lean_object* l___regBuiltin_Lean_Delaborator_delabLit(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_Lean_Delaborator_delabAttribute; +x_3 = l_Lean_Delaborator_getExprKind___closed__24; +x_4 = l___regBuiltin_Lean_Delaborator_delabLit___closed__1; +x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); +return x_5; +} +} +lean_object* l_Lean_delab(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = lean_unsigned_to_nat(1u); +x_7 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_7, 0, x_1); +lean_ctor_set(x_7, 1, x_6); +lean_ctor_set(x_7, 2, x_2); +lean_ctor_set(x_7, 3, x_3); +lean_inc(x_4); +x_8 = l_Lean_Delaborator_delab(x_7, x_4, x_5); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; +x_9 = lean_ctor_get(x_8, 0); +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 = lean_ctor_get(x_8, 1); +lean_inc(x_10); +lean_dec(x_8); +x_11 = l_Lean_Meta_isClassQuick___main___closed__1; +x_12 = l_unreachable_x21___rarg(x_11); +x_13 = lean_apply_2(x_12, x_4, x_10); +return x_13; +} +else +{ +uint8_t x_14; +lean_dec(x_4); +x_14 = !lean_is_exclusive(x_8); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_ctor_get(x_8, 0); +lean_dec(x_15); +x_16 = lean_ctor_get(x_9, 0); +lean_inc(x_16); +lean_dec(x_9); +lean_ctor_set(x_8, 0, x_16); +return x_8; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_8, 1); +lean_inc(x_17); +lean_dec(x_8); +x_18 = lean_ctor_get(x_9, 0); +lean_inc(x_18); +lean_dec(x_9); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_17); +return x_19; +} +} +} +else +{ +uint8_t x_20; +lean_dec(x_4); +x_20 = !lean_is_exclusive(x_8); +if (x_20 == 0) +{ +return x_8; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_8, 0); +x_22 = lean_ctor_get(x_8, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_8); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +} lean_object* initialize_Init_Lean_KeyedDeclsAttribute(lean_object*); +lean_object* initialize_Init_Lean_Parser_Level(lean_object*); +lean_object* initialize_Init_Lean_Elab(lean_object*); static bool _G_initialized = false; lean_object* initialize_Init_Lean_Delaborator(lean_object* w) { lean_object * res; @@ -365,6 +13735,87 @@ _G_initialized = true; res = initialize_Init_Lean_KeyedDeclsAttribute(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); +res = initialize_Init_Lean_Parser_Level(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Init_Lean_Elab(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lean_Level_quote___main___lambda__1___closed__1 = _init_l_Lean_Level_quote___main___lambda__1___closed__1(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__1___closed__1); +l_Lean_Level_quote___main___lambda__1___closed__2 = _init_l_Lean_Level_quote___main___lambda__1___closed__2(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__1___closed__2); +l_Lean_Level_quote___main___lambda__1___closed__3 = _init_l_Lean_Level_quote___main___lambda__1___closed__3(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__1___closed__3); +l_Lean_Level_quote___main___lambda__1___closed__4 = _init_l_Lean_Level_quote___main___lambda__1___closed__4(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__1___closed__4); +l_Lean_Level_quote___main___lambda__1___closed__5 = _init_l_Lean_Level_quote___main___lambda__1___closed__5(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__1___closed__5); +l_Lean_Level_quote___main___lambda__1___closed__6 = _init_l_Lean_Level_quote___main___lambda__1___closed__6(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__1___closed__6); +l_Lean_Level_quote___main___lambda__2___closed__1 = _init_l_Lean_Level_quote___main___lambda__2___closed__1(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__2___closed__1); +l_Lean_Level_quote___main___lambda__4___closed__1 = _init_l_Lean_Level_quote___main___lambda__4___closed__1(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__4___closed__1); +l_Lean_Level_quote___main___lambda__4___closed__2 = _init_l_Lean_Level_quote___main___lambda__4___closed__2(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__4___closed__2); +l_Lean_Level_quote___main___lambda__6___closed__1 = _init_l_Lean_Level_quote___main___lambda__6___closed__1(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__6___closed__1); +l_Lean_Level_quote___main___lambda__6___closed__2 = _init_l_Lean_Level_quote___main___lambda__6___closed__2(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__6___closed__2); +l_Lean_Level_quote___main___lambda__9___closed__1 = _init_l_Lean_Level_quote___main___lambda__9___closed__1(); +lean_mark_persistent(l_Lean_Level_quote___main___lambda__9___closed__1); +l_Lean_Level_quote___main___closed__1 = _init_l_Lean_Level_quote___main___closed__1(); +lean_mark_persistent(l_Lean_Level_quote___main___closed__1); +l_Lean_Level_quote___main___closed__2 = _init_l_Lean_Level_quote___main___closed__2(); +lean_mark_persistent(l_Lean_Level_quote___main___closed__2); +l_Lean_Level_quote___main___closed__3 = _init_l_Lean_Level_quote___main___closed__3(); +lean_mark_persistent(l_Lean_Level_quote___main___closed__3); +l_Lean_Level_quote___main___closed__4 = _init_l_Lean_Level_quote___main___closed__4(); +lean_mark_persistent(l_Lean_Level_quote___main___closed__4); +l_Lean_Level_quote___main___closed__5 = _init_l_Lean_Level_quote___main___closed__5(); +lean_mark_persistent(l_Lean_Level_quote___main___closed__5); +l_Lean_Level_quote___main___closed__6 = _init_l_Lean_Level_quote___main___closed__6(); +lean_mark_persistent(l_Lean_Level_quote___main___closed__6); +l_Lean_Level_HasQuote___closed__1 = _init_l_Lean_Level_HasQuote___closed__1(); +lean_mark_persistent(l_Lean_Level_HasQuote___closed__1); +l_Lean_Level_HasQuote = _init_l_Lean_Level_HasQuote(); +lean_mark_persistent(l_Lean_Level_HasQuote); +l_Lean_getPPBinderTypes___closed__1 = _init_l_Lean_getPPBinderTypes___closed__1(); +lean_mark_persistent(l_Lean_getPPBinderTypes___closed__1); +l_Lean_getPPBinderTypes___closed__2 = _init_l_Lean_getPPBinderTypes___closed__2(); +lean_mark_persistent(l_Lean_getPPBinderTypes___closed__2); +l_Lean_getPPBinderTypes___closed__3 = _init_l_Lean_getPPBinderTypes___closed__3(); +lean_mark_persistent(l_Lean_getPPBinderTypes___closed__3); +l_Lean_getPPBinderTypes___closed__4 = _init_l_Lean_getPPBinderTypes___closed__4(); +lean_mark_persistent(l_Lean_getPPBinderTypes___closed__4); +l_Lean_getPPExplicit___closed__1 = _init_l_Lean_getPPExplicit___closed__1(); +lean_mark_persistent(l_Lean_getPPExplicit___closed__1); +l_Lean_getPPUniverses___closed__1 = _init_l_Lean_getPPUniverses___closed__1(); +lean_mark_persistent(l_Lean_getPPUniverses___closed__1); +l_Lean_getPPAll___closed__1 = _init_l_Lean_getPPAll___closed__1(); +lean_mark_persistent(l_Lean_getPPAll___closed__1); +l_Lean_getPPAll___closed__2 = _init_l_Lean_getPPAll___closed__2(); +lean_mark_persistent(l_Lean_getPPAll___closed__2); +l_Lean_ppOptions___closed__1 = _init_l_Lean_ppOptions___closed__1(); +lean_mark_persistent(l_Lean_ppOptions___closed__1); +l_Lean_ppOptions___closed__2 = _init_l_Lean_ppOptions___closed__2(); +lean_mark_persistent(l_Lean_ppOptions___closed__2); +res = l_Lean_ppOptions(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lean_Delaborator_DelabM_inhabited___closed__1 = _init_l_Lean_Delaborator_DelabM_inhabited___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_DelabM_inhabited___closed__1); +l_Lean_Delaborator_DelabM_monadQuotation___closed__1 = _init_l_Lean_Delaborator_DelabM_monadQuotation___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_DelabM_monadQuotation___closed__1); +l_Lean_Delaborator_DelabM_monadQuotation___closed__2 = _init_l_Lean_Delaborator_DelabM_monadQuotation___closed__2(); +lean_mark_persistent(l_Lean_Delaborator_DelabM_monadQuotation___closed__2); +l_Lean_Delaborator_DelabM_monadQuotation___closed__3 = _init_l_Lean_Delaborator_DelabM_monadQuotation___closed__3(); +lean_mark_persistent(l_Lean_Delaborator_DelabM_monadQuotation___closed__3); +l_Lean_Delaborator_DelabM_monadQuotation___closed__4 = _init_l_Lean_Delaborator_DelabM_monadQuotation___closed__4(); +lean_mark_persistent(l_Lean_Delaborator_DelabM_monadQuotation___closed__4); +l_Lean_Delaborator_DelabM_monadQuotation = _init_l_Lean_Delaborator_DelabM_monadQuotation(); +lean_mark_persistent(l_Lean_Delaborator_DelabM_monadQuotation); l_Lean_Delaborator_mkDelabAttribute___lambda__1___closed__1 = _init_l_Lean_Delaborator_mkDelabAttribute___lambda__1___closed__1(); lean_mark_persistent(l_Lean_Delaborator_mkDelabAttribute___lambda__1___closed__1); l_Lean_Delaborator_mkDelabAttribute___lambda__1___closed__2 = _init_l_Lean_Delaborator_mkDelabAttribute___lambda__1___closed__2(); @@ -418,6 +13869,193 @@ if (lean_io_result_is_error(res)) return res; l_Lean_Delaborator_delabAttribute = lean_io_result_get_value(res); lean_mark_persistent(l_Lean_Delaborator_delabAttribute); lean_dec_ref(res); +l_Lean_Delaborator_getExprKind___closed__1 = _init_l_Lean_Delaborator_getExprKind___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__1); +l_Lean_Delaborator_getExprKind___closed__2 = _init_l_Lean_Delaborator_getExprKind___closed__2(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__2); +l_Lean_Delaborator_getExprKind___closed__3 = _init_l_Lean_Delaborator_getExprKind___closed__3(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__3); +l_Lean_Delaborator_getExprKind___closed__4 = _init_l_Lean_Delaborator_getExprKind___closed__4(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__4); +l_Lean_Delaborator_getExprKind___closed__5 = _init_l_Lean_Delaborator_getExprKind___closed__5(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__5); +l_Lean_Delaborator_getExprKind___closed__6 = _init_l_Lean_Delaborator_getExprKind___closed__6(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__6); +l_Lean_Delaborator_getExprKind___closed__7 = _init_l_Lean_Delaborator_getExprKind___closed__7(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__7); +l_Lean_Delaborator_getExprKind___closed__8 = _init_l_Lean_Delaborator_getExprKind___closed__8(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__8); +l_Lean_Delaborator_getExprKind___closed__9 = _init_l_Lean_Delaborator_getExprKind___closed__9(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__9); +l_Lean_Delaborator_getExprKind___closed__10 = _init_l_Lean_Delaborator_getExprKind___closed__10(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__10); +l_Lean_Delaborator_getExprKind___closed__11 = _init_l_Lean_Delaborator_getExprKind___closed__11(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__11); +l_Lean_Delaborator_getExprKind___closed__12 = _init_l_Lean_Delaborator_getExprKind___closed__12(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__12); +l_Lean_Delaborator_getExprKind___closed__13 = _init_l_Lean_Delaborator_getExprKind___closed__13(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__13); +l_Lean_Delaborator_getExprKind___closed__14 = _init_l_Lean_Delaborator_getExprKind___closed__14(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__14); +l_Lean_Delaborator_getExprKind___closed__15 = _init_l_Lean_Delaborator_getExprKind___closed__15(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__15); +l_Lean_Delaborator_getExprKind___closed__16 = _init_l_Lean_Delaborator_getExprKind___closed__16(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__16); +l_Lean_Delaborator_getExprKind___closed__17 = _init_l_Lean_Delaborator_getExprKind___closed__17(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__17); +l_Lean_Delaborator_getExprKind___closed__18 = _init_l_Lean_Delaborator_getExprKind___closed__18(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__18); +l_Lean_Delaborator_getExprKind___closed__19 = _init_l_Lean_Delaborator_getExprKind___closed__19(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__19); +l_Lean_Delaborator_getExprKind___closed__20 = _init_l_Lean_Delaborator_getExprKind___closed__20(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__20); +l_Lean_Delaborator_getExprKind___closed__21 = _init_l_Lean_Delaborator_getExprKind___closed__21(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__21); +l_Lean_Delaborator_getExprKind___closed__22 = _init_l_Lean_Delaborator_getExprKind___closed__22(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__22); +l_Lean_Delaborator_getExprKind___closed__23 = _init_l_Lean_Delaborator_getExprKind___closed__23(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__23); +l_Lean_Delaborator_getExprKind___closed__24 = _init_l_Lean_Delaborator_getExprKind___closed__24(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__24); +l_Lean_Delaborator_getExprKind___closed__25 = _init_l_Lean_Delaborator_getExprKind___closed__25(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__25); +l_Lean_Delaborator_getExprKind___closed__26 = _init_l_Lean_Delaborator_getExprKind___closed__26(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__26); +l_Lean_Delaborator_getExprKind___closed__27 = _init_l_Lean_Delaborator_getExprKind___closed__27(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__27); +l_Lean_Delaborator_getExprKind___closed__28 = _init_l_Lean_Delaborator_getExprKind___closed__28(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__28); +l_Lean_Delaborator_getExprKind___closed__29 = _init_l_Lean_Delaborator_getExprKind___closed__29(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__29); +l_Lean_Delaborator_getExprKind___closed__30 = _init_l_Lean_Delaborator_getExprKind___closed__30(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__30); +l_Lean_Delaborator_getExprKind___closed__31 = _init_l_Lean_Delaborator_getExprKind___closed__31(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__31); +l_Lean_Delaborator_getExprKind___closed__32 = _init_l_Lean_Delaborator_getExprKind___closed__32(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__32); +l_Lean_Delaborator_getExprKind___closed__33 = _init_l_Lean_Delaborator_getExprKind___closed__33(); +lean_mark_persistent(l_Lean_Delaborator_getExprKind___closed__33); +l_Lean_Delaborator_getPPOption___closed__1 = _init_l_Lean_Delaborator_getPPOption___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_getPPOption___closed__1); +l_Lean_Delaborator_infoForPos___closed__1 = _init_l_Lean_Delaborator_infoForPos___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_infoForPos___closed__1); +l_Lean_Delaborator_infoForPos___closed__2 = _init_l_Lean_Delaborator_infoForPos___closed__2(); +lean_mark_persistent(l_Lean_Delaborator_infoForPos___closed__2); +l_Lean_Delaborator_delab___closed__1 = _init_l_Lean_Delaborator_delab___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_delab___closed__1); +l___regBuiltin_Lean_Delaborator_delabFVar___closed__1 = _init_l___regBuiltin_Lean_Delaborator_delabFVar___closed__1(); +lean_mark_persistent(l___regBuiltin_Lean_Delaborator_delabFVar___closed__1); +res = l___regBuiltin_Lean_Delaborator_delabFVar(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lean_Delaborator_delabMVar___closed__1 = _init_l_Lean_Delaborator_delabMVar___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_delabMVar___closed__1); +l_Lean_Delaborator_delabMVar___closed__2 = _init_l_Lean_Delaborator_delabMVar___closed__2(); +lean_mark_persistent(l_Lean_Delaborator_delabMVar___closed__2); +l___regBuiltin_Lean_Delaborator_delabMVar___closed__1 = _init_l___regBuiltin_Lean_Delaborator_delabMVar___closed__1(); +lean_mark_persistent(l___regBuiltin_Lean_Delaborator_delabMVar___closed__1); +res = l___regBuiltin_Lean_Delaborator_delabMVar(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lean_Delaborator_delabSort___closed__1 = _init_l_Lean_Delaborator_delabSort___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__1); +l_Lean_Delaborator_delabSort___closed__2 = _init_l_Lean_Delaborator_delabSort___closed__2(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__2); +l_Lean_Delaborator_delabSort___closed__3 = _init_l_Lean_Delaborator_delabSort___closed__3(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__3); +l_Lean_Delaborator_delabSort___closed__4 = _init_l_Lean_Delaborator_delabSort___closed__4(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__4); +l_Lean_Delaborator_delabSort___closed__5 = _init_l_Lean_Delaborator_delabSort___closed__5(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__5); +l_Lean_Delaborator_delabSort___closed__6 = _init_l_Lean_Delaborator_delabSort___closed__6(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__6); +l_Lean_Delaborator_delabSort___closed__7 = _init_l_Lean_Delaborator_delabSort___closed__7(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__7); +l_Lean_Delaborator_delabSort___closed__8 = _init_l_Lean_Delaborator_delabSort___closed__8(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__8); +l_Lean_Delaborator_delabSort___closed__9 = _init_l_Lean_Delaborator_delabSort___closed__9(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__9); +l_Lean_Delaborator_delabSort___closed__10 = _init_l_Lean_Delaborator_delabSort___closed__10(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__10); +l_Lean_Delaborator_delabSort___closed__11 = _init_l_Lean_Delaborator_delabSort___closed__11(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__11); +l_Lean_Delaborator_delabSort___closed__12 = _init_l_Lean_Delaborator_delabSort___closed__12(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__12); +l_Lean_Delaborator_delabSort___closed__13 = _init_l_Lean_Delaborator_delabSort___closed__13(); +lean_mark_persistent(l_Lean_Delaborator_delabSort___closed__13); +l___regBuiltin_Lean_Delaborator_delabSort___closed__1 = _init_l___regBuiltin_Lean_Delaborator_delabSort___closed__1(); +lean_mark_persistent(l___regBuiltin_Lean_Delaborator_delabSort___closed__1); +res = l___regBuiltin_Lean_Delaborator_delabSort(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lean_Delaborator_delabConst___closed__1 = _init_l_Lean_Delaborator_delabConst___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_delabConst___closed__1); +l_Lean_Delaborator_delabConst___closed__2 = _init_l_Lean_Delaborator_delabConst___closed__2(); +lean_mark_persistent(l_Lean_Delaborator_delabConst___closed__2); +l_Lean_Delaborator_delabConst___closed__3 = _init_l_Lean_Delaborator_delabConst___closed__3(); +lean_mark_persistent(l_Lean_Delaborator_delabConst___closed__3); +l_Lean_Delaborator_delabConst___closed__4 = _init_l_Lean_Delaborator_delabConst___closed__4(); +lean_mark_persistent(l_Lean_Delaborator_delabConst___closed__4); +l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__1 = _init_l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__1(); +lean_mark_persistent(l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__1); +l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__2 = _init_l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__2(); +lean_mark_persistent(l_Array_umapMAux___main___at_Lean_Delaborator_getImplicitParams___spec__1___closed__2); +l_Lean_Delaborator_getImplicitParams___closed__1 = _init_l_Lean_Delaborator_getImplicitParams___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_getImplicitParams___closed__1); +l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__1 = _init_l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__1); +l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__2 = _init_l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__2(); +lean_mark_persistent(l_Lean_Delaborator_delabAppExplicit___lambda__1___closed__2); +l_Lean_Delaborator_delabAppExplicit___closed__1 = _init_l_Lean_Delaborator_delabAppExplicit___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_delabAppExplicit___closed__1); +l_Lean_Delaborator_delabAppExplicit___closed__2 = _init_l_Lean_Delaborator_delabAppExplicit___closed__2(); +lean_mark_persistent(l_Lean_Delaborator_delabAppExplicit___closed__2); +l_Lean_Delaborator_delabAppExplicit___closed__3 = _init_l_Lean_Delaborator_delabAppExplicit___closed__3(); +lean_mark_persistent(l_Lean_Delaborator_delabAppExplicit___closed__3); +l_Lean_Delaborator_delabAppExplicit___closed__4 = _init_l_Lean_Delaborator_delabAppExplicit___closed__4(); +lean_mark_persistent(l_Lean_Delaborator_delabAppExplicit___closed__4); +l___regBuiltin_Lean_Delaborator_delabAppExplicit___closed__1 = _init_l___regBuiltin_Lean_Delaborator_delabAppExplicit___closed__1(); +lean_mark_persistent(l___regBuiltin_Lean_Delaborator_delabAppExplicit___closed__1); +res = l___regBuiltin_Lean_Delaborator_delabAppExplicit(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lean_Delaborator_delabAppImplicit___closed__1 = _init_l_Lean_Delaborator_delabAppImplicit___closed__1(); +lean_mark_persistent(l_Lean_Delaborator_delabAppImplicit___closed__1); +l_Lean_Delaborator_delabAppImplicit___closed__2 = _init_l_Lean_Delaborator_delabAppImplicit___closed__2(); +lean_mark_persistent(l_Lean_Delaborator_delabAppImplicit___closed__2); +l_Lean_Delaborator_delabAppImplicit___closed__3 = _init_l_Lean_Delaborator_delabAppImplicit___closed__3(); +lean_mark_persistent(l_Lean_Delaborator_delabAppImplicit___closed__3); +l_Lean_Delaborator_delabAppImplicit___closed__4 = _init_l_Lean_Delaborator_delabAppImplicit___closed__4(); +lean_mark_persistent(l_Lean_Delaborator_delabAppImplicit___closed__4); +l_Lean_Delaborator_delabAppImplicit___closed__5 = _init_l_Lean_Delaborator_delabAppImplicit___closed__5(); +lean_mark_persistent(l_Lean_Delaborator_delabAppImplicit___closed__5); +l_Lean_Delaborator_delabAppImplicit___closed__6 = _init_l_Lean_Delaborator_delabAppImplicit___closed__6(); +lean_mark_persistent(l_Lean_Delaborator_delabAppImplicit___closed__6); +l_Lean_Delaborator_delabAppImplicit___closed__7 = _init_l_Lean_Delaborator_delabAppImplicit___closed__7(); +lean_mark_persistent(l_Lean_Delaborator_delabAppImplicit___closed__7); +l___regBuiltin_Lean_Delaborator_delabAppImplicit___closed__1 = _init_l___regBuiltin_Lean_Delaborator_delabAppImplicit___closed__1(); +lean_mark_persistent(l___regBuiltin_Lean_Delaborator_delabAppImplicit___closed__1); +res = l___regBuiltin_Lean_Delaborator_delabAppImplicit(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__1 = _init_l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__1); +l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__2 = _init_l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__2); +l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3 = _init_l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Delaborator_1__shouldGroupWithNext___closed__3); +l___private_Init_Lean_Delaborator_2__delabLamAux___main___closed__1 = _init_l___private_Init_Lean_Delaborator_2__delabLamAux___main___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Delaborator_2__delabLamAux___main___closed__1); +l___regBuiltin_Lean_Delaborator_delabExplicitLam___closed__1 = _init_l___regBuiltin_Lean_Delaborator_delabExplicitLam___closed__1(); +lean_mark_persistent(l___regBuiltin_Lean_Delaborator_delabExplicitLam___closed__1); +res = l___regBuiltin_Lean_Delaborator_delabExplicitLam(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l___regBuiltin_Lean_Delaborator_delabLit___closed__1 = _init_l___regBuiltin_Lean_Delaborator_delabLit___closed__1(); +lean_mark_persistent(l___regBuiltin_Lean_Delaborator_delabLit___closed__1); +res = l___regBuiltin_Lean_Delaborator_delabLit(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); return lean_mk_io_result(lean_box(0)); } #ifdef __cplusplus diff --git a/stage0/stdlib/Init/Lean/Elab/App.c b/stage0/stdlib/Init/Lean/Elab/App.c index 8da882cb8d..fc5a08e1b6 100644 --- a/stage0/stdlib/Init/Lean/Elab/App.c +++ b/stage0/stdlib/Init/Lean/Elab/App.c @@ -86,7 +86,6 @@ lean_object* lean_expr_instantiate1(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_App_23__toMessageData___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_NamedArg_hasToString(lean_object*); lean_object* lean_array_push(lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; lean_object* lean_array_get_size(lean_object*); lean_object* l___private_Init_Lean_Elab_App_19__elabAppLVals___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_string_append(lean_object*, lean_object*); @@ -104,7 +103,6 @@ lean_object* l_Lean_Elab_Term_synthesizeAppInstMVars(lean_object*, lean_object*, lean_object* l___regBuiltin_Lean_Elab_Term_elabId(lean_object*); lean_object* l___private_Init_Lean_Elab_App_19__elabAppLVals(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_addNamedArg___closed__6; -lean_object* l___private_Init_Lean_Elab_App_23__toMessageData___closed__2; extern lean_object* l_Lean_Parser_Term_sort___elambda__1___closed__2; lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabSortApp___closed__1; @@ -168,6 +166,7 @@ extern lean_object* l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign_ lean_object* l_Lean_Syntax_replaceInfo___main(lean_object*, lean_object*); lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Elab_Term_mkConst___closed__4; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; lean_object* l___private_Init_Lean_Elab_App_24__mergeFailures___rarg___closed__2; lean_object* l_Lean_FindMVar_main___main___at___private_Init_Lean_Elab_App_7__hasOnlyTypeMVar___spec__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_NamedArg_inhabited___closed__1; @@ -237,7 +236,6 @@ lean_object* l___private_Init_Lean_Elab_App_17__addLValArg___main___closed__6; lean_object* l___regBuiltin_Lean_Elab_Term_elabProj___closed__1; uint8_t l_Lean_Expr_isAutoParam(lean_object*); extern lean_object* l_Lean_Parser_Term_arrayRef___elambda__1___closed__2; -lean_object* l_Lean_Elab_getPosition___at___private_Init_Lean_Elab_App_23__toMessageData___spec__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_App_11__elabAppArgs___closed__8; lean_object* l___private_Init_Lean_Elab_App_10__elabAppArgsAux___main___closed__7; @@ -266,7 +264,6 @@ lean_object* l___private_Init_Lean_Elab_App_17__addLValArg___boxed(lean_object*, extern lean_object* l_Option_HasRepr___rarg___closed__3; uint8_t l_Array_anyRangeMAux___main___at___private_Init_Lean_Elab_App_6__hasTypeMVar___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_App_13__resolveLValAux___closed__2; -extern lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8; uint8_t l_Array_anyRangeMAux___main___at_Lean_Elab_Term_addNamedArg___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Syntax_inhabited; lean_object* l___private_Init_Lean_Elab_App_22__getSuccess(lean_object*); @@ -312,7 +309,6 @@ lean_object* l___private_Init_Lean_Elab_App_18__elabAppLValsAux___main___boxed(l lean_object* l___private_Init_Lean_Elab_App_10__elabAppArgsAux___main___closed__3; lean_object* l___private_Init_Lean_Elab_App_18__elabAppLValsAux___main___closed__1; lean_object* l_Lean_Elab_Term_whnfCore(lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Util_1__mkPanicMessage___closed__2; lean_object* l___private_Init_Lean_Elab_App_24__mergeFailures___rarg___closed__3; lean_object* l___private_Init_Lean_Elab_App_13__resolveLValAux___closed__1; extern lean_object* l_Lean_mkHole___closed__1; @@ -344,6 +340,7 @@ lean_object* l___private_Init_Lean_Elab_App_18__elabAppLValsAux___main(lean_obje uint8_t l_Lean_Expr_hasLooseBVars(lean_object*); lean_object* l___private_Init_Lean_Elab_App_23__toMessageData(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_addNamedArg___closed__1; +extern lean_object* l_Lean_KernelException_toMessageData___closed__12; lean_object* l_Array_toList___rarg(lean_object*); lean_object* l_Lean_Elab_Term_addNamedArg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabArrayRef___closed__1; @@ -367,7 +364,7 @@ uint8_t l_Lean_Position_DecidableEq(lean_object*, lean_object*); lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*); extern lean_object* l_Lean_mkOptionalNode___closed__2; lean_object* l___private_Init_Lean_Elab_App_13__resolveLValAux___closed__7; -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_object*, lean_object*); extern lean_object* l_Nat_Inhabited; extern lean_object* l___private_Init_Lean_Elab_Util_4__regTraceClasses___closed__1; extern lean_object* l_System_FilePath_dirName___closed__1; @@ -397,6 +394,7 @@ lean_object* l_Array_findIdxAux___main___at___private_Init_Lean_Elab_App_10__ela lean_object* l___private_Init_Lean_Elab_App_13__resolveLValAux___closed__14; lean_object* l_Lean_Elab_Term_ensureHasTypeAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_insertAt___rarg(lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Syntax_6__formatInfo___closed__1; lean_object* l___private_Init_Lean_Elab_App_13__resolveLValAux___closed__28; lean_object* l_Lean_findField_x3f___main(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_App_11__elabAppArgs___closed__6; @@ -440,26 +438,27 @@ _start: { if (lean_obj_tag(x_1) == 0) { -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_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); lean_dec(x_1); x_3 = lean_box(0); -x_4 = lean_unsigned_to_nat(0u); -x_5 = l_Lean_Syntax_formatStxAux___main(x_3, x_4, x_2); -x_6 = l_Lean_Options_empty; -x_7 = l_Lean_Format_pretty(x_5, x_6); -return x_7; +x_4 = 0; +x_5 = lean_unsigned_to_nat(0u); +x_6 = l_Lean_Syntax_formatStxAux___main(x_3, x_4, x_5, x_2); +x_7 = l_Lean_Options_empty; +x_8 = l_Lean_Format_pretty(x_6, x_7); +return x_8; } else { -lean_object* x_8; lean_object* x_9; -x_8 = lean_ctor_get(x_1, 0); -lean_inc(x_8); +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_1, 0); +lean_inc(x_9); lean_dec(x_1); -x_9 = lean_expr_dbg_to_string(x_8); -lean_dec(x_8); -return x_9; +x_10 = lean_expr_dbg_to_string(x_9); +lean_dec(x_9); +return x_10; } } } @@ -481,34 +480,35 @@ lean_inc(x_9); lean_dec(x_1); 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_17; lean_object* x_18; +lean_object* x_10; lean_object* x_11; uint8_t 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_10 = lean_ctor_get(x_9, 0); lean_inc(x_10); lean_dec(x_9); x_11 = lean_box(0); -x_12 = lean_unsigned_to_nat(0u); -x_13 = l_Lean_Syntax_formatStxAux___main(x_11, x_12, x_10); -x_14 = l_Lean_Options_empty; -x_15 = l_Lean_Format_pretty(x_13, x_14); -x_16 = lean_string_append(x_8, x_15); -lean_dec(x_15); -x_17 = l_Option_HasRepr___rarg___closed__3; -x_18 = lean_string_append(x_16, x_17); -return x_18; +x_12 = 0; +x_13 = lean_unsigned_to_nat(0u); +x_14 = l_Lean_Syntax_formatStxAux___main(x_11, x_12, x_13, x_10); +x_15 = l_Lean_Options_empty; +x_16 = l_Lean_Format_pretty(x_14, x_15); +x_17 = lean_string_append(x_8, x_16); +lean_dec(x_16); +x_18 = l_Option_HasRepr___rarg___closed__3; +x_19 = lean_string_append(x_17, x_18); +return x_19; } else { -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_9, 0); -lean_inc(x_19); +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_20 = lean_ctor_get(x_9, 0); +lean_inc(x_20); lean_dec(x_9); -x_20 = lean_expr_dbg_to_string(x_19); -lean_dec(x_19); -x_21 = lean_string_append(x_8, x_20); +x_21 = lean_expr_dbg_to_string(x_20); lean_dec(x_20); -x_22 = l_Option_HasRepr___rarg___closed__3; -x_23 = lean_string_append(x_21, x_22); -return x_23; +x_22 = lean_string_append(x_8, x_21); +lean_dec(x_21); +x_23 = l_Option_HasRepr___rarg___closed__3; +x_24 = lean_string_append(x_22, x_23); +return x_24; } } } @@ -3166,6 +3166,7 @@ lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_inc(x_2); x_161 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_161, 0, x_2); +lean_inc(x_4); x_162 = l_Lean_Elab_Term_logTrace(x_159, x_6, x_161, x_4, x_158); x_163 = lean_ctor_get(x_162, 1); lean_inc(x_163); @@ -3630,6 +3631,7 @@ lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_inc(x_2); x_278 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_278, 0, x_2); +lean_inc(x_4); x_279 = l_Lean_Elab_Term_logTrace(x_276, x_6, x_278, x_4, x_275); x_280 = lean_ctor_get(x_279, 1); lean_inc(x_280); @@ -4014,6 +4016,7 @@ lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_inc(x_2); x_353 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_353, 0, x_2); +lean_inc(x_4); x_354 = l_Lean_Elab_Term_logTrace(x_351, x_6, x_353, x_4, x_350); x_355 = lean_ctor_get(x_354, 1); lean_inc(x_355); @@ -4487,6 +4490,7 @@ lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_inc(x_2); x_468 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_468, 0, x_2); +lean_inc(x_4); x_469 = l_Lean_Elab_Term_logTrace(x_466, x_6, x_468, x_4, x_465); x_470 = lean_ctor_get(x_469, 1); lean_inc(x_470); @@ -5107,6 +5111,7 @@ lean_object* x_606; lean_object* x_607; lean_object* x_608; lean_inc(x_2); x_606 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_606, 0, x_2); +lean_inc(x_4); x_607 = l_Lean_Elab_Term_logTrace(x_604, x_6, x_606, x_4, x_603); x_608 = lean_ctor_get(x_607, 1); lean_inc(x_608); @@ -5453,6 +5458,7 @@ lean_object* x_677; lean_object* x_678; lean_object* x_679; lean_inc(x_2); x_677 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_677, 0, x_2); +lean_inc(x_4); x_678 = l_Lean_Elab_Term_logTrace(x_675, x_6, x_677, x_4, x_674); x_679 = lean_ctor_get(x_678, 1); lean_inc(x_679); @@ -5855,6 +5861,7 @@ lean_object* x_763; lean_object* x_764; lean_object* x_765; lean_inc(x_2); x_763 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_763, 0, x_2); +lean_inc(x_4); x_764 = l_Lean_Elab_Term_logTrace(x_761, x_6, x_763, x_4, x_760); x_765 = lean_ctor_get(x_764, 1); lean_inc(x_765); @@ -6319,6 +6326,7 @@ lean_object* x_880; lean_object* x_881; lean_object* x_882; lean_inc(x_2); x_880 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_880, 0, x_2); +lean_inc(x_4); x_881 = l_Lean_Elab_Term_logTrace(x_878, x_6, x_880, x_4, x_877); x_882 = lean_ctor_get(x_881, 1); lean_inc(x_882); @@ -6703,6 +6711,7 @@ lean_object* x_955; lean_object* x_956; lean_object* x_957; lean_inc(x_2); x_955 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_955, 0, x_2); +lean_inc(x_4); x_956 = l_Lean_Elab_Term_logTrace(x_953, x_6, x_955, x_4, x_952); x_957 = lean_ctor_get(x_956, 1); lean_inc(x_957); @@ -7176,6 +7185,7 @@ lean_object* x_1070; lean_object* x_1071; lean_object* x_1072; lean_inc(x_2); x_1070 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1070, 0, x_2); +lean_inc(x_4); x_1071 = l_Lean_Elab_Term_logTrace(x_1068, x_6, x_1070, x_4, x_1067); x_1072 = lean_ctor_get(x_1071, 1); lean_inc(x_1072); @@ -7652,6 +7662,7 @@ lean_object* x_1184; lean_object* x_1185; lean_object* x_1186; lean_inc(x_2); x_1184 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1184, 0, x_2); +lean_inc(x_4); x_1185 = l_Lean_Elab_Term_logTrace(x_1182, x_6, x_1184, x_4, x_1181); x_1186 = lean_ctor_get(x_1185, 1); lean_inc(x_1186); @@ -7998,6 +8009,7 @@ lean_object* x_1255; lean_object* x_1256; lean_object* x_1257; lean_inc(x_2); x_1255 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1255, 0, x_2); +lean_inc(x_4); x_1256 = l_Lean_Elab_Term_logTrace(x_1253, x_6, x_1255, x_4, x_1252); x_1257 = lean_ctor_get(x_1256, 1); lean_inc(x_1257); @@ -8495,6 +8507,7 @@ lean_object* x_1376; lean_object* x_1377; lean_object* x_1378; lean_inc(x_2); x_1376 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1376, 0, x_2); +lean_inc(x_4); x_1377 = l_Lean_Elab_Term_logTrace(x_1374, x_6, x_1376, x_4, x_1373); x_1378 = lean_ctor_get(x_1377, 1); lean_inc(x_1378); @@ -8959,6 +8972,7 @@ lean_object* x_1493; lean_object* x_1494; lean_object* x_1495; lean_inc(x_2); x_1493 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1493, 0, x_2); +lean_inc(x_4); x_1494 = l_Lean_Elab_Term_logTrace(x_1491, x_6, x_1493, x_4, x_1490); x_1495 = lean_ctor_get(x_1494, 1); lean_inc(x_1495); @@ -9343,6 +9357,7 @@ lean_object* x_1568; lean_object* x_1569; lean_object* x_1570; lean_inc(x_2); x_1568 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1568, 0, x_2); +lean_inc(x_4); x_1569 = l_Lean_Elab_Term_logTrace(x_1566, x_6, x_1568, x_4, x_1565); x_1570 = lean_ctor_get(x_1569, 1); lean_inc(x_1570); @@ -9816,6 +9831,7 @@ lean_object* x_1683; lean_object* x_1684; lean_object* x_1685; lean_inc(x_2); x_1683 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1683, 0, x_2); +lean_inc(x_4); x_1684 = l_Lean_Elab_Term_logTrace(x_1681, x_6, x_1683, x_4, x_1680); x_1685 = lean_ctor_get(x_1684, 1); lean_inc(x_1685); @@ -10521,6 +10537,7 @@ lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_inc(x_2); x_86 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_86, 0, x_2); +lean_inc(x_4); x_87 = l_Lean_Elab_Term_logTrace(x_84, x_6, x_86, x_4, x_83); x_88 = lean_ctor_get(x_87, 1); lean_inc(x_88); @@ -10908,6 +10925,7 @@ lean_ctor_set(x_56, 1, x_55); x_57 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_57, 0, x_56); lean_ctor_set(x_57, 1, x_52); +lean_inc(x_7); x_58 = l_Lean_Elab_Term_logTrace(x_49, x_1, x_57, x_7, x_48); x_59 = lean_ctor_get(x_58, 1); lean_inc(x_59); @@ -10929,6 +10947,7 @@ lean_ctor_set(x_63, 1, x_62); x_64 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_64, 0, x_63); lean_ctor_set(x_64, 1, x_52); +lean_inc(x_7); x_65 = l_Lean_Elab_Term_logTrace(x_49, x_1, x_64, x_7, x_48); x_66 = lean_ctor_get(x_65, 1); lean_inc(x_66); @@ -11133,7 +11152,7 @@ x_10 = l_Lean_MessageData_ofList___closed__3; x_11 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_11, 0, x_9); lean_ctor_set(x_11, 1, x_10); -x_12 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8; +x_12 = l_Lean_KernelException_toMessageData___closed__12; x_13 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_13, 0, x_11); lean_ctor_set(x_13, 1, x_12); @@ -17235,8 +17254,12 @@ if (lean_obj_tag(x_1) == 0) { lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; x_4 = lean_ctor_get(x_2, 2); +lean_inc(x_4); x_5 = lean_ctor_get(x_2, 3); +lean_inc(x_5); +lean_dec(x_2); x_6 = l_Lean_FileMap_toPosition(x_4, x_5); +lean_dec(x_4); x_7 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_7, 0, x_6); lean_ctor_set(x_7, 1, x_3); @@ -17246,8 +17269,13 @@ else { lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; x_8 = lean_ctor_get(x_2, 2); +lean_inc(x_8); +lean_dec(x_2); x_9 = lean_ctor_get(x_1, 0); +lean_inc(x_9); +lean_dec(x_1); x_10 = l_Lean_FileMap_toPosition(x_8, x_9); +lean_dec(x_8); x_11 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_11, 0, x_10); lean_ctor_set(x_11, 1, x_3); @@ -17259,17 +17287,7 @@ lean_object* _init_l___private_Init_Lean_Elab_App_23__toMessageData___closed__1( _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Util_1__mkPanicMessage___closed__2; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l___private_Init_Lean_Elab_App_23__toMessageData___closed__2() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_App_23__toMessageData___closed__1; +x_1 = l___private_Init_Lean_Syntax_6__formatInfo___closed__1; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; @@ -17288,7 +17306,6 @@ lean_dec(x_5); x_8 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_8, 0, x_6); x_9 = l_Lean_Elab_getPosition___at___private_Init_Lean_Elab_App_23__toMessageData___spec__1(x_8, x_3, x_7); -lean_dec(x_8); x_10 = !lean_is_exclusive(x_9); if (x_10 == 0) { @@ -17308,7 +17325,7 @@ x_16 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_16, 0, x_15); x_17 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_17, 0, x_16); -x_18 = l___private_Init_Lean_Elab_App_23__toMessageData___closed__2; +x_18 = l___private_Init_Lean_Elab_App_23__toMessageData___closed__1; x_19 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_19, 0, x_17); lean_ctor_set(x_19, 1, x_18); @@ -17369,7 +17386,7 @@ x_36 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_36, 0, x_35); x_37 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_37, 0, x_36); -x_38 = l___private_Init_Lean_Elab_App_23__toMessageData___closed__2; +x_38 = l___private_Init_Lean_Elab_App_23__toMessageData___closed__1; x_39 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_39, 0, x_37); lean_ctor_set(x_39, 1, x_38); @@ -17414,22 +17431,11 @@ return x_51; } } } -lean_object* l_Lean_Elab_getPosition___at___private_Init_Lean_Elab_App_23__toMessageData___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -lean_object* x_4; -x_4 = l_Lean_Elab_getPosition___at___private_Init_Lean_Elab_App_23__toMessageData___spec__1(x_1, x_2, x_3); -lean_dec(x_2); -lean_dec(x_1); -return x_4; -} -} lean_object* l___private_Init_Lean_Elab_App_23__toMessageData___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_Init_Lean_Elab_App_23__toMessageData(x_1, x_2, x_3, x_4); -lean_dec(x_3); lean_dec(x_2); return x_5; } @@ -17462,7 +17468,7 @@ if (lean_obj_tag(x_12) == 0) { lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_dec(x_12); -x_13 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_13 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_14 = l_unreachable_x21___rarg(x_13); lean_inc(x_4); x_15 = lean_apply_2(x_14, x_4, x_5); @@ -17516,6 +17522,7 @@ lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean x_27 = lean_ctor_get(x_12, 0); lean_inc(x_27); lean_dec(x_12); +lean_inc(x_4); x_28 = l___private_Init_Lean_Elab_App_23__toMessageData(x_27, x_1, x_4, x_5); x_29 = lean_ctor_get(x_28, 0); lean_inc(x_29); @@ -19136,8 +19143,6 @@ l___private_Init_Lean_Elab_App_19__elabAppLVals___closed__3 = _init_l___private_ lean_mark_persistent(l___private_Init_Lean_Elab_App_19__elabAppLVals___closed__3); l___private_Init_Lean_Elab_App_23__toMessageData___closed__1 = _init_l___private_Init_Lean_Elab_App_23__toMessageData___closed__1(); lean_mark_persistent(l___private_Init_Lean_Elab_App_23__toMessageData___closed__1); -l___private_Init_Lean_Elab_App_23__toMessageData___closed__2 = _init_l___private_Init_Lean_Elab_App_23__toMessageData___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_App_23__toMessageData___closed__2); l___private_Init_Lean_Elab_App_24__mergeFailures___rarg___closed__1 = _init_l___private_Init_Lean_Elab_App_24__mergeFailures___rarg___closed__1(); lean_mark_persistent(l___private_Init_Lean_Elab_App_24__mergeFailures___rarg___closed__1); l___private_Init_Lean_Elab_App_24__mergeFailures___rarg___closed__2 = _init_l___private_Init_Lean_Elab_App_24__mergeFailures___rarg___closed__2(); diff --git a/stage0/stdlib/Init/Lean/Elab/Binders.c b/stage0/stdlib/Init/Lean/Elab/Binders.c index 4165622e6f..4446f891e1 100644 --- a/stage0/stdlib/Init/Lean/Elab/Binders.c +++ b/stage0/stdlib/Init/Lean/Elab/Binders.c @@ -20,11 +20,10 @@ lean_object* l_Lean_Elab_Term_elabBinders(lean_object*); lean_object* l_Lean_Elab_Term_mkForall(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_12__checkNoOptAutoParam___closed__4; lean_object* l___private_Init_Lean_Elab_Binders_2__expandBinderIdent___boxed(lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; lean_object* l_Lean_Elab_Term_elabLetDecl(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13; lean_object* l_Lean_Elab_Term_elabDepArrow___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_instantiateMVars(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabForall___closed__1; @@ -33,11 +32,11 @@ lean_object* l___private_Init_Lean_Elab_Binders_2__expandBinderIdent(lean_object lean_object* l_unreachable_x21___rarg(lean_object*); extern lean_object* l_Lean_nullKind; lean_object* l_Lean_Elab_Term_elabDepArrow(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main(lean_object*); lean_object* l_Lean_Elab_Term_elabArrow___closed__1; lean_object* l_Lean_Elab_Term_declareTacticSyntax___closed__5; lean_object* l___regBuiltin_Lean_Elab_Term_elabDepArrow___closed__1; lean_object* l___private_Init_Lean_Elab_Binders_12__checkNoOptAutoParam___boxed(lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6; extern lean_object* l_Lean_List_format___rarg___closed__2; uint8_t lean_name_eq(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabFunCore___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -56,6 +55,7 @@ extern lean_object* l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign_ extern lean_object* l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__3; lean_object* l_Lean_Elab_Term_expandFunBinders___boxed(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Array_empty___closed__1; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; lean_object* l_Lean_Elab_Term_FunBinders_elabFunBindersAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_declareTacticSyntax___closed__1; lean_object* l_Lean_Elab_Term_elabLetDeclAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); @@ -63,33 +63,29 @@ uint8_t l_Lean_checkTraceOption(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_4__expandBinderModifier___closed__3; lean_object* l___private_Init_Lean_Elab_Binders_6__matchBinder___boxed(lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; lean_object* l___regBuiltin_Lean_Elab_Term_elabArrow___closed__1; lean_object* l_Lean_Elab_Term_elabFunBinders___rarg(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_declareTacticSyntax___closed__2; lean_object* l_Lean_mkIdentFrom(lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16; lean_object* l_Lean_Elab_Term_compileDecl(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_mkLambda(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_expr_instantiate1(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__2; lean_object* lean_array_push(lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; lean_object* lean_array_get_size(lean_object*); extern lean_object* l_Lean_Parser_Term_depArrow___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabFun(lean_object*); -extern lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__3; extern lean_object* l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__2; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; lean_object* l_Lean_Elab_Term_declareTacticSyntax___closed__3; lean_object* lean_string_utf8_byte_size(lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11; lean_object* l___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__7; lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_14__elabFunBinderViews___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_withLetDecl___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_getMainModule___rarg(lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; lean_object* l___private_Init_Lean_Elab_Binders_1__expandBinderType(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_1__quoteName___main(lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_4__expandBinderModifier___closed__5; extern lean_object* l_Lean_mkAppStx___closed__8; extern lean_object* l_Lean_mkAppStx___closed__7; @@ -144,15 +140,16 @@ extern lean_object* l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign_ lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabFunCore___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_7__elabBinderViews___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; lean_object* l___private_Init_Lean_Elab_Binders_15__regTraceClasses(lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_7__elabBinderViews(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_quoteAutoTactic___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabLetBangDecl(lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; lean_object* l___private_Init_Lean_Elab_Binders_4__expandBinderModifier___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16; extern lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__3; lean_object* l_Lean_Elab_Term_logTrace(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; lean_object* l_Lean_Elab_Term_elabArrow___lambda__1___boxed(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_explicitBinder___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_elabForall___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -161,19 +158,17 @@ lean_object* l_Lean_Syntax_getId(lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_13__propagateExpectedType___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_4__expandBinderModifier___closed__1; lean_object* l_Lean_Elab_Term_elabFunBinders(lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11; extern lean_object* l_Lean_Parser_Term_instBinder___elambda__1___closed__1; lean_object* lean_name_mk_string(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; lean_object* l_Lean_Elab_Term_throwError___rarg(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_elabArrow___lambda__1___closed__1; lean_object* l_Lean_Elab_Term_elabBinder___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_getCurrMacroScope(lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; lean_object* l_Lean_Elab_Term_elabArrow___lambda__1___closed__2; lean_object* l_Lean_Elab_Term_expandOptType(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_withLocalDecl___rarg(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; lean_object* l___regBuiltin_Lean_Elab_Term_elabForall(lean_object*); extern lean_object* l_Lean_mkAppStx___closed__6; lean_object* l___private_Init_Lean_Elab_Binders_8__elabBindersAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -190,8 +185,10 @@ lean_object* l_Lean_Elab_Term_isClass(lean_object*, lean_object*, lean_object*, lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Lean_Elab_Term_Quotation_isAntiquot(lean_object*); lean_object* l_Lean_Elab_Term_elabLetBangDecl___closed__1; +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; lean_object* l_Lean_mkFVar(lean_object*); extern lean_object* l_Lean_Expr_getAutoParamTactic_x3f___closed__1; +extern lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__4; lean_object* l_Lean_Elab_Term_quoteAutoTactic(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabLetBangDecl___closed__2; lean_object* l___private_Init_Lean_Elab_Binders_4__expandBinderModifier(lean_object*, lean_object*, lean_object*, lean_object*); @@ -205,6 +202,7 @@ lean_object* l___private_Init_Lean_Elab_Binders_13__propagateExpectedType(lean_o lean_object* l___private_Init_Lean_Elab_Binders_7__elabBinderViews___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabBinders___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_12__checkNoOptAutoParam(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_String_HasQuote___closed__2; lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Binders_5__getBinderIds___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_expandOptType___boxed(lean_object*, lean_object*); extern lean_object* l_Lean_nullKind___closed__2; @@ -214,12 +212,11 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabLetBangDecl___closed__1; lean_object* l___private_Init_Lean_Elab_Binders_3__expandOptIdent___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_isDefEq(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_mkAppStx___closed__3; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__4; lean_object* lean_local_ctx_mk_local_decl(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); extern lean_object* l_Lean_identKind; lean_object* l___private_Init_Lean_Elab_Binders_8__elabBindersAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22; extern lean_object* l_Lean_Parser_Term_implicitBinder___elambda__1___closed__2; -extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__2; extern lean_object* l_Lean_Syntax_inhabited; lean_object* l_Lean_Elab_Term_elabArrow(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Binders_6__matchBinder___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -228,7 +225,6 @@ lean_object* l_Lean_Elab_Term_elabArrow___lambda__1___closed__5; lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Binders_6__matchBinder___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_mkAppStx___closed__5; extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__3; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__8; lean_object* l_Lean_Syntax_getNumArgs(lean_object*); lean_object* l_Lean_mkHole(lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__1; @@ -250,12 +246,13 @@ uint8_t l_Lean_BinderInfo_isExplicit(uint8_t); lean_object* l_Lean_Syntax_getKind(lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__4; lean_object* l_Lean_Elab_Term_elabLetDecl___closed__1; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26; lean_object* l_Lean_Elab_Term_quoteAutoTactic___main___closed__2; lean_object* l_Lean_Elab_Term_elabLetDeclAux___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_12__checkNoOptAutoParam___closed__6; extern lean_object* l___private_Init_Util_1__mkPanicMessage___closed__2; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; extern lean_object* l_Lean_mkHole___closed__1; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; lean_object* l_Lean_Elab_Term_mkExplicitBinder(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_adaptExpander(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_10__getFunBinderIds_x3f___boxed(lean_object*, lean_object*, lean_object*); @@ -271,11 +268,11 @@ lean_object* l_Lean_Elab_Term_expandFunBinders(lean_object*, lean_object*, lean_ lean_object* l_Lean_Elab_Term_elabLetBangDecl(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_whnfForall(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__9; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6; uint8_t l_Lean_Syntax_isNone(lean_object*); lean_object* l_Lean_Elab_Term_resetSynthInstanceCache___rarg(lean_object*); lean_object* l_Lean_mkTermIdFrom(lean_object*, lean_object*); extern lean_object* l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2___closed__1; -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; extern lean_object* l_Lean_Parser_Term_matchAlt___closed__2; extern lean_object* l_Lean_Parser_Term_binderDefault___elambda__1___closed__2; extern lean_object* l_Lean_Expr_Inhabited; @@ -283,10 +280,13 @@ lean_object* l___private_Init_Lean_Elab_Binders_7__elabBinderViews___boxed(lean_ lean_object* l___private_Init_Lean_Elab_Binders_9__getFunBinderIdsAux_x3f___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_quoteAutoTactic___main___spec__1___closed__3; uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13; uint8_t l_Lean_Expr_isOptParam(lean_object*); extern lean_object* l_Lean_mkHole___closed__2; lean_object* l_Lean_Elab_Term_elabBinders___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_9__getFunBinderIdsAux_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23; lean_object* l_Lean_Elab_Term_elabLetDeclAux___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*); extern lean_object* l_Lean_mkOptionalNode___closed__2; @@ -296,8 +296,6 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabLetDecl(lean_object*); extern lean_object* l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Binders_6__matchBinder___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_14__elabFunBinderViews(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__4; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; lean_object* l_Lean_Elab_Term_elabArrow___lambda__1(lean_object*, lean_object*, lean_object*); extern lean_object* l___private_Init_Lean_Elab_Util_4__regTraceClasses___closed__1; lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*); @@ -310,22 +308,24 @@ extern lean_object* l_Lean_Parser_Term_let_x21___elambda__1___closed__2; extern lean_object* l_Lean_Parser_Term_simpleBinder___elambda__1___closed__2; extern lean_object* l_Lean_Parser_Term_forall___elambda__1___closed__1; lean_object* l___private_Init_Lean_Elab_Binders_12__checkNoOptAutoParam___closed__3; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26; lean_object* l_Lean_mkConst(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; lean_object* l___private_Init_Lean_Elab_Binders_12__checkNoOptAutoParam___closed__5; extern lean_object* l_Lean_mkAppStx___closed__1; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__8; lean_object* l___regBuiltin_Lean_Elab_Term_elabLetDecl___closed__1; lean_object* l___private_Init_Lean_Elab_Binders_9__getFunBinderIdsAux_x3f___main(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabFunCore(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); extern lean_object* l_Lean_Meta_AbstractMVars_abstractExprMVars___main___closed__1; lean_object* l___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__6; +extern lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__3; lean_object* l___regBuiltin_Lean_Elab_Term_elabDepArrow(lean_object*); lean_object* l___private_Init_Lean_Elab_Binders_3__expandOptIdent(lean_object*, lean_object*, lean_object*); uint8_t lean_string_dec_eq(lean_object*, lean_object*); uint8_t lean_nat_dec_lt(lean_object*, lean_object*); extern lean_object* l_Lean_Meta_AbstractMVars_abstractExprMVars___main___closed__2; lean_object* l_Lean_Elab_Term_elabBinder(lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__4; lean_object* l___private_Init_Lean_Elab_Binders_1__expandBinderType(lean_object* x_1) { _start: { @@ -613,7 +613,7 @@ lean_dec(x_30); x_33 = l_Lean_mkAppStx___closed__7; lean_inc(x_3); x_34 = lean_name_mk_string(x_3, x_33); -x_35 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__4; +x_35 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__4; lean_inc(x_7); x_36 = lean_name_mk_string(x_7, x_35); lean_inc(x_36); @@ -626,7 +626,7 @@ lean_inc(x_9); x_39 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_39, 0, x_38); lean_ctor_set(x_39, 1, x_9); -x_40 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__3; +x_40 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__3; lean_inc(x_6); x_41 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_41, 0, x_6); @@ -732,7 +732,7 @@ switch (lean_obj_tag(x_1)) { case 0: { lean_object* x_4; lean_object* x_5; lean_object* x_6; -x_4 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_4 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_5 = l_unreachable_x21___rarg(x_4); x_6 = lean_apply_2(x_5, x_2, x_3); return x_6; @@ -769,11 +769,11 @@ x_18 = lean_ctor_get(x_16, 1); lean_inc(x_18); lean_dec(x_16); x_19 = lean_box(0); -x_20 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6; +x_20 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6; x_21 = l_Lean_addMacroScope(x_17, x_20, x_14); x_22 = lean_box(0); -x_23 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__4; -x_24 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__8; +x_23 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__4; +x_24 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__8; x_25 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_25, 0, x_19); lean_ctor_set(x_25, 1, x_23); @@ -814,10 +814,10 @@ if (x_42 == 0) { lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_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; x_43 = lean_ctor_get(x_41, 0); -x_44 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13; +x_44 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13; x_45 = l_Lean_addMacroScope(x_43, x_44, x_39); -x_46 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11; -x_47 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16; +x_46 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11; +x_47 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16; x_48 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_48, 0, x_19); lean_ctor_set(x_48, 1, x_46); @@ -829,7 +829,7 @@ x_51 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_51, 0, x_30); lean_ctor_set(x_51, 1, x_50); x_52 = lean_array_push(x_26, x_51); -x_53 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_7); +x_53 = l___private_Init_Lean_Syntax_7__quoteName___main(x_7); x_54 = lean_array_push(x_26, x_53); x_55 = lean_array_push(x_54, x_36); x_56 = lean_alloc_ctor(1, 2, 0); @@ -851,10 +851,10 @@ x_61 = lean_ctor_get(x_41, 1); lean_inc(x_61); lean_inc(x_60); lean_dec(x_41); -x_62 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13; +x_62 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13; x_63 = l_Lean_addMacroScope(x_60, x_62, x_39); -x_64 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11; -x_65 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16; +x_64 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11; +x_65 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16; x_66 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_66, 0, x_19); lean_ctor_set(x_66, 1, x_64); @@ -866,7 +866,7 @@ x_69 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_69, 0, x_30); lean_ctor_set(x_69, 1, x_68); x_70 = lean_array_push(x_26, x_69); -x_71 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_7); +x_71 = l___private_Init_Lean_Syntax_7__quoteName___main(x_7); x_72 = lean_array_push(x_26, x_71); x_73 = lean_array_push(x_72, x_36); x_74 = lean_alloc_ctor(1, 2, 0); @@ -925,11 +925,11 @@ x_88 = lean_ctor_get(x_86, 1); lean_inc(x_88); lean_dec(x_86); x_89 = lean_box(0); -x_90 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6; +x_90 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6; x_91 = l_Lean_addMacroScope(x_87, x_90, x_84); x_92 = lean_box(0); -x_93 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__4; -x_94 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__8; +x_93 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__4; +x_94 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__8; x_95 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_95, 0, x_89); lean_ctor_set(x_95, 1, x_93); @@ -978,10 +978,10 @@ if (lean_is_exclusive(x_112)) { lean_dec_ref(x_112); x_115 = lean_box(0); } -x_116 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13; +x_116 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13; x_117 = l_Lean_addMacroScope(x_113, x_116, x_110); -x_118 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11; -x_119 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16; +x_118 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11; +x_119 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16; x_120 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_120, 0, x_89); lean_ctor_set(x_120, 1, x_118); @@ -993,7 +993,7 @@ x_123 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_123, 0, x_100); lean_ctor_set(x_123, 1, x_122); x_124 = lean_array_push(x_96, x_123); -x_125 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_7); +x_125 = l___private_Init_Lean_Syntax_7__quoteName___main(x_7); x_126 = lean_array_push(x_96, x_125); x_127 = lean_array_push(x_126, x_107); x_128 = lean_alloc_ctor(1, 2, 0); @@ -1076,12 +1076,12 @@ if (x_146 == 0) lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; x_147 = lean_ctor_get(x_145, 0); x_148 = lean_box(0); -x_149 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23; +x_149 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23; lean_inc(x_143); lean_inc(x_147); x_150 = l_Lean_addMacroScope(x_147, x_149, x_143); -x_151 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22; -x_152 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26; +x_151 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22; +x_152 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26; x_153 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_153, 0, x_148); lean_ctor_set(x_153, 1, x_151); @@ -1096,10 +1096,10 @@ lean_ctor_set_tag(x_1, 1); lean_ctor_set(x_1, 1, x_157); lean_ctor_set(x_1, 0, x_158); x_159 = lean_array_push(x_154, x_1); -x_160 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_160 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; x_161 = l_Lean_addMacroScope(x_147, x_160, x_143); -x_162 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_163 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_162 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_163 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_164 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_164, 0, x_148); lean_ctor_set(x_164, 1, x_162); @@ -1114,7 +1114,7 @@ x_168 = lean_array_push(x_154, x_167); x_169 = l_Lean_mkStxStrLit(x_140, x_148); x_170 = l_Lean_mkOptionalNode___closed__2; x_171 = lean_array_push(x_170, x_169); -x_172 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_172 = l_Lean_String_HasQuote___closed__2; x_173 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_173, 0, x_172); lean_ctor_set(x_173, 1, x_171); @@ -1140,12 +1140,12 @@ lean_inc(x_181); lean_inc(x_180); lean_dec(x_145); x_182 = lean_box(0); -x_183 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23; +x_183 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23; lean_inc(x_143); lean_inc(x_180); x_184 = l_Lean_addMacroScope(x_180, x_183, x_143); -x_185 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22; -x_186 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26; +x_185 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22; +x_186 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26; x_187 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_187, 0, x_182); lean_ctor_set(x_187, 1, x_185); @@ -1160,10 +1160,10 @@ lean_ctor_set_tag(x_1, 1); lean_ctor_set(x_1, 1, x_191); lean_ctor_set(x_1, 0, x_192); x_193 = lean_array_push(x_188, x_1); -x_194 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_194 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; x_195 = l_Lean_addMacroScope(x_180, x_194, x_143); -x_196 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_197 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_196 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_197 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_198 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_198, 0, x_182); lean_ctor_set(x_198, 1, x_196); @@ -1178,7 +1178,7 @@ x_202 = lean_array_push(x_188, x_201); x_203 = l_Lean_mkStxStrLit(x_140, x_182); x_204 = l_Lean_mkOptionalNode___closed__2; x_205 = lean_array_push(x_204, x_203); -x_206 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_206 = l_Lean_String_HasQuote___closed__2; x_207 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_207, 0, x_206); lean_ctor_set(x_207, 1, x_205); @@ -1225,12 +1225,12 @@ if (lean_is_exclusive(x_219)) { x_222 = lean_box(0); } x_223 = lean_box(0); -x_224 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23; +x_224 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23; lean_inc(x_217); lean_inc(x_220); x_225 = l_Lean_addMacroScope(x_220, x_224, x_217); -x_226 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22; -x_227 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26; +x_226 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22; +x_227 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26; x_228 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_228, 0, x_223); lean_ctor_set(x_228, 1, x_226); @@ -1245,10 +1245,10 @@ x_234 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_234, 0, x_233); lean_ctor_set(x_234, 1, x_232); x_235 = lean_array_push(x_229, x_234); -x_236 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_236 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; x_237 = l_Lean_addMacroScope(x_220, x_236, x_217); -x_238 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_239 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_238 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_239 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_240 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_240, 0, x_223); lean_ctor_set(x_240, 1, x_238); @@ -1263,7 +1263,7 @@ x_244 = lean_array_push(x_229, x_243); x_245 = l_Lean_mkStxStrLit(x_215, x_223); x_246 = l_Lean_mkOptionalNode___closed__2; x_247 = lean_array_push(x_246, x_245); -x_248 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_248 = l_Lean_String_HasQuote___closed__2; x_249 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_249, 0, x_248); lean_ctor_set(x_249, 1, x_247); @@ -1449,6 +1449,7 @@ lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_inc(x_28); x_58 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_58, 0, x_28); +lean_inc(x_2); x_59 = l_Lean_Elab_Term_logTrace(x_56, x_20, x_58, x_2, x_55); x_60 = lean_ctor_get(x_59, 1); lean_inc(x_60); @@ -1716,6 +1717,7 @@ lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_inc(x_100); x_129 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_129, 0, x_100); +lean_inc(x_81); x_130 = l_Lean_Elab_Term_logTrace(x_127, x_92, x_129, x_81, x_126); x_131 = lean_ctor_get(x_130, 1); lean_inc(x_131); @@ -2031,6 +2033,7 @@ lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_inc(x_181); x_210 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_210, 0, x_181); +lean_inc(x_162); x_211 = l_Lean_Elab_Term_logTrace(x_208, x_173, x_210, x_162, x_207); x_212 = lean_ctor_get(x_211, 1); lean_inc(x_212); @@ -5732,7 +5735,7 @@ x_24 = l_Lean_nullKind___closed__2; x_25 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_25, 0, x_24); lean_ctor_set(x_25, 1, x_23); -x_26 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_26 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_27 = lean_array_push(x_26, x_25); x_28 = l_Lean_Elab_Term_elabArrow___lambda__1___closed__4; x_29 = lean_array_push(x_28, x_7); @@ -5742,7 +5745,7 @@ lean_ctor_set(x_30, 1, x_29); x_31 = lean_array_push(x_27, x_30); x_32 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_33 = lean_array_push(x_31, x_32); -x_34 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_34 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_35 = lean_array_push(x_33, x_34); x_36 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__2; x_37 = lean_alloc_ctor(1, 2, 0); @@ -5788,7 +5791,7 @@ x_57 = l_Lean_nullKind___closed__2; x_58 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_58, 0, x_57); lean_ctor_set(x_58, 1, x_56); -x_59 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_59 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_60 = lean_array_push(x_59, x_58); x_61 = l_Lean_Elab_Term_elabArrow___lambda__1___closed__4; x_62 = lean_array_push(x_61, x_7); @@ -5798,7 +5801,7 @@ lean_ctor_set(x_63, 1, x_62); x_64 = lean_array_push(x_60, x_63); x_65 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_66 = lean_array_push(x_64, x_65); -x_67 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_67 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_68 = lean_array_push(x_66, x_67); x_69 = l_Lean_Parser_Term_explicitBinder___elambda__1___closed__2; x_70 = lean_alloc_ctor(1, 2, 0); @@ -24013,6 +24016,7 @@ lean_ctor_set(x_47, 0, x_16); x_48 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_48, 0, x_46); lean_ctor_set(x_48, 1, x_47); +lean_inc(x_9); x_49 = l_Lean_Elab_Term_logTrace(x_38, x_1, x_48, x_9, x_37); x_50 = lean_ctor_get(x_49, 1); lean_inc(x_50); @@ -24426,7 +24430,7 @@ lean_ctor_set(x_41, 2, x_38); lean_ctor_set(x_41, 3, x_39); x_42 = l_Array_empty___closed__1; x_43 = lean_array_push(x_42, x_41); -x_44 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_44 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_45 = lean_array_push(x_43, x_44); x_46 = l_Lean_Elab_Term_elabArrow___lambda__1___closed__4; x_47 = lean_array_push(x_46, x_25); @@ -24441,16 +24445,16 @@ lean_ctor_set(x_52, 0, x_51); lean_ctor_set(x_52, 1, x_50); lean_inc(x_45); x_53 = lean_array_push(x_45, x_52); -x_54 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_54 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_55 = lean_array_push(x_53, x_54); x_56 = lean_array_push(x_55, x_27); x_57 = l_Lean_Parser_Term_letIdDecl___closed__2; x_58 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_58, 0, x_57); lean_ctor_set(x_58, 1, x_56); -x_59 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_59 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_60 = lean_array_push(x_59, x_58); -x_61 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_61 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_62 = lean_array_push(x_60, x_61); x_63 = l_Lean_mkTermIdFromIdent___closed__2; x_64 = lean_alloc_ctor(1, 2, 0); @@ -24621,20 +24625,20 @@ lean_ctor_set(x_143, 2, x_140); lean_ctor_set(x_143, 3, x_141); x_144 = l_Array_empty___closed__1; x_145 = lean_array_push(x_144, x_143); -x_146 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_146 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_147 = lean_array_push(x_145, x_146); lean_inc(x_147); x_148 = lean_array_push(x_147, x_146); -x_149 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_149 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_150 = lean_array_push(x_148, x_149); x_151 = lean_array_push(x_150, x_129); x_152 = l_Lean_Parser_Term_letIdDecl___closed__2; x_153 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_153, 0, x_152); lean_ctor_set(x_153, 1, x_151); -x_154 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_154 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_155 = lean_array_push(x_154, x_153); -x_156 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_156 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_157 = lean_array_push(x_155, x_156); x_158 = l_Lean_mkTermIdFromIdent___closed__2; x_159 = lean_alloc_ctor(1, 2, 0); @@ -25167,7 +25171,7 @@ lean_ctor_set(x_41, 2, x_38); lean_ctor_set(x_41, 3, x_39); x_42 = l_Array_empty___closed__1; x_43 = lean_array_push(x_42, x_41); -x_44 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_44 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_45 = lean_array_push(x_43, x_44); x_46 = l_Lean_Elab_Term_elabArrow___lambda__1___closed__4; x_47 = lean_array_push(x_46, x_25); @@ -25182,7 +25186,7 @@ lean_ctor_set(x_52, 0, x_51); lean_ctor_set(x_52, 1, x_50); lean_inc(x_45); x_53 = lean_array_push(x_45, x_52); -x_54 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_54 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_55 = lean_array_push(x_53, x_54); x_56 = lean_array_push(x_55, x_27); x_57 = l_Lean_Parser_Term_letIdDecl___closed__2; @@ -25191,7 +25195,7 @@ lean_ctor_set(x_58, 0, x_57); lean_ctor_set(x_58, 1, x_56); x_59 = l_Lean_Elab_Term_elabLetBangDecl___closed__2; x_60 = lean_array_push(x_59, x_58); -x_61 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_61 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_62 = lean_array_push(x_60, x_61); x_63 = l_Lean_mkTermIdFromIdent___closed__2; x_64 = lean_alloc_ctor(1, 2, 0); @@ -25362,11 +25366,11 @@ lean_ctor_set(x_143, 2, x_140); lean_ctor_set(x_143, 3, x_141); x_144 = l_Array_empty___closed__1; x_145 = lean_array_push(x_144, x_143); -x_146 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_146 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_147 = lean_array_push(x_145, x_146); lean_inc(x_147); x_148 = lean_array_push(x_147, x_146); -x_149 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_149 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_150 = lean_array_push(x_148, x_149); x_151 = lean_array_push(x_150, x_129); x_152 = l_Lean_Parser_Term_letIdDecl___closed__2; @@ -25375,7 +25379,7 @@ lean_ctor_set(x_153, 0, x_152); lean_ctor_set(x_153, 1, x_151); x_154 = l_Lean_Elab_Term_elabLetBangDecl___closed__2; x_155 = lean_array_push(x_154, x_153); -x_156 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_156 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_157 = lean_array_push(x_155, x_156); x_158 = l_Lean_mkTermIdFromIdent___closed__2; x_159 = lean_alloc_ctor(1, 2, 0); diff --git a/stage0/stdlib/Init/Lean/Elab/BuiltinNotation.c b/stage0/stdlib/Init/Lean/Elab/BuiltinNotation.c index cb56333211..298fbd04a6 100644 --- a/stage0/stdlib/Init/Lean/Elab/BuiltinNotation.c +++ b/stage0/stdlib/Init/Lean/Elab/BuiltinNotation.c @@ -32,6 +32,7 @@ lean_object* l___private_Init_Lean_Elab_BuiltinNotation_3__getPropToDecide___clo lean_object* l_Lean_extractMacroScopes(lean_object*); lean_object* l_Lean_Elab_Term_elabAdd___closed__1; extern lean_object* l_Lean_Parser_Term_andthen___elambda__1___closed__2; +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; lean_object* l_Lean_Elab_Term_elabModN___closed__1; lean_object* l_Lean_Elab_Term_elabIff(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Meta_reduceNative_x3f___closed__2; @@ -53,6 +54,7 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabNativeRefl___closed__1; lean_object* l_Lean_Elab_Term_elabAnonymousCtor___closed__2; lean_object* l_Lean_Elab_Term_elabBOr___boxed(lean_object*, lean_object*, lean_object*); extern lean_object* l___private_Init_Lean_Elab_Term_8__exceptionToSorry___closed__1; +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main(lean_object*); lean_object* l_Lean_Elab_Term_elabInfix(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__5; lean_object* l_Lean_Elab_Term_expandSubtype___closed__9; @@ -66,9 +68,9 @@ lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__28; lean_object* l_Lean_Elab_Term_elabInfixOp(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__18; lean_object* l_Lean_Elab_Term_expandHave___boxed(lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__1; lean_object* l_Lean_Elab_Term_getDeclName_x3f(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_BuiltinNotation_2__elabClosedTerm___closed__1; +extern lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__14; lean_object* l_Lean_Elab_Term_elabAnonymousCtor___closed__1; lean_object* l_Lean_Elab_Term_elabBOr___closed__1; @@ -87,12 +89,13 @@ extern lean_object* l_Lean_Parser_Term_show___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_elabMul___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_expandDollarProj(lean_object*); extern lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +extern lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__4; extern lean_object* l_Array_empty___closed__1; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; lean_object* l_Lean_Elab_Term_elabPow___closed__3; lean_object* lean_environment_find(lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_decide___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabseqRight___closed__1; -extern lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__4; lean_object* l_Lean_Elab_Term_elabMod___closed__1; lean_object* l_Lean_Elab_Term_elabTermAndSynthesize(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_expandDollar(lean_object*, lean_object*, lean_object*); @@ -101,7 +104,6 @@ lean_object* l___regBuiltin_Lean_Elab_Term_ElabFComp___closed__1; extern lean_object* l_Lean_Parser_Term_fromTerm___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabGT(lean_object*); extern lean_object* l_Lean_Parser_Term_mul___elambda__1___closed__1; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; extern lean_object* l_Lean_Parser_Term_andM___elambda__1___closed__1; lean_object* l_Lean_Elab_Term_elabEquiv___closed__1; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__17; @@ -125,7 +127,6 @@ extern lean_object* l_Lean_Parser_Term_seqRight___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_expandSubtype___closed__10; lean_object* lean_array_push(lean_object*, lean_object*); lean_object* lean_array_get_size(lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__3; lean_object* l_Lean_Elab_Term_elabModN(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabAndThen___closed__1; lean_object* l_Lean_Elab_Term_elabDecide___closed__3; @@ -143,10 +144,12 @@ lean_object* l_Lean_Elab_Term_expandSubtype___closed__11; lean_object* l_Lean_Elab_Term_elabLT___closed__3; extern lean_object* l_Lean_Parser_Term_typeAscription___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabAppend(lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1; lean_object* l_Lean_Elab_Term_elabDiv___closed__3; lean_object* l___regBuiltin_Lean_Elab_Term_elabHEq___closed__1; lean_object* l_Lean_Elab_Term_elabBNe(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_appArg_x21(lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__2; lean_object* l_Lean_Elab_Term_elabLT___boxed(lean_object*, lean_object*, lean_object*); lean_object* lean_string_utf8_byte_size(lean_object*); @@ -164,14 +167,12 @@ lean_object* l_Lean_Elab_Term_getMainModule___rarg(lean_object*); lean_object* l_Lean_Elab_Term_elabMod___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabAnonymousCtor___closed__6; lean_object* l_Lean_Elab_Term_elabAppend___closed__3; -extern lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; lean_object* l_Lean_Elab_Term_expandWhere___boxed(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_lt___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_elabModN___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabEq(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_expandShow___closed__1; lean_object* l_Lean_Elab_Term_elabSub___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_1__quoteName___main(lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_expandDollar___closed__1; lean_object* l___regBuiltin_Lean_Elab_Term_elabGT___closed__1; extern lean_object* l_Lean_mkAppStx___closed__8; @@ -228,10 +229,8 @@ lean_object* l_Lean_Elab_Term_elabseq___boxed(lean_object*, lean_object*, lean_o uint8_t lean_nat_dec_eq(lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabMap___closed__1; lean_object* l_Lean_Elab_Term_elabNativeRefl___boxed(lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1; lean_object* l_Lean_Elab_Term_elabMul(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabseq___closed__2; -extern lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__3; lean_object* l___regBuiltin_Lean_Elab_Term_elabOrElse___closed__1; extern lean_object* l_Lean_Parser_Term_band___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_expandHave___closed__1; @@ -279,7 +278,6 @@ lean_object* l_Lean_Elab_Term_elabBind(lean_object*, lean_object*, lean_object*) lean_object* l_Lean_Elab_Term_elabEquiv___closed__3; lean_object* l_Lean_Elab_Term_elabTParserMacro___closed__1; lean_object* l_Lean_Elab_Term_expandIf___closed__6; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; lean_object* l_Lean_Elab_Term_elabDecide___closed__1; lean_object* l___regBuiltin_Lean_Elab_Term_elabDecide(lean_object*); lean_object* l_Lean_Elab_Term_ElabFComp(lean_object*, lean_object*, lean_object*); @@ -298,6 +296,7 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabNativeDecide(lean_object*); lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__27; lean_object* l___regBuiltin_Lean_Elab_Term_elabMapConst___closed__1; lean_object* l_Lean_Elab_Term_elabSub(lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; extern lean_object* l_Lean_Parser_Term_fcomp___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_elabMapRev___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabMod___closed__3; @@ -306,6 +305,7 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabAnd___closed__1; lean_object* l_Lean_Elab_Term_elabseqRight___closed__1; extern lean_object* l_Lean_mkDecIsTrue___closed__2; lean_object* lean_name_mk_string(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; lean_object* l_Lean_Elab_Term_throwError___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabBOr(lean_object*); lean_object* l_Lean_Elab_Term_expandSubtype___closed__8; @@ -321,13 +321,11 @@ lean_object* l_Lean_Elab_Term_elabBAnd(lean_object*, lean_object*, lean_object*) lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__31; lean_object* l_Lean_Elab_Term_getCurrMacroScope(lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_orM___elambda__1___closed__2; -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; extern lean_object* l_Lean_Parser_Term_orM___elambda__1___closed__1; lean_object* l_Lean_Elab_Term_expandSubtype___closed__4; extern lean_object* l_Lean_Parser_Term_iff___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_elabAnonymousCtor___closed__9; lean_object* l_Lean_Elab_Term_elabLE(lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; lean_object* l_Lean_Elab_Term_expandShow(lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabOr(lean_object*); lean_object* l_Lean_Elab_Term_elabOr___closed__1; @@ -337,7 +335,6 @@ lean_object* l_Lean_Elab_Term_elabTParserMacro___lambda__1___closed__3; lean_object* l_Lean_Elab_Term_elabMap___closed__3; lean_object* l_Lean_Elab_Term_elabOr___boxed(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_beq___elambda__1___closed__1; -extern lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5; lean_object* l_Lean_Elab_Term_elabAppend___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabAnonymousCtor___closed__15; lean_object* l_Lean_Elab_Term_elabPow___closed__2; @@ -384,6 +381,7 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabAdd___closed__1; lean_object* l_Lean_Elab_Term_expandSubtype___closed__7; lean_object* l_Lean_Elab_Term_elabPow___closed__1; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_String_HasQuote___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabDecide___closed__1; lean_object* l___regBuiltin_Lean_Elab_Term_elabNativeRefl(lean_object*); extern lean_object* l_Lean_nullKind___closed__2; @@ -406,7 +404,6 @@ lean_object* l_Lean_Elab_Term_elabMap___closed__2; lean_object* l_Lean_Elab_Term_expandSubtype___closed__3; lean_object* l_Lean_Elab_Term_expandHave(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_le___elambda__1___closed__2; -extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__20; lean_object* l_Lean_Elab_Term_elabTParserMacro(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabAnd___closed__1; @@ -446,12 +443,12 @@ extern lean_object* l_Lean_Parser_Term_mapRev___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_expandIf___closed__8; lean_object* l___regBuiltin_Lean_Elab_Term_elabOrM(lean_object*); extern lean_object* l___private_Init_Util_1__mkPanicMessage___closed__2; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; extern lean_object* l_Lean_Parser_Term_append___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabseqLeft(lean_object*); lean_object* l_Lean_Elab_Term_elabGE___closed__1; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__10; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__32; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; lean_object* l_Lean_Elab_Term_elabNativeRefl___closed__10; lean_object* l_Lean_Elab_Term_expandSubtype___closed__5; lean_object* l_Lean_Elab_Term_adaptExpander(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -483,7 +480,6 @@ extern lean_object* l_Lean_TraceState_Inhabited___closed__1; lean_object* l___regBuiltin_Lean_Elab_Term_expandDollar(lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabEq(lean_object*); lean_object* l_Lean_Elab_Term_elabGT___closed__2; -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; lean_object* l_Lean_Expr_consumeMData___main(lean_object*); lean_object* l_Lean_Elab_Term_elabGT___closed__1; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__3; @@ -493,6 +489,7 @@ lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__15; lean_object* l_Lean_Elab_Term_elabHEq___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabOrM(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_expandShow___closed__4; +extern lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__3; lean_object* l_Lean_Elab_Term_elabAndThen___closed__2; uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabMapConst___boxed(lean_object*, lean_object*, lean_object*); @@ -503,6 +500,7 @@ lean_object* l_Lean_Elab_Term_elabseqLeft(lean_object*, lean_object*, lean_objec lean_object* l_Lean_Elab_Term_elabMapConst___closed__1; extern lean_object* l_Lean_mkHole___closed__2; lean_object* l_Lean_Elab_Term_elabNativeDecide___closed__1; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; lean_object* l_Lean_Elab_Term_elabseqRight(lean_object*, lean_object*, lean_object*); uint8_t l_List_beq___main___at_Lean_Elab_Term_elabParserMacro___spec__1(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabNativeDecide___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -513,6 +511,7 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabIff___closed__1; lean_object* l_Lean_Meta_reduceNative_x3f(lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabAndM___closed__1; extern lean_object* l_Lean_Meta_reduceNative_x3f___closed__4; +extern lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__3; lean_object* l___regBuiltin_Lean_Elab_Term_elabParserMacro___closed__1; lean_object* l_Lean_Elab_Term_elabAnonymousCtor___closed__5; lean_object* l___regBuiltin_Lean_Elab_Term_elabGE(lean_object*); @@ -529,12 +528,12 @@ extern lean_object* l_Lean_Parser_Term_typeSpec___elambda__1___closed__2; lean_object* l___private_Init_Lean_Elab_BuiltinNotation_3__getPropToDecide___closed__4; extern lean_object* l_Lean_Parser_Term_nativeRefl___elambda__1___closed__2; lean_object* l_Lean_mkCTermIdFrom(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__1; lean_object* l_Lean_Elab_Term_elabCons(lean_object*, lean_object*, lean_object*); extern lean_object* l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; lean_object* l___regBuiltin_Lean_Elab_Term_expandIf___closed__1; lean_object* l_Lean_Elab_Term_elabMod(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabAnonymousCtor___closed__7; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; extern lean_object* l_Lean_Parser_Term_map___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabPow(lean_object*); extern lean_object* l_Lean_Parser_Term_orelse___elambda__1___closed__2; @@ -565,10 +564,10 @@ lean_object* l_Lean_Elab_Term_elabAndThen(lean_object*, lean_object*, lean_objec lean_object* l___regBuiltin_Lean_Elab_Term_elabTParserMacro___closed__1; lean_object* l_Lean_Elab_Term_elabNativeRefl___closed__3; extern lean_object* l_Lean_Parser_Term_bindOp___elambda__1___closed__2; -extern lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6; lean_object* l_Lean_mkConst(lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_modN___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabseqRight(lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; lean_object* l_Lean_Elab_Term_elabNe___closed__2; extern lean_object* l_Lean_Parser_Term_and___elambda__1___closed__1; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__7; @@ -582,6 +581,7 @@ lean_object* l_Lean_Elab_Term_elabSub___boxed(lean_object*, lean_object*, lean_o lean_object* l_Lean_Elab_Term_elabTParserMacro___lambda__1___closed__2; lean_object* l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__24; lean_object* l___regBuiltin_Lean_Elab_Term_elabOrM___closed__1; +extern lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5; extern lean_object* l_Lean_Parser_Term_dollar___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabEquiv___closed__1; lean_object* l_Lean_Elab_Term_elabNe___closed__1; @@ -867,7 +867,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1; +x_2 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } @@ -1058,7 +1058,7 @@ lean_dec(x_2); x_20 = lean_box(0); x_21 = l_Lean_Elab_Term_expandIf___closed__1; x_22 = l_Lean_addMacroScope(x_19, x_21, x_18); -x_23 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__3; +x_23 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__3; x_24 = l_Lean_Elab_Term_expandIf___closed__3; x_25 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_25, 0, x_20); @@ -1067,7 +1067,7 @@ lean_ctor_set(x_25, 2, x_22); lean_ctor_set(x_25, 3, x_24); x_26 = l_Array_empty___closed__1; x_27 = lean_array_push(x_26, x_25); -x_28 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_28 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_29 = lean_array_push(x_27, x_28); x_30 = l_Lean_mkTermIdFromIdent___closed__2; x_31 = lean_alloc_ctor(1, 2, 0); @@ -1148,7 +1148,7 @@ lean_ctor_set(x_66, 2, x_63); lean_ctor_set(x_66, 3, x_65); x_67 = l_Array_empty___closed__1; x_68 = lean_array_push(x_67, x_66); -x_69 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_69 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_70 = lean_array_push(x_68, x_69); x_71 = l_Lean_mkTermIdFromIdent___closed__2; x_72 = lean_alloc_ctor(1, 2, 0); @@ -1180,9 +1180,9 @@ x_88 = lean_array_push(x_87, x_69); x_89 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_89, 0, x_43); lean_ctor_set(x_89, 1, x_88); -x_90 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_90 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_91 = lean_array_push(x_90, x_89); -x_92 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_92 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_93 = lean_array_push(x_91, x_92); x_94 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_95 = lean_alloc_ctor(1, 2, 0); @@ -1333,7 +1333,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Elab_Term_expandSubtype___closed__8; -x_2 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__3; +x_2 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__3; x_3 = lean_array_push(x_1, x_2); return x_3; } @@ -1476,7 +1476,7 @@ lean_ctor_set(x_23, 2, x_20); lean_ctor_set(x_23, 3, x_22); x_24 = l_Array_empty___closed__1; x_25 = lean_array_push(x_24, x_23); -x_26 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_26 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_27 = lean_array_push(x_25, x_26); x_28 = l_Lean_mkTermIdFromIdent___closed__2; x_29 = lean_alloc_ctor(1, 2, 0); @@ -1495,9 +1495,9 @@ x_37 = l_Lean_nullKind___closed__2; x_38 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_38, 0, x_37); lean_ctor_set(x_38, 1, x_36); -x_39 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_39 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_40 = lean_array_push(x_39, x_38); -x_41 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_41 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_42 = lean_array_push(x_40, x_41); x_43 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_44 = lean_alloc_ctor(1, 2, 0); @@ -1634,7 +1634,7 @@ lean_ctor_set(x_90, 2, x_87); lean_ctor_set(x_90, 3, x_89); x_91 = l_Array_empty___closed__1; x_92 = lean_array_push(x_91, x_90); -x_93 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_93 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_94 = lean_array_push(x_92, x_93); x_95 = l_Lean_mkTermIdFromIdent___closed__2; x_96 = lean_alloc_ctor(1, 2, 0); @@ -1661,9 +1661,9 @@ x_108 = lean_array_push(x_101, x_107); x_109 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_109, 0, x_67); lean_ctor_set(x_109, 1, x_108); -x_110 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_110 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_111 = lean_array_push(x_110, x_109); -x_112 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_112 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_113 = lean_array_push(x_111, x_112); x_114 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_115 = lean_alloc_ctor(1, 2, 0); @@ -2490,7 +2490,7 @@ x_27 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_27, 0, x_26); lean_ctor_set(x_27, 1, x_25); x_28 = lean_array_push(x_20, x_27); -x_29 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_29 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_30 = lean_array_push(x_28, x_29); x_31 = lean_array_push(x_30, x_14); x_32 = l_Lean_Parser_Term_letIdDecl___closed__2; @@ -2499,7 +2499,7 @@ lean_ctor_set(x_33, 0, x_32); lean_ctor_set(x_33, 1, x_31); x_34 = l_Lean_Elab_Term_expandShow___closed__4; x_35 = lean_array_push(x_34, x_33); -x_36 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_36 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_37 = lean_array_push(x_35, x_36); x_38 = lean_array_push(x_37, x_16); x_39 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; @@ -2678,7 +2678,7 @@ x_23 = l_Lean_Syntax_getArg(x_1, x_22); lean_dec(x_1); x_24 = l_Array_empty___closed__1; x_25 = lean_array_push(x_24, x_13); -x_26 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_26 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_27 = lean_array_push(x_25, x_26); x_28 = l_Lean_Elab_Term_expandSubtype___closed__8; x_29 = lean_array_push(x_28, x_15); @@ -2692,7 +2692,7 @@ x_34 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_34, 0, x_33); lean_ctor_set(x_34, 1, x_32); x_35 = lean_array_push(x_27, x_34); -x_36 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_36 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_37 = lean_array_push(x_35, x_36); x_38 = lean_array_push(x_37, x_21); x_39 = l_Lean_Parser_Term_letIdDecl___closed__2; @@ -2701,7 +2701,7 @@ lean_ctor_set(x_40, 0, x_39); lean_ctor_set(x_40, 1, x_38); x_41 = l_Lean_Elab_Term_expandShow___closed__4; x_42 = lean_array_push(x_41, x_40); -x_43 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_43 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_44 = lean_array_push(x_42, x_43); x_45 = lean_array_push(x_44, x_23); x_46 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; @@ -2751,7 +2751,7 @@ x_59 = l_Lean_Syntax_getArg(x_1, x_58); lean_dec(x_1); x_60 = l_Array_empty___closed__1; x_61 = lean_array_push(x_60, x_13); -x_62 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_62 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_63 = lean_array_push(x_61, x_62); x_64 = l_Lean_Elab_Term_expandSubtype___closed__8; x_65 = lean_array_push(x_64, x_15); @@ -2765,7 +2765,7 @@ x_70 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_70, 0, x_69); lean_ctor_set(x_70, 1, x_68); x_71 = lean_array_push(x_63, x_70); -x_72 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_72 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_73 = lean_array_push(x_71, x_72); x_74 = lean_array_push(x_73, x_57); x_75 = l_Lean_Parser_Term_letIdDecl___closed__2; @@ -2774,7 +2774,7 @@ lean_ctor_set(x_76, 0, x_75); lean_ctor_set(x_76, 1, x_74); x_77 = l_Lean_Elab_Term_expandShow___closed__4; x_78 = lean_array_push(x_77, x_76); -x_79 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_79 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_80 = lean_array_push(x_78, x_79); x_81 = lean_array_push(x_80, x_59); x_82 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; @@ -2868,7 +2868,7 @@ x_112 = l_Lean_mkIdentFrom(x_1, x_111); lean_dec(x_1); x_113 = l_Array_empty___closed__1; x_114 = lean_array_push(x_113, x_112); -x_115 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_115 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_116 = lean_array_push(x_114, x_115); x_117 = l_Lean_Elab_Term_expandSubtype___closed__8; x_118 = lean_array_push(x_117, x_102); @@ -2881,7 +2881,7 @@ x_122 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_122, 0, x_93); lean_ctor_set(x_122, 1, x_121); x_123 = lean_array_push(x_116, x_122); -x_124 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_124 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_125 = lean_array_push(x_123, x_124); x_126 = lean_array_push(x_125, x_108); x_127 = l_Lean_Parser_Term_letIdDecl___closed__2; @@ -2890,7 +2890,7 @@ lean_ctor_set(x_128, 0, x_127); lean_ctor_set(x_128, 1, x_126); x_129 = l_Lean_Elab_Term_expandShow___closed__4; x_130 = lean_array_push(x_129, x_128); -x_131 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_131 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_132 = lean_array_push(x_130, x_131); x_133 = lean_array_push(x_132, x_110); x_134 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; @@ -2942,7 +2942,7 @@ x_149 = l_Lean_mkIdentFrom(x_1, x_148); lean_dec(x_1); x_150 = l_Array_empty___closed__1; x_151 = lean_array_push(x_150, x_149); -x_152 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_152 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_153 = lean_array_push(x_151, x_152); x_154 = l_Lean_Elab_Term_expandSubtype___closed__8; x_155 = lean_array_push(x_154, x_102); @@ -2955,7 +2955,7 @@ x_159 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_159, 0, x_93); lean_ctor_set(x_159, 1, x_158); x_160 = lean_array_push(x_153, x_159); -x_161 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_161 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_162 = lean_array_push(x_160, x_161); x_163 = lean_array_push(x_162, x_145); x_164 = l_Lean_Parser_Term_letIdDecl___closed__2; @@ -2964,7 +2964,7 @@ lean_ctor_set(x_165, 0, x_164); lean_ctor_set(x_165, 1, x_163); x_166 = l_Lean_Elab_Term_expandShow___closed__4; x_167 = lean_array_push(x_166, x_165); -x_168 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_168 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_169 = lean_array_push(x_167, x_168); x_170 = lean_array_push(x_169, x_147); x_171 = l_Lean_Parser_Term_let_x21___elambda__1___closed__2; @@ -3027,11 +3027,11 @@ x_14 = lean_array_fget(x_4, x_13); x_15 = l_Lean_Parser_Term_let___elambda__1___closed__1; lean_inc(x_2); x_16 = lean_name_mk_string(x_2, x_15); -x_17 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__1; +x_17 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__1; lean_inc(x_3); x_18 = lean_array_push(x_3, x_17); x_19 = lean_array_push(x_18, x_14); -x_20 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_20 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_21 = lean_array_push(x_19, x_20); x_22 = lean_array_push(x_21, x_7); x_23 = lean_alloc_ctor(1, 2, 0); @@ -3493,7 +3493,7 @@ lean_object* _init_l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__29() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5; +x_1 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } @@ -3502,7 +3502,7 @@ lean_object* _init_l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__30() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5; +x_1 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5; x_2 = lean_unsigned_to_nat(0u); x_3 = l_Lean_Elab_Term_elabParserMacro___lambda__1___closed__29; x_4 = lean_alloc_ctor(0, 3, 0); @@ -3517,7 +3517,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5; +x_2 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } @@ -3527,7 +3527,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6; +x_2 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6; x_3 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); @@ -3625,12 +3625,12 @@ lean_dec(x_15); x_18 = lean_ctor_get(x_16, 1); lean_inc(x_18); lean_dec(x_16); -x_19 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_14); +x_19 = l___private_Init_Lean_Syntax_7__quoteName___main(x_14); x_20 = lean_box(0); x_21 = l_Lean_mkStxStrLit(x_18, x_20); x_22 = l_Lean_mkOptionalNode___closed__2; x_23 = lean_array_push(x_22, x_21); -x_24 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_24 = l_Lean_String_HasQuote___closed__2; x_25 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_25, 0, x_24); lean_ctor_set(x_25, 1, x_23); @@ -3731,10 +3731,10 @@ lean_ctor_set(x_75, 0, x_42); lean_ctor_set(x_75, 1, x_74); x_76 = lean_array_push(x_38, x_75); x_77 = lean_array_push(x_38, x_25); -x_78 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_78 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; x_79 = l_Lean_addMacroScope(x_58, x_78, x_54); -x_80 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_81 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_80 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_81 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_82 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_82, 0, x_20); lean_ctor_set(x_82, 1, x_80); @@ -3758,9 +3758,9 @@ x_91 = lean_array_push(x_90, x_40); x_92 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_92, 0, x_47); lean_ctor_set(x_92, 1, x_91); -x_93 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_93 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_94 = lean_array_push(x_93, x_92); -x_95 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_95 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_96 = lean_array_push(x_94, x_95); x_97 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_98 = lean_alloc_ctor(1, 2, 0); @@ -3821,10 +3821,10 @@ lean_ctor_set(x_122, 0, x_42); lean_ctor_set(x_122, 1, x_121); x_123 = lean_array_push(x_38, x_122); x_124 = lean_array_push(x_38, x_25); -x_125 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_125 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; x_126 = l_Lean_addMacroScope(x_104, x_125, x_54); -x_127 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_128 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_127 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_128 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_129 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_129, 0, x_20); lean_ctor_set(x_129, 1, x_127); @@ -3848,9 +3848,9 @@ x_138 = lean_array_push(x_137, x_40); x_139 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_139, 0, x_47); lean_ctor_set(x_139, 1, x_138); -x_140 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_140 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_141 = lean_array_push(x_140, x_139); -x_142 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_142 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_143 = lean_array_push(x_141, x_142); x_144 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_145 = lean_alloc_ctor(1, 2, 0); @@ -3949,9 +3949,9 @@ x_190 = lean_array_push(x_189, x_40); x_191 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_191, 0, x_47); lean_ctor_set(x_191, 1, x_190); -x_192 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_192 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_193 = lean_array_push(x_192, x_191); -x_194 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_194 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_195 = lean_array_push(x_193, x_194); x_196 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_197 = lean_alloc_ctor(1, 2, 0); @@ -4057,9 +4057,9 @@ x_247 = lean_array_push(x_246, x_40); x_248 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_248, 0, x_47); lean_ctor_set(x_248, 1, x_247); -x_249 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_249 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_250 = lean_array_push(x_249, x_248); -x_251 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_251 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_252 = lean_array_push(x_250, x_251); x_253 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_254 = lean_alloc_ctor(1, 2, 0); @@ -4330,7 +4330,7 @@ lean_dec(x_8); x_14 = lean_ctor_get(x_9, 0); lean_inc(x_14); lean_dec(x_9); -x_15 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_14); +x_15 = l___private_Init_Lean_Syntax_7__quoteName___main(x_14); x_16 = l_Lean_Elab_Term_getCurrMacroScope(x_2, x_13); lean_dec(x_2); x_17 = lean_ctor_get(x_16, 0); @@ -7923,7 +7923,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__4; +x_2 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__4; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } diff --git a/stage0/stdlib/Init/Lean/Elab/Command.c b/stage0/stdlib/Init/Lean/Elab/Command.c index 1038f3e887..0da9516c1b 100644 --- a/stage0/stdlib/Init/Lean/Elab/Command.c +++ b/stage0/stdlib/Init/Lean/Elab/Command.c @@ -495,7 +495,7 @@ lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Command_elabExport___spec lean_object* l_Lean_Elab_Command_Lean_Elab_MonadMacroAdapter___lambda__2(lean_object*, lean_object*, lean_object*); uint8_t l___private_Init_Lean_Elab_Command_15__checkEndHeader(lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_mkCommandElabAttribute___closed__5; -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_CommandElabM_inhabited___closed__1; extern lean_object* l___private_Init_Lean_Elab_Util_4__regTraceClasses___closed__1; lean_object* l_Lean_Elab_Command_elabChoiceAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -700,7 +700,6 @@ x_8 = lean_ctor_get(x_1, 4); lean_inc(x_8); lean_dec(x_1); x_9 = l_Lean_Elab_mkMessageCore(x_5, x_6, x_3, x_4, x_8); -lean_dec(x_8); lean_dec(x_6); return x_9; } @@ -712,7 +711,6 @@ x_10 = lean_ctor_get(x_7, 0); lean_inc(x_10); lean_dec(x_7); x_11 = l_Lean_Elab_mkMessageCore(x_5, x_6, x_3, x_4, x_10); -lean_dec(x_10); lean_dec(x_6); return x_11; } @@ -1975,7 +1973,6 @@ lean_inc(x_7); x_8 = lean_ctor_get(x_4, 4); lean_inc(x_8); x_9 = l_Lean_FileMap_toPosition(x_7, x_8); -lean_dec(x_8); lean_dec(x_7); x_10 = l_Lean_Elab_Command_addContext(x_1, x_4, x_5); if (lean_obj_tag(x_10) == 0) @@ -2054,6 +2051,8 @@ lean_inc(x_26); x_27 = lean_ctor_get(x_4, 1); lean_inc(x_27); x_28 = lean_ctor_get(x_3, 0); +lean_inc(x_28); +lean_dec(x_3); x_29 = l_Lean_FileMap_toPosition(x_27, x_28); lean_dec(x_27); x_30 = l_Lean_Elab_Command_addContext(x_1, x_4, x_5); @@ -2140,7 +2139,6 @@ lean_dec(x_6); x_9 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_9, 0, x_7); x_10 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Command_throwError___spec__3(x_1, x_2, x_9, x_4, x_8); -lean_dec(x_9); return x_10; } } @@ -2235,7 +2233,6 @@ uint8_t x_6; lean_object* x_7; x_6 = lean_unbox(x_2); lean_dec(x_2); x_7 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Command_throwError___spec__3(x_1, x_6, x_3, x_4, x_5); -lean_dec(x_3); return x_7; } } @@ -2267,7 +2264,6 @@ x_6 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_6, 0, x_1); lean_inc(x_4); x_7 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Command_throwError___spec__3(x_3, x_2, x_6, x_4, x_5); -lean_dec(x_6); if (lean_obj_tag(x_7) == 0) { lean_object* x_8; lean_object* x_9; lean_object* x_10; @@ -17017,7 +17013,6 @@ lean_ctor_set(x_22, 0, x_20); lean_ctor_set(x_22, 1, x_21); x_23 = 0; x_24 = l_Lean_Elab_log___at_Lean_Elab_Term_logTrace___spec__1(x_2, x_23, x_22, x_4, x_17); -lean_dec(x_4); x_25 = !lean_is_exclusive(x_24); if (x_25 == 0) { @@ -19083,7 +19078,6 @@ x_27 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_27, 0, x_24); x_28 = 0; x_29 = l_Lean_Elab_log___at_Lean_Elab_Term_logTrace___spec__1(x_2, x_28, x_27, x_4, x_26); -lean_dec(x_4); x_30 = !lean_is_exclusive(x_29); if (x_30 == 0) { @@ -19180,7 +19174,6 @@ x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_54); x_58 = 0; x_59 = l_Lean_Elab_log___at_Lean_Elab_Term_logTrace___spec__1(x_2, x_58, x_57, x_4, x_56); -lean_dec(x_4); x_60 = lean_ctor_get(x_59, 1); lean_inc(x_60); if (lean_is_exclusive(x_59)) { @@ -21042,115 +21035,116 @@ return x_2; lean_object* l_Lean_Elab_Command_elabSetOption(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_21; +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_22; x_4 = lean_unsigned_to_nat(1u); x_5 = l_Lean_Syntax_getIdAt(x_1, x_4); x_6 = lean_unsigned_to_nat(2u); x_7 = l_Lean_Syntax_getArg(x_1, x_6); -x_21 = l_Lean_Syntax_isStrLit_x3f(x_7); -if (lean_obj_tag(x_21) == 0) +x_22 = l_Lean_Syntax_isStrLit_x3f(x_7); +if (lean_obj_tag(x_22) == 0) { -lean_object* x_22; lean_object* x_23; -x_22 = l_Lean_numLitKind; -x_23 = l_Lean_Syntax_isNatLitAux(x_22, x_7); -if (lean_obj_tag(x_23) == 0) +lean_object* x_23; lean_object* x_24; +x_23 = l_Lean_numLitKind; +x_24 = l_Lean_Syntax_isNatLitAux(x_23, x_7); +if (lean_obj_tag(x_24) == 0) { if (lean_obj_tag(x_7) == 2) { -lean_object* x_24; lean_object* x_25; uint8_t x_26; -x_24 = lean_ctor_get(x_7, 1); -lean_inc(x_24); -x_25 = l_Bool_HasRepr___closed__2; -x_26 = lean_string_dec_eq(x_24, x_25); -if (x_26 == 0) +lean_object* x_25; lean_object* x_26; uint8_t x_27; +x_25 = lean_ctor_get(x_7, 1); +lean_inc(x_25); +x_26 = l_Bool_HasRepr___closed__2; +x_27 = lean_string_dec_eq(x_25, x_26); +if (x_27 == 0) { -lean_object* x_27; uint8_t x_28; -x_27 = l_Bool_HasRepr___closed__1; -x_28 = lean_string_dec_eq(x_24, x_27); -lean_dec(x_24); -if (x_28 == 0) +lean_object* x_28; uint8_t x_29; +x_28 = l_Bool_HasRepr___closed__1; +x_29 = lean_string_dec_eq(x_25, x_28); +lean_dec(x_25); +if (x_29 == 0) { -lean_object* x_29; +lean_object* x_30; lean_dec(x_5); -x_29 = lean_box(0); -x_8 = x_29; -goto block_20; +x_30 = lean_box(0); +x_8 = x_30; +goto block_21; } else { -lean_object* x_30; lean_object* x_31; +lean_object* x_31; lean_object* x_32; lean_dec(x_7); -x_30 = l_Lean_registerTraceClass___closed__1; -x_31 = l_Lean_Elab_Command_setOption(x_1, x_5, x_30, x_2, x_3); -return x_31; +x_31 = l_Lean_registerTraceClass___closed__1; +x_32 = l_Lean_Elab_Command_setOption(x_1, x_5, x_31, x_2, x_3); +return x_32; } } else { -lean_object* x_32; lean_object* x_33; -lean_dec(x_24); +lean_object* x_33; lean_object* x_34; +lean_dec(x_25); lean_dec(x_7); -x_32 = l_Lean_verboseOption___closed__3; -x_33 = l_Lean_Elab_Command_setOption(x_1, x_5, x_32, x_2, x_3); -return x_33; +x_33 = l_Lean_verboseOption___closed__3; +x_34 = l_Lean_Elab_Command_setOption(x_1, x_5, x_33, x_2, x_3); +return x_34; } } else { -lean_object* x_34; +lean_object* x_35; lean_dec(x_5); -x_34 = lean_box(0); -x_8 = x_34; -goto block_20; +x_35 = lean_box(0); +x_8 = x_35; +goto block_21; } } else { -lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_dec(x_7); -x_35 = lean_ctor_get(x_23, 0); -lean_inc(x_35); -lean_dec(x_23); -x_36 = lean_alloc_ctor(3, 1, 0); -lean_ctor_set(x_36, 0, x_35); -x_37 = l_Lean_Elab_Command_setOption(x_1, x_5, x_36, x_2, x_3); -return x_37; +x_36 = lean_ctor_get(x_24, 0); +lean_inc(x_36); +lean_dec(x_24); +x_37 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_37, 0, x_36); +x_38 = l_Lean_Elab_Command_setOption(x_1, x_5, x_37, x_2, x_3); +return x_38; } } else { -lean_object* x_38; lean_object* x_39; lean_object* x_40; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_dec(x_7); -x_38 = lean_ctor_get(x_21, 0); -lean_inc(x_38); -lean_dec(x_21); -x_39 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_39, 0, x_38); -x_40 = l_Lean_Elab_Command_setOption(x_1, x_5, x_39, x_2, x_3); -return x_40; +x_39 = lean_ctor_get(x_22, 0); +lean_inc(x_39); +lean_dec(x_22); +x_40 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_40, 0, x_39); +x_41 = l_Lean_Elab_Command_setOption(x_1, x_5, x_40, x_2, x_3); +return x_41; } -block_20: +block_21: { -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; uint8_t x_18; lean_object* x_19; +lean_object* x_9; uint8_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_dec(x_8); x_9 = lean_box(0); -x_10 = lean_unsigned_to_nat(0u); +x_10 = 0; +x_11 = lean_unsigned_to_nat(0u); lean_inc(x_7); -x_11 = l_Lean_Syntax_formatStxAux___main(x_9, x_10, x_7); -x_12 = l_Lean_Options_empty; -x_13 = l_Lean_Format_pretty(x_11, x_12); -x_14 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_14, 0, x_13); -x_15 = lean_alloc_ctor(0, 1, 0); +x_12 = l_Lean_Syntax_formatStxAux___main(x_9, x_10, x_11, x_7); +x_13 = l_Lean_Options_empty; +x_14 = l_Lean_Format_pretty(x_12, x_13); +x_15 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_15, 0, x_14); -x_16 = l_Lean_Elab_Command_elabSetOption___closed__3; -x_17 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_17, 0, x_16); -lean_ctor_set(x_17, 1, x_15); -x_18 = 2; -x_19 = l_Lean_Elab_log___at_Lean_Elab_Command_logTrace___spec__1(x_7, x_18, x_17, x_2, x_3); +x_16 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_16, 0, x_15); +x_17 = l_Lean_Elab_Command_elabSetOption___closed__3; +x_18 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_16); +x_19 = 2; +x_20 = l_Lean_Elab_log___at_Lean_Elab_Command_logTrace___spec__1(x_7, x_19, x_18, x_2, x_3); lean_dec(x_7); -return x_19; +return x_20; } } } diff --git a/stage0/stdlib/Init/Lean/Elab/DeclModifiers.c b/stage0/stdlib/Init/Lean/Elab/DeclModifiers.c index c31be61e68..3e05c9fed5 100644 --- a/stage0/stdlib/Init/Lean/Elab/DeclModifiers.c +++ b/stage0/stdlib/Init/Lean/Elab/DeclModifiers.c @@ -115,7 +115,7 @@ lean_object* l_Lean_Elab_Command_Attribute_hasFormat(lean_object*); extern lean_object* l_Lean_Parser_Command_private___elambda__1___closed__2; lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Command_partial___elambda__1___closed__1; -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabModifiers___closed__7; lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabAttr(lean_object*, lean_object*, lean_object*); @@ -162,29 +162,29 @@ lean_dec(x_1); x_7 = l_Lean_Syntax_isMissing(x_6); 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; uint8_t 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_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; x_8 = lean_box(0); -x_9 = lean_unsigned_to_nat(0u); -x_10 = l_Lean_Syntax_formatStxAux___main(x_8, x_9, x_6); -x_11 = l_Lean_Options_empty; -x_12 = l_Lean_Format_pretty(x_10, x_11); -x_13 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_13, 0, x_12); -x_14 = 0; +x_9 = 0; +x_10 = lean_unsigned_to_nat(0u); +x_11 = l_Lean_Syntax_formatStxAux___main(x_8, x_9, x_10, x_6); +x_12 = l_Lean_Options_empty; +x_13 = l_Lean_Format_pretty(x_11, x_12); +x_14 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_14, 0, x_13); x_15 = lean_alloc_ctor(4, 2, 1); lean_ctor_set(x_15, 0, x_5); -lean_ctor_set(x_15, 1, x_13); -lean_ctor_set_uint8(x_15, sizeof(void*)*2, x_14); +lean_ctor_set(x_15, 1, x_14); +lean_ctor_set_uint8(x_15, sizeof(void*)*2, x_9); x_16 = l_Lean_Elab_Command_Attribute_hasFormat___closed__2; x_17 = lean_alloc_ctor(4, 2, 1); lean_ctor_set(x_17, 0, x_16); lean_ctor_set(x_17, 1, x_15); -lean_ctor_set_uint8(x_17, sizeof(void*)*2, x_14); +lean_ctor_set_uint8(x_17, sizeof(void*)*2, x_9); x_18 = l_Lean_Format_sbracket___closed__3; x_19 = lean_alloc_ctor(4, 2, 1); lean_ctor_set(x_19, 0, x_17); lean_ctor_set(x_19, 1, x_18); -lean_ctor_set_uint8(x_19, sizeof(void*)*2, x_14); +lean_ctor_set_uint8(x_19, sizeof(void*)*2, x_9); x_20 = l_Lean_Elab_Command_Attribute_hasFormat___closed__1; x_21 = lean_alloc_ctor(3, 2, 0); lean_ctor_set(x_21, 0, x_20); @@ -317,29 +317,29 @@ lean_dec(x_1); x_7 = l_Lean_Syntax_isMissing(x_6); 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; uint8_t 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_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; x_8 = lean_box(0); -x_9 = lean_unsigned_to_nat(0u); -x_10 = l_Lean_Syntax_formatStxAux___main(x_8, x_9, x_6); -x_11 = l_Lean_Options_empty; -x_12 = l_Lean_Format_pretty(x_10, x_11); -x_13 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_13, 0, x_12); -x_14 = 0; +x_9 = 0; +x_10 = lean_unsigned_to_nat(0u); +x_11 = l_Lean_Syntax_formatStxAux___main(x_8, x_9, x_10, x_6); +x_12 = l_Lean_Options_empty; +x_13 = l_Lean_Format_pretty(x_11, x_12); +x_14 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_14, 0, x_13); x_15 = lean_alloc_ctor(4, 2, 1); lean_ctor_set(x_15, 0, x_5); -lean_ctor_set(x_15, 1, x_13); -lean_ctor_set_uint8(x_15, sizeof(void*)*2, x_14); +lean_ctor_set(x_15, 1, x_14); +lean_ctor_set_uint8(x_15, sizeof(void*)*2, x_9); x_16 = l_Lean_Elab_Command_Attribute_hasFormat___closed__2; x_17 = lean_alloc_ctor(4, 2, 1); lean_ctor_set(x_17, 0, x_16); lean_ctor_set(x_17, 1, x_15); -lean_ctor_set_uint8(x_17, sizeof(void*)*2, x_14); +lean_ctor_set_uint8(x_17, sizeof(void*)*2, x_9); x_18 = l_Lean_Format_sbracket___closed__3; x_19 = lean_alloc_ctor(4, 2, 1); lean_ctor_set(x_19, 0, x_17); lean_ctor_set(x_19, 1, x_18); -lean_ctor_set_uint8(x_19, sizeof(void*)*2, x_14); +lean_ctor_set_uint8(x_19, sizeof(void*)*2, x_9); x_20 = l_Lean_Elab_Command_Attribute_hasFormat___closed__1; x_21 = lean_alloc_ctor(3, 2, 0); lean_ctor_set(x_21, 0, x_20); @@ -1525,158 +1525,160 @@ uint8_t x_86; x_86 = !lean_is_exclusive(x_84); if (x_86 == 0) { -lean_object* x_87; lean_object* x_88; lean_object* x_104; +lean_object* x_87; lean_object* x_88; lean_object* x_105; x_87 = lean_ctor_get(x_84, 0); -x_104 = l_Lean_Syntax_getArg(x_87, x_6); -if (lean_obj_tag(x_104) == 2) +x_105 = l_Lean_Syntax_getArg(x_87, x_6); +if (lean_obj_tag(x_105) == 2) { -lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_dec(x_87); -x_105 = lean_ctor_get(x_104, 1); -lean_inc(x_105); -lean_dec(x_104); -x_106 = lean_string_utf8_byte_size(x_105); -x_107 = lean_nat_sub(x_106, x_8); -lean_dec(x_106); -x_108 = lean_string_utf8_extract(x_105, x_4, x_107); -lean_dec(x_107); +x_106 = lean_ctor_get(x_105, 1); +lean_inc(x_106); lean_dec(x_105); -lean_ctor_set(x_84, 0, x_108); +x_107 = lean_string_utf8_byte_size(x_106); +x_108 = lean_nat_sub(x_107, x_8); +lean_dec(x_107); +x_109 = lean_string_utf8_extract(x_106, x_4, x_108); +lean_dec(x_108); +lean_dec(x_106); +lean_ctor_set(x_84, 0, x_109); x_16 = x_84; x_17 = x_3; goto block_83; } else { -lean_object* x_109; -lean_dec(x_104); +lean_object* x_110; +lean_dec(x_105); lean_free_object(x_84); lean_dec(x_15); lean_dec(x_13); lean_dec(x_11); lean_dec(x_9); lean_dec(x_7); -x_109 = lean_box(0); -x_88 = x_109; -goto block_103; +x_110 = lean_box(0); +x_88 = x_110; +goto block_104; } -block_103: +block_104: { -lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; uint8_t x_99; +lean_object* x_89; lean_object* x_90; uint8_t x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; uint8_t x_100; lean_dec(x_88); x_89 = l_Lean_Syntax_getArg(x_87, x_6); x_90 = lean_box(0); -x_91 = l_Lean_Syntax_formatStxAux___main(x_90, x_4, x_89); -x_92 = l_Lean_Options_empty; -x_93 = l_Lean_Format_pretty(x_91, x_92); -x_94 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_94, 0, x_93); -x_95 = lean_alloc_ctor(0, 1, 0); +x_91 = 0; +x_92 = l_Lean_Syntax_formatStxAux___main(x_90, x_91, x_4, x_89); +x_93 = l_Lean_Options_empty; +x_94 = l_Lean_Format_pretty(x_92, x_93); +x_95 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_95, 0, x_94); -x_96 = l_Lean_Elab_Command_elabModifiers___closed__7; -x_97 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_97, 0, x_96); -lean_ctor_set(x_97, 1, x_95); -x_98 = l_Lean_Elab_Command_throwError___rarg(x_87, x_97, x_2, x_3); +x_96 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_96, 0, x_95); +x_97 = l_Lean_Elab_Command_elabModifiers___closed__7; +x_98 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_98, 0, x_97); +lean_ctor_set(x_98, 1, x_96); +x_99 = l_Lean_Elab_Command_throwError___rarg(x_87, x_98, x_2, x_3); lean_dec(x_87); -x_99 = !lean_is_exclusive(x_98); -if (x_99 == 0) +x_100 = !lean_is_exclusive(x_99); +if (x_100 == 0) { -return x_98; +return x_99; } else { -lean_object* x_100; lean_object* x_101; lean_object* x_102; -x_100 = lean_ctor_get(x_98, 0); -x_101 = lean_ctor_get(x_98, 1); +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_99, 0); +x_102 = lean_ctor_get(x_99, 1); +lean_inc(x_102); lean_inc(x_101); -lean_inc(x_100); -lean_dec(x_98); -x_102 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_102, 0, x_100); -lean_ctor_set(x_102, 1, x_101); -return x_102; +lean_dec(x_99); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; } } } else { -lean_object* x_110; lean_object* x_111; lean_object* x_127; -x_110 = lean_ctor_get(x_84, 0); -lean_inc(x_110); +lean_object* x_111; lean_object* x_112; lean_object* x_129; +x_111 = lean_ctor_get(x_84, 0); +lean_inc(x_111); lean_dec(x_84); -x_127 = l_Lean_Syntax_getArg(x_110, x_6); -if (lean_obj_tag(x_127) == 2) +x_129 = l_Lean_Syntax_getArg(x_111, x_6); +if (lean_obj_tag(x_129) == 2) { -lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; -lean_dec(x_110); -x_128 = lean_ctor_get(x_127, 1); -lean_inc(x_128); -lean_dec(x_127); -x_129 = lean_string_utf8_byte_size(x_128); -x_130 = lean_nat_sub(x_129, x_8); +lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +lean_dec(x_111); +x_130 = lean_ctor_get(x_129, 1); +lean_inc(x_130); lean_dec(x_129); -x_131 = lean_string_utf8_extract(x_128, x_4, x_130); +x_131 = lean_string_utf8_byte_size(x_130); +x_132 = lean_nat_sub(x_131, x_8); +lean_dec(x_131); +x_133 = lean_string_utf8_extract(x_130, x_4, x_132); +lean_dec(x_132); lean_dec(x_130); -lean_dec(x_128); -x_132 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_132, 0, x_131); -x_16 = x_132; +x_134 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_134, 0, x_133); +x_16 = x_134; x_17 = x_3; goto block_83; } else { -lean_object* x_133; -lean_dec(x_127); +lean_object* x_135; +lean_dec(x_129); lean_dec(x_15); lean_dec(x_13); lean_dec(x_11); lean_dec(x_9); lean_dec(x_7); -x_133 = lean_box(0); -x_111 = x_133; -goto block_126; +x_135 = lean_box(0); +x_112 = x_135; +goto block_128; } -block_126: +block_128: { -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_object* x_118; 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_dec(x_111); -x_112 = l_Lean_Syntax_getArg(x_110, x_6); -x_113 = lean_box(0); -x_114 = l_Lean_Syntax_formatStxAux___main(x_113, x_4, x_112); -x_115 = l_Lean_Options_empty; -x_116 = l_Lean_Format_pretty(x_114, x_115); -x_117 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_117, 0, x_116); -x_118 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_118, 0, x_117); -x_119 = l_Lean_Elab_Command_elabModifiers___closed__7; -x_120 = lean_alloc_ctor(9, 2, 0); +lean_object* x_113; lean_object* x_114; uint8_t x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; +lean_dec(x_112); +x_113 = l_Lean_Syntax_getArg(x_111, x_6); +x_114 = lean_box(0); +x_115 = 0; +x_116 = l_Lean_Syntax_formatStxAux___main(x_114, x_115, x_4, x_113); +x_117 = l_Lean_Options_empty; +x_118 = l_Lean_Format_pretty(x_116, x_117); +x_119 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_119, 0, x_118); +x_120 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_120, 0, x_119); -lean_ctor_set(x_120, 1, x_118); -x_121 = l_Lean_Elab_Command_throwError___rarg(x_110, x_120, x_2, x_3); -lean_dec(x_110); -x_122 = lean_ctor_get(x_121, 0); -lean_inc(x_122); -x_123 = lean_ctor_get(x_121, 1); -lean_inc(x_123); -if (lean_is_exclusive(x_121)) { - lean_ctor_release(x_121, 0); - lean_ctor_release(x_121, 1); - x_124 = x_121; +x_121 = l_Lean_Elab_Command_elabModifiers___closed__7; +x_122 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_122, 0, x_121); +lean_ctor_set(x_122, 1, x_120); +x_123 = l_Lean_Elab_Command_throwError___rarg(x_111, x_122, x_2, x_3); +lean_dec(x_111); +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +x_125 = lean_ctor_get(x_123, 1); +lean_inc(x_125); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_126 = x_123; } else { - lean_dec_ref(x_121); - x_124 = lean_box(0); + lean_dec_ref(x_123); + x_126 = lean_box(0); } -if (lean_is_scalar(x_124)) { - x_125 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_126)) { + x_127 = lean_alloc_ctor(1, 2, 0); } else { - x_125 = x_124; + x_127 = x_126; } -lean_ctor_set(x_125, 0, x_122); -lean_ctor_set(x_125, 1, x_123); -return x_125; +lean_ctor_set(x_127, 0, x_124); +lean_ctor_set(x_127, 1, x_125); +return x_127; } } } diff --git a/stage0/stdlib/Init/Lean/Elab/Declaration.c b/stage0/stdlib/Init/Lean/Elab/Declaration.c index e9805b5879..03a92b1c25 100644 --- a/stage0/stdlib/Init/Lean/Elab/Declaration.c +++ b/stage0/stdlib/Init/Lean/Elab/Declaration.c @@ -14,7 +14,6 @@ extern "C" { #endif lean_object* l_Lean_Elab_Command_elabDeclaration(lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__3; lean_object* l_Lean_Elab_Term_mkForall(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_extractMacroScopes(lean_object*); extern lean_object* l_Lean_Parser_Command_abbrev___elambda__1___closed__2; @@ -75,7 +74,6 @@ lean_object* l_Lean_Elab_Command_elabConstant(lean_object*, lean_object*, lean_o lean_object* l_Lean_Elab_Command_elabAxiom___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_expandOptDeclSig(lean_object*); extern lean_object* l_Lean_Elab_Command_mkDef___lambda__1___closed__1; -extern lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11; extern lean_object* l_Lean_Meta_registerInstanceAttr___closed__2; lean_object* l_Lean_Syntax_getId(lean_object*); lean_object* l_Lean_Elab_Command_elabClassInductive(lean_object*, lean_object*, lean_object*); @@ -111,6 +109,7 @@ lean_object* l_Lean_MacroScopesView_review(lean_object*); lean_object* l_Lean_Elab_Command_elabInductive___boxed(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Command_12__addScopes___main(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabAbbrev___closed__2; +extern lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11; lean_object* l_Lean_Elab_Command_elabStructure(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_Modifiers_addAttribute(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabType(lean_object*, lean_object*, lean_object*); @@ -144,6 +143,7 @@ lean_object* l_Lean_Elab_Command_elabAbbrev___closed__4; lean_object* l_Lean_CollectLevelParams_main___main(lean_object*, lean_object*); extern lean_object* l_Lean_Elab_Command_liftTermElabM___rarg___closed__1; lean_object* l_Lean_Elab_Command_modifyScope___at_Lean_Elab_Command_elabAxiom___spec__1(lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__3; extern lean_object* l_Lean_Parser_Command_constant___elambda__1___closed__2; extern lean_object* l_Lean_Parser_Command_theorem___elambda__1___closed__2; lean_object* l_Lean_Elab_Command_elabClassInductive___rarg(lean_object*); @@ -477,13 +477,13 @@ x_30 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_30, 0, x_29); lean_ctor_set(x_30, 1, x_28); x_31 = lean_array_push(x_25, x_30); -x_32 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11; +x_32 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11; x_33 = lean_array_push(x_31, x_32); x_34 = l_Lean_mkAppStx___closed__8; x_35 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_35, 0, x_34); lean_ctor_set(x_35, 1, x_33); -x_36 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__3; +x_36 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__3; x_37 = l_Lean_mkAtomFrom(x_2, x_36); x_38 = l_Lean_mkAppStx___closed__9; x_39 = lean_array_push(x_38, x_37); diff --git a/stage0/stdlib/Init/Lean/Elab/Definition.c b/stage0/stdlib/Init/Lean/Elab/Definition.c index 7c15037f5e..568ddbf35b 100644 --- a/stage0/stdlib/Init/Lean/Elab/Definition.c +++ b/stage0/stdlib/Init/Lean/Elab/Definition.c @@ -61,7 +61,6 @@ lean_object* l_Lean_Elab_Command_mkDeclName(lean_object*, lean_object*, lean_obj lean_object* l_Lean_Elab_Command_collectUsedFVarsAtFVars(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabDefLike___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_array_fget(lean_object*, lean_object*); -lean_object* l_ShareCommonT_withShareCommon___at_Lean_Elab_Command_mkDef___spec__1(lean_object*, lean_object*); uint8_t lean_nat_dec_eq(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Command_collectUsedFVarsAtFVars___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_levelMVarToParam(lean_object*, lean_object*, lean_object*); @@ -1348,14 +1347,6 @@ lean_dec(x_1); return x_10; } } -lean_object* l_ShareCommonT_withShareCommon___at_Lean_Elab_Command_mkDef___spec__1(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; -x_3 = lean_state_sharecommon(x_2, x_1); -return x_3; -} -} lean_object* _init_l_Lean_Elab_Command_mkDef___lambda__1___closed__1() { _start: { @@ -1551,6 +1542,7 @@ lean_ctor_set(x_117, 0, x_43); x_118 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_118, 0, x_116); lean_ctor_set(x_118, 1, x_117); +lean_inc(x_11); x_119 = l_Lean_Elab_Term_logTrace(x_106, x_1, x_118, x_11, x_105); x_120 = lean_ctor_get(x_119, 1); lean_inc(x_120); diff --git a/stage0/stdlib/Init/Lean/Elab/DoNotation.c b/stage0/stdlib/Init/Lean/Elab/DoNotation.c index 79a9924846..be7b35cdb2 100644 --- a/stage0/stdlib/Init/Lean/Elab/DoNotation.c +++ b/stage0/stdlib/Init/Lean/Elab/DoNotation.c @@ -16,6 +16,7 @@ extern "C" { lean_object* l_Lean_Elab_Term_mkAppM(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_getEnv___rarg(lean_object*); lean_object* lean_array_set(lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; lean_object* l___private_Init_Lean_Elab_DoNotation_6__expandLiftMethod(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_DoNotation_2__extractBind___closed__3; @@ -83,8 +84,6 @@ extern lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__6; extern lean_object* l_Lean_Parser_Term_doId___elambda__1___closed__2; lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); lean_object* l_Array_back___at___private_Init_Lean_Elab_DoNotation_10__mkBind___spec__1___boxed(lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; -extern lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11; extern lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__3; lean_object* l_Lean_Elab_Term_logTrace(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_DoNotation_9__extractTypeFormerAppArg___closed__2; @@ -107,6 +106,7 @@ lean_object* l___private_Init_Lean_Elab_DoNotation_9__extractTypeFormerAppArg(le lean_object* l___private_Init_Lean_Elab_DoNotation_7__expandDoElemsAux___main___closed__5; extern lean_object* l_Lean_Parser_Term_let___elambda__1___closed__2; lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; lean_object* l___private_Init_Lean_Elab_DoNotation_5__expandLiftMethodAux(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabDo___closed__1; lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*); @@ -131,6 +131,7 @@ lean_object* l_Lean_Syntax_getKind(lean_object*); lean_object* l___private_Init_Lean_Elab_DoNotation_13__regTraceClasses(lean_object*); extern lean_object* l___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__4; lean_object* lean_panic_fn(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11; lean_object* l___regBuiltin_Lean_Elab_Term_elabDo(lean_object*); lean_object* l___private_Init_Lean_Elab_DoNotation_2__extractBind(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabType(lean_object*, lean_object*, lean_object*); @@ -141,7 +142,6 @@ uint8_t l_Lean_Syntax_isNone(lean_object*); lean_object* l___private_Init_Lean_Elab_DoNotation_5__expandLiftMethodAux___main(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at___private_Init_Lean_Elab_DoNotation_10__mkBind___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_DoNotation_5__expandLiftMethodAux___main___closed__4; -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; extern lean_object* l_Lean_Parser_Term_matchAlt___closed__2; lean_object* l___private_Init_Lean_Elab_DoNotation_5__expandLiftMethodAux___main___closed__1; extern lean_object* l_Lean_Expr_Inhabited; @@ -1451,7 +1451,7 @@ x_63 = l_Lean_Parser_Term_doId___elambda__1___closed__2; lean_ctor_set(x_1, 1, x_62); lean_ctor_set(x_1, 0, x_63); x_64 = lean_array_push(x_56, x_1); -x_65 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_65 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_66 = lean_array_push(x_64, x_65); x_67 = lean_box(0); x_68 = lean_array_push(x_66, x_67); @@ -1508,7 +1508,7 @@ x_95 = l_Lean_Parser_Term_doId___elambda__1___closed__2; lean_ctor_set(x_1, 1, x_94); lean_ctor_set(x_1, 0, x_95); x_96 = lean_array_push(x_88, x_1); -x_97 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_97 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_98 = lean_array_push(x_96, x_97); x_99 = lean_box(0); x_100 = lean_array_push(x_98, x_99); @@ -1580,7 +1580,7 @@ x_131 = l_Lean_Parser_Term_doId___elambda__1___closed__2; lean_ctor_set(x_1, 1, x_130); lean_ctor_set(x_1, 0, x_131); x_132 = lean_array_push(x_124, x_1); -x_133 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_133 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_134 = lean_array_push(x_132, x_133); x_135 = lean_box(0); x_136 = lean_array_push(x_134, x_135); @@ -1703,7 +1703,7 @@ x_176 = l_Lean_Parser_Term_doId___elambda__1___closed__2; lean_ctor_set(x_1, 1, x_175); lean_ctor_set(x_1, 0, x_176); x_177 = lean_array_push(x_169, x_1); -x_178 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_178 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_179 = lean_array_push(x_177, x_178); x_180 = lean_box(0); x_181 = lean_array_push(x_179, x_180); @@ -1939,7 +1939,7 @@ x_247 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_247, 0, x_246); lean_ctor_set(x_247, 1, x_245); x_248 = lean_array_push(x_239, x_247); -x_249 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_249 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_250 = lean_array_push(x_248, x_249); x_251 = lean_box(0); x_252 = lean_array_push(x_250, x_251); @@ -2170,7 +2170,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_empty___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11; x_3 = lean_array_push(x_1, x_2); return x_3; } @@ -2340,7 +2340,7 @@ x_96 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_96, 0, x_95); lean_ctor_set(x_96, 1, x_94); x_97 = lean_array_push(x_88, x_96); -x_98 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_98 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_99 = lean_array_push(x_97, x_98); x_100 = lean_box(0); x_101 = lean_array_push(x_99, x_100); @@ -2446,7 +2446,7 @@ x_158 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_158, 0, x_157); lean_ctor_set(x_158, 1, x_156); x_159 = lean_array_push(x_130, x_158); -x_160 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_160 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_161 = lean_array_push(x_159, x_160); x_162 = l_Lean_mkTermIdFromIdent___closed__2; x_163 = lean_alloc_ctor(1, 2, 0); @@ -2534,7 +2534,7 @@ x_211 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_211, 0, x_210); lean_ctor_set(x_211, 1, x_209); x_212 = lean_array_push(x_130, x_211); -x_213 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_213 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_214 = lean_array_push(x_212, x_213); x_215 = l_Lean_mkTermIdFromIdent___closed__2; x_216 = lean_alloc_ctor(1, 2, 0); @@ -2631,7 +2631,7 @@ x_267 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_267, 0, x_266); lean_ctor_set(x_267, 1, x_265); x_268 = lean_array_push(x_259, x_267); -x_269 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_269 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_270 = lean_array_push(x_268, x_269); x_271 = l_Lean_mkTermIdFromIdent___closed__2; x_272 = lean_alloc_ctor(1, 2, 0); @@ -2724,7 +2724,7 @@ x_325 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_325, 0, x_324); lean_ctor_set(x_325, 1, x_323); x_326 = lean_array_push(x_317, x_325); -x_327 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_327 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_328 = lean_array_push(x_326, x_327); x_329 = l_Lean_mkTermIdFromIdent___closed__2; x_330 = lean_alloc_ctor(1, 2, 0); @@ -2825,9 +2825,9 @@ x_383 = l_Lean_Parser_Term_do___elambda__1___closed__2; x_384 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_384, 0, x_383); lean_ctor_set(x_384, 1, x_382); -x_385 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_385 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_386 = lean_array_push(x_385, x_364); -x_387 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_387 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_388 = lean_array_push(x_386, x_387); x_389 = lean_array_push(x_388, x_384); x_390 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -2887,9 +2887,9 @@ x_410 = lean_array_get(x_408, x_367, x_409); lean_dec(x_367); x_411 = l_Lean_Syntax_getArg(x_410, x_409); lean_dec(x_410); -x_412 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_412 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_413 = lean_array_push(x_412, x_364); -x_414 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_414 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_415 = lean_array_push(x_413, x_414); x_416 = lean_array_push(x_415, x_411); x_417 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -3033,7 +3033,7 @@ x_477 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_477, 0, x_476); lean_ctor_set(x_477, 1, x_475); x_478 = lean_array_push(x_469, x_477); -x_479 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_479 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_480 = lean_array_push(x_478, x_479); x_481 = lean_box(0); x_482 = lean_array_push(x_480, x_481); @@ -3139,7 +3139,7 @@ x_539 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_539, 0, x_538); lean_ctor_set(x_539, 1, x_537); x_540 = lean_array_push(x_511, x_539); -x_541 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_541 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_542 = lean_array_push(x_540, x_541); x_543 = l_Lean_mkTermIdFromIdent___closed__2; x_544 = lean_alloc_ctor(1, 2, 0); @@ -3227,7 +3227,7 @@ x_592 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_592, 0, x_591); lean_ctor_set(x_592, 1, x_590); x_593 = lean_array_push(x_511, x_592); -x_594 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_594 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_595 = lean_array_push(x_593, x_594); x_596 = l_Lean_mkTermIdFromIdent___closed__2; x_597 = lean_alloc_ctor(1, 2, 0); @@ -3324,7 +3324,7 @@ x_648 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_648, 0, x_647); lean_ctor_set(x_648, 1, x_646); x_649 = lean_array_push(x_640, x_648); -x_650 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_650 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_651 = lean_array_push(x_649, x_650); x_652 = l_Lean_mkTermIdFromIdent___closed__2; x_653 = lean_alloc_ctor(1, 2, 0); @@ -3417,7 +3417,7 @@ x_706 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_706, 0, x_705); lean_ctor_set(x_706, 1, x_704); x_707 = lean_array_push(x_698, x_706); -x_708 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_708 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_709 = lean_array_push(x_707, x_708); x_710 = l_Lean_mkTermIdFromIdent___closed__2; x_711 = lean_alloc_ctor(1, 2, 0); @@ -3518,9 +3518,9 @@ x_764 = l_Lean_Parser_Term_do___elambda__1___closed__2; x_765 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_765, 0, x_764); lean_ctor_set(x_765, 1, x_763); -x_766 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_766 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_767 = lean_array_push(x_766, x_745); -x_768 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_768 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_769 = lean_array_push(x_767, x_768); x_770 = lean_array_push(x_769, x_765); x_771 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -3584,9 +3584,9 @@ x_793 = lean_array_get(x_791, x_748, x_792); lean_dec(x_748); x_794 = l_Lean_Syntax_getArg(x_793, x_792); lean_dec(x_793); -x_795 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_795 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_796 = lean_array_push(x_795, x_745); -x_797 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_797 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_798 = lean_array_push(x_796, x_797); x_799 = lean_array_push(x_798, x_794); x_800 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -5590,6 +5590,7 @@ lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_inc(x_1); x_55 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_55, 0, x_1); +lean_inc(x_3); x_56 = l_Lean_Elab_Term_logTrace(x_53, x_1, x_55, x_3, x_52); x_57 = lean_ctor_get(x_56, 1); lean_inc(x_57); diff --git a/stage0/stdlib/Init/Lean/Elab/Exception.c b/stage0/stdlib/Init/Lean/Elab/Exception.c index 22867669b7..1c4ce12573 100644 --- a/stage0/stdlib/Init/Lean/Elab/Exception.c +++ b/stage0/stdlib/Init/Lean/Elab/Exception.c @@ -95,7 +95,6 @@ uint8_t x_6; lean_object* x_7; x_6 = lean_unbox(x_4); lean_dec(x_4); x_7 = l_Lean_Elab_mkMessageCore(x_1, x_2, x_3, x_6, x_5); -lean_dec(x_5); lean_dec(x_2); return x_7; } @@ -125,7 +124,6 @@ _start: { lean_object* x_5; x_5 = l_Lean_Elab_mkExceptionCore(x_1, x_2, x_3, x_4); -lean_dec(x_4); lean_dec(x_2); return x_5; } diff --git a/stage0/stdlib/Init/Lean/Elab/Import.c b/stage0/stdlib/Init/Lean/Elab/Import.c index d86ec1d044..9662cb08b7 100644 --- a/stage0/stdlib/Init/Lean/Elab/Import.c +++ b/stage0/stdlib/Init/Lean/Elab/Import.c @@ -31,8 +31,8 @@ lean_object* l_Lean_Elab_processHeader(lean_object*, lean_object*, lean_object*, lean_object* l_Lean_Elab_parseImports___closed__1; lean_object* l_Lean_MessageLog_toList(lean_object*); lean_object* l_Lean_Elab_headerToImports___closed__3; +lean_object* l_IO_println___at_Lean_HasRepr_hasEval___spec__1(lean_object*, lean_object*); lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); -lean_object* l_IO_println___at_Lean_HasRepr_HasEval___spec__1(lean_object*, lean_object*); lean_object* lean_name_mk_string(lean_object*, lean_object*); lean_object* l_Lean_Elab_processHeader___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_print_deps(lean_object*, lean_object*); @@ -339,7 +339,6 @@ x_35 = lean_ctor_get(x_21, 0); lean_inc(x_35); lean_dec(x_21); x_36 = l_Lean_FileMap_toPosition(x_22, x_35); -lean_dec(x_35); x_37 = 2; x_38 = l_String_splitAux___main___closed__1; lean_inc(x_23); @@ -406,7 +405,6 @@ x_59 = lean_ctor_get(x_44, 0); lean_inc(x_59); lean_dec(x_44); x_60 = l_Lean_FileMap_toPosition(x_45, x_59); -lean_dec(x_59); x_61 = 2; x_62 = l_String_splitAux___main___closed__1; lean_inc(x_46); @@ -513,7 +511,6 @@ x_18 = lean_ctor_get(x_15, 0); lean_inc(x_18); lean_dec(x_15); x_19 = l_Lean_FileMap_toPosition(x_17, x_18); -lean_dec(x_18); lean_dec(x_17); lean_ctor_set(x_12, 0, x_19); lean_ctor_set(x_10, 0, x_16); @@ -536,7 +533,6 @@ x_25 = lean_ctor_get(x_21, 0); lean_inc(x_25); lean_dec(x_21); x_26 = l_Lean_FileMap_toPosition(x_24, x_25); -lean_dec(x_25); lean_dec(x_24); x_27 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_27, 0, x_26); @@ -574,7 +570,6 @@ x_35 = lean_ctor_get(x_30, 0); lean_inc(x_35); lean_dec(x_30); x_36 = l_Lean_FileMap_toPosition(x_34, x_35); -lean_dec(x_35); lean_dec(x_34); if (lean_is_scalar(x_32)) { x_37 = lean_alloc_ctor(0, 2, 0); @@ -633,7 +628,6 @@ x_52 = lean_ctor_get(x_47, 0); lean_inc(x_52); lean_dec(x_47); x_53 = l_Lean_FileMap_toPosition(x_51, x_52); -lean_dec(x_52); lean_dec(x_51); if (lean_is_scalar(x_49)) { x_54 = lean_alloc_ctor(0, 2, 0); @@ -687,7 +681,6 @@ x_69 = lean_ctor_get(x_66, 0); lean_inc(x_69); lean_dec(x_66); x_70 = l_Lean_FileMap_toPosition(x_68, x_69); -lean_dec(x_69); lean_dec(x_68); lean_ctor_set(x_63, 0, x_70); lean_ctor_set(x_61, 0, x_67); @@ -710,7 +703,6 @@ x_76 = lean_ctor_get(x_72, 0); lean_inc(x_76); lean_dec(x_72); x_77 = l_Lean_FileMap_toPosition(x_75, x_76); -lean_dec(x_76); lean_dec(x_75); x_78 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_78, 0, x_77); @@ -748,7 +740,6 @@ x_86 = lean_ctor_get(x_81, 0); lean_inc(x_86); lean_dec(x_81); x_87 = l_Lean_FileMap_toPosition(x_85, x_86); -lean_dec(x_86); lean_dec(x_85); if (lean_is_scalar(x_83)) { x_88 = lean_alloc_ctor(0, 2, 0); @@ -809,7 +800,6 @@ x_103 = lean_ctor_get(x_98, 0); lean_inc(x_103); lean_dec(x_98); x_104 = l_Lean_FileMap_toPosition(x_102, x_103); -lean_dec(x_103); lean_dec(x_102); if (lean_is_scalar(x_100)) { x_105 = lean_alloc_ctor(0, 2, 0); @@ -1049,7 +1039,7 @@ lean_inc(x_9); x_10 = lean_ctor_get(x_8, 1); lean_inc(x_10); lean_dec(x_8); -x_11 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_9, x_10); +x_11 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_9, x_10); lean_dec(x_9); if (lean_obj_tag(x_11) == 0) { diff --git a/stage0/stdlib/Init/Lean/Elab/Level.c b/stage0/stdlib/Init/Lean/Elab/Level.c index 56812c36c8..f81653436d 100644 --- a/stage0/stdlib/Init/Lean/Elab/Level.c +++ b/stage0/stdlib/Init/Lean/Elab/Level.c @@ -19,7 +19,6 @@ lean_object* l_Lean_Elab_Level_LevelElabM_MonadLog___closed__9; lean_object* l_Lean_Syntax_isNatLitAux(lean_object*, lean_object*); lean_object* l_Lean_Elab_Level_LevelElabM_MonadLog___closed__4; lean_object* l_Lean_Elab_Level_elabLevel___main___closed__7; -extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__2; lean_object* l_Lean_Elab_Level_LevelElabM_MonadLog___lambda__2(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MetavarContext_addLevelMVarDecl(lean_object*, lean_object*); lean_object* l_ReaderT_read___at_Lean_Elab_Level_LevelElabM_MonadLog___spec__1(lean_object*, lean_object*); @@ -30,6 +29,7 @@ lean_object* l_Lean_Syntax_getIdAt(lean_object*, lean_object*); uint8_t l_List_elem___main___at_Lean_NameHashSet_insert___spec__2(lean_object*, lean_object*); lean_object* l_Lean_Elab_Level_LevelElabM_MonadLog___lambda__3(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Level_max___elambda__1___closed__1; +extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__1; lean_object* lean_array_get_size(lean_object*); lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*); extern lean_object* l_String_splitAux___main___closed__1; @@ -50,7 +50,6 @@ lean_object* l_Lean_Elab_Level_mkFreshLevelMVar(lean_object*); lean_object* l___private_Init_Data_Array_Basic_4__foldrRangeMAux___main___at_Lean_Elab_Level_elabLevel___main___spec__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Level_addLit___elambda__1___closed__2; lean_object* l_Lean_Elab_Level_LevelElabM_MonadLog___closed__2; -lean_object* l_Lean_Elab_Level_elabLevel___main___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Level_elabLevel___main___closed__5; lean_object* l_Lean_Elab_Level_LevelElabM_MonadLog___closed__6; lean_object* l_Lean_Elab_mkMessageAt___at_Lean_Elab_Level_elabLevel___main___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -68,7 +67,6 @@ lean_object* l_Lean_Elab_mkMessage___at_Lean_Elab_Level_elabLevel___main___spec_ lean_object* l_Lean_FileMap_toPosition(lean_object*, lean_object*); lean_object* l_Lean_Elab_Level_elabLevel___main___closed__1; lean_object* l_Lean_Elab_Level_mkFreshId___rarg(lean_object*); -lean_object* l_Lean_Elab_Level_elabLevel___boxed(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Level_ident___elambda__1___closed__1; lean_object* l_Lean_mkLevelMVar(lean_object*); lean_object* l_Lean_Elab_Level_LevelElabM_MonadLog___lambda__4(lean_object*, lean_object*, lean_object*); @@ -589,12 +587,16 @@ if (lean_obj_tag(x_3) == 0) { lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); x_7 = lean_ctor_get(x_4, 1); +lean_inc(x_7); x_8 = lean_ctor_get(x_4, 2); +lean_inc(x_8); +lean_dec(x_4); x_9 = l_Lean_FileMap_toPosition(x_7, x_8); +lean_dec(x_7); x_10 = lean_box(0); x_11 = l_String_splitAux___main___closed__1; -lean_inc(x_6); x_12 = lean_alloc_ctor(0, 5, 1); lean_ctor_set(x_12, 0, x_6); lean_ctor_set(x_12, 1, x_9); @@ -611,12 +613,17 @@ else { lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; x_14 = lean_ctor_get(x_4, 0); +lean_inc(x_14); x_15 = lean_ctor_get(x_4, 1); +lean_inc(x_15); +lean_dec(x_4); x_16 = lean_ctor_get(x_3, 0); +lean_inc(x_16); +lean_dec(x_3); x_17 = l_Lean_FileMap_toPosition(x_15, x_16); +lean_dec(x_15); x_18 = lean_box(0); x_19 = l_String_splitAux___main___closed__1; -lean_inc(x_14); x_20 = lean_alloc_ctor(0, 5, 1); lean_ctor_set(x_20, 0, x_14); lean_ctor_set(x_20, 1, x_17); @@ -644,7 +651,6 @@ lean_dec(x_6); x_9 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_9, 0, x_7); x_10 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Level_elabLevel___main___spec__4(x_1, x_2, x_9, x_4, x_8); -lean_dec(x_9); return x_10; } } @@ -729,6 +735,7 @@ x_10 = lean_unsigned_to_nat(1u); x_11 = lean_nat_sub(x_3, x_10); lean_dec(x_3); x_12 = lean_array_fget(x_1, x_11); +lean_inc(x_6); x_13 = l_Lean_Elab_Level_elabLevel___main(x_12, x_6, x_7); if (lean_obj_tag(x_13) == 0) { @@ -753,6 +760,7 @@ goto _start; else { lean_dec(x_11); +lean_dec(x_6); lean_ctor_set(x_13, 0, x_17); return x_13; } @@ -779,6 +787,7 @@ else { lean_object* x_25; lean_dec(x_11); +lean_dec(x_6); x_25 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_25, 0, x_22); lean_ctor_set(x_25, 1, x_21); @@ -790,6 +799,7 @@ else { uint8_t x_26; lean_dec(x_11); +lean_dec(x_6); lean_dec(x_5); x_26 = !lean_is_exclusive(x_13); if (x_26 == 0) @@ -814,6 +824,7 @@ return x_29; else { lean_object* x_30; +lean_dec(x_6); lean_dec(x_3); x_30 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_30, 0, x_5); @@ -835,6 +846,7 @@ x_10 = lean_unsigned_to_nat(1u); x_11 = lean_nat_sub(x_3, x_10); lean_dec(x_3); x_12 = lean_array_fget(x_1, x_11); +lean_inc(x_6); x_13 = l_Lean_Elab_Level_elabLevel___main(x_12, x_6, x_7); if (lean_obj_tag(x_13) == 0) { @@ -859,6 +871,7 @@ goto _start; else { lean_dec(x_11); +lean_dec(x_6); lean_ctor_set(x_13, 0, x_17); return x_13; } @@ -885,6 +898,7 @@ else { lean_object* x_25; lean_dec(x_11); +lean_dec(x_6); x_25 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_25, 0, x_22); lean_ctor_set(x_25, 1, x_21); @@ -896,6 +910,7 @@ else { uint8_t x_26; lean_dec(x_11); +lean_dec(x_6); lean_dec(x_5); x_26 = !lean_is_exclusive(x_13); if (x_26 == 0) @@ -920,6 +935,7 @@ return x_29; else { lean_object* x_30; +lean_dec(x_6); lean_dec(x_3); x_30 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_30, 0, x_5); @@ -1038,7 +1054,7 @@ x_12 = lean_name_eq(x_4, x_11); if (x_12 == 0) { lean_object* x_13; uint8_t x_14; -x_13 = l_Lean_Parser_Level_num___elambda__1___closed__2; +x_13 = l_Lean_Parser_Level_num___elambda__1___closed__1; x_14 = lean_name_eq(x_4, x_13); if (x_14 == 0) { @@ -1064,6 +1080,7 @@ else lean_object* x_21; lean_object* x_22; lean_object* x_23; x_21 = lean_unsigned_to_nat(0u); x_22 = l_Lean_Syntax_getArg(x_1, x_21); +lean_inc(x_2); x_23 = l_Lean_Elab_Level_elabLevel___main(x_22, x_2, x_3); if (lean_obj_tag(x_23) == 0) { @@ -1092,6 +1109,7 @@ return x_32; else { lean_object* x_33; lean_object* x_34; +lean_dec(x_2); lean_dec(x_1); x_33 = lean_ctor_get(x_30, 0); lean_inc(x_33); @@ -1126,6 +1144,7 @@ return x_42; else { lean_object* x_43; lean_object* x_44; lean_object* x_45; +lean_dec(x_2); lean_dec(x_1); x_43 = lean_ctor_get(x_40, 0); lean_inc(x_43); @@ -1141,6 +1160,7 @@ return x_45; else { uint8_t x_46; +lean_dec(x_2); lean_dec(x_1); x_46 = !lean_is_exclusive(x_23); if (x_46 == 0) @@ -1170,7 +1190,9 @@ lean_dec(x_4); x_50 = lean_unsigned_to_nat(0u); x_51 = l_Lean_Syntax_getIdAt(x_1, x_50); x_52 = lean_ctor_get(x_2, 3); +lean_inc(x_52); x_53 = l_List_elem___main___at_Lean_NameHashSet_insert___spec__2(x_51, x_52); +lean_dec(x_52); if (x_53 == 0) { lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; @@ -1204,6 +1226,7 @@ return x_61; else { lean_object* x_62; lean_object* x_63; +lean_dec(x_2); lean_dec(x_1); x_62 = l_Lean_mkLevelParam(x_51); x_63 = lean_alloc_ctor(0, 2, 0); @@ -1233,6 +1256,7 @@ return x_69; else { lean_object* x_70; lean_object* x_71; lean_object* x_72; +lean_dec(x_2); lean_dec(x_1); x_70 = lean_ctor_get(x_67, 0); lean_inc(x_70); @@ -1250,6 +1274,7 @@ else { lean_object* x_73; lean_dec(x_4); +lean_dec(x_2); lean_dec(x_1); x_73 = l_Lean_Elab_Level_mkFreshLevelMVar___rarg(x_3); return x_73; @@ -1265,6 +1290,7 @@ lean_dec(x_1); x_76 = l_Lean_Syntax_getArgs(x_75); lean_dec(x_75); x_77 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_76); +lean_inc(x_2); x_78 = l_Lean_Elab_Level_elabLevel___main(x_77, x_2, x_3); if (lean_obj_tag(x_78) == 0) { @@ -1300,6 +1326,7 @@ else { uint8_t x_88; lean_dec(x_76); +lean_dec(x_2); x_88 = !lean_is_exclusive(x_78); if (x_88 == 0) { @@ -1331,6 +1358,7 @@ lean_dec(x_1); x_94 = l_Lean_Syntax_getArgs(x_93); lean_dec(x_93); x_95 = l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(x_94); +lean_inc(x_2); x_96 = l_Lean_Elab_Level_elabLevel___main(x_95, x_2, x_3); if (lean_obj_tag(x_96) == 0) { @@ -1366,6 +1394,7 @@ else { uint8_t x_106; lean_dec(x_94); +lean_dec(x_2); x_106 = !lean_is_exclusive(x_96); if (x_106 == 0) { @@ -1416,8 +1445,6 @@ uint8_t x_6; lean_object* x_7; x_6 = lean_unbox(x_2); lean_dec(x_2); x_7 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Level_elabLevel___main___spec__4(x_1, x_6, x_3, x_4, x_5); -lean_dec(x_4); -lean_dec(x_3); return x_7; } } @@ -1428,7 +1455,6 @@ uint8_t x_6; lean_object* x_7; x_6 = lean_unbox(x_2); lean_dec(x_2); x_7 = l_Lean_Elab_mkMessage___at_Lean_Elab_Level_elabLevel___main___spec__2(x_1, x_6, x_3, x_4, x_5); -lean_dec(x_4); lean_dec(x_3); return x_7; } @@ -1438,7 +1464,6 @@ _start: { lean_object* x_5; x_5 = l_Lean_Elab_throwError___at_Lean_Elab_Level_elabLevel___main___spec__1(x_1, x_2, x_3, x_4); -lean_dec(x_3); lean_dec(x_1); return x_5; } @@ -1448,7 +1473,6 @@ _start: { lean_object* x_5; x_5 = l_Lean_Elab_throwError___at_Lean_Elab_Level_elabLevel___main___spec__5(x_1, x_2, x_3, x_4); -lean_dec(x_3); lean_dec(x_1); return x_5; } @@ -1458,7 +1482,6 @@ _start: { lean_object* x_8; x_8 = l___private_Init_Data_Array_Basic_4__foldrRangeMAux___main___at_Lean_Elab_Level_elabLevel___main___spec__6(x_1, x_2, x_3, x_4, x_5, x_6, x_7); -lean_dec(x_6); lean_dec(x_2); lean_dec(x_1); return x_8; @@ -1469,21 +1492,11 @@ _start: { lean_object* x_8; x_8 = l___private_Init_Data_Array_Basic_4__foldrRangeMAux___main___at_Lean_Elab_Level_elabLevel___main___spec__7(x_1, x_2, x_3, x_4, x_5, x_6, x_7); -lean_dec(x_6); lean_dec(x_2); lean_dec(x_1); return x_8; } } -lean_object* l_Lean_Elab_Level_elabLevel___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -lean_object* x_4; -x_4 = l_Lean_Elab_Level_elabLevel___main(x_1, x_2, x_3); -lean_dec(x_2); -return x_4; -} -} lean_object* l_Lean_Elab_Level_elabLevel(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { @@ -1492,15 +1505,6 @@ x_4 = l_Lean_Elab_Level_elabLevel___main(x_1, x_2, x_3); return x_4; } } -lean_object* l_Lean_Elab_Level_elabLevel___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -lean_object* x_4; -x_4 = l_Lean_Elab_Level_elabLevel(x_1, x_2, x_3); -lean_dec(x_2); -return x_4; -} -} lean_object* initialize_Init_Lean_Meta_LevelDefEq(lean_object*); lean_object* initialize_Init_Lean_Elab_Exception(lean_object*); lean_object* initialize_Init_Lean_Elab_Log(lean_object*); diff --git a/stage0/stdlib/Init/Lean/Elab/Log.c b/stage0/stdlib/Init/Lean/Elab/Log.c index 42bf588192..0defa4d713 100644 --- a/stage0/stdlib/Init/Lean/Elab/Log.c +++ b/stage0/stdlib/Init/Lean/Elab/Log.c @@ -86,6 +86,7 @@ return x_8; else { lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +lean_dec(x_4); x_9 = lean_ctor_get(x_1, 0); lean_inc(x_9); lean_dec(x_1); @@ -93,6 +94,8 @@ x_10 = lean_ctor_get(x_9, 1); lean_inc(x_10); lean_dec(x_9); x_11 = lean_ctor_get(x_2, 0); +lean_inc(x_11); +lean_dec(x_2); x_12 = l_Lean_FileMap_toPosition(x_3, x_11); x_13 = lean_apply_2(x_10, lean_box(0), x_12); return x_13; @@ -145,9 +148,7 @@ _start: { lean_object* x_5; x_5 = l_Lean_Elab_getPosition___rarg___lambda__1(x_1, x_2, x_3, x_4); -lean_dec(x_4); lean_dec(x_3); -lean_dec(x_2); return x_5; } } @@ -198,7 +199,10 @@ return x_15; else { lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_dec(x_9); x_16 = lean_ctor_get(x_3, 0); +lean_inc(x_16); +lean_dec(x_3); x_17 = l_Lean_FileMap_toPosition(x_4, x_16); x_18 = lean_box(x_7); x_19 = lean_alloc_closure((void*)(l_Lean_Elab_mkMessageAt___rarg___lambda__1___boxed), 5, 4); @@ -298,9 +302,7 @@ uint8_t x_10; lean_object* x_11; x_10 = lean_unbox(x_7); lean_dec(x_7); x_11 = l_Lean_Elab_mkMessageAt___rarg___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_10, x_8, x_9); -lean_dec(x_9); lean_dec(x_4); -lean_dec(x_3); return x_11; } } diff --git a/stage0/stdlib/Init/Lean/Elab/Quotation.c b/stage0/stdlib/Init/Lean/Elab/Quotation.c index dfc13d34de..61849017e5 100644 --- a/stage0/stdlib/Init/Lean/Elab/Quotation.c +++ b/stage0/stdlib/Init/Lean/Elab/Quotation.c @@ -13,1036 +13,574 @@ #ifdef __cplusplus extern "C" { #endif +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__6; lean_object* l_List_reverse___rarg(lean_object*); extern lean_object* l_Lean_Expr_eq_x3f___closed__1; extern lean_object* l_Lean_mkHole___closed__3; -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__3; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; -lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__38; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__21; -lean_object* l_Lean_Name_hasQuote___closed__1; -lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; +lean_object* l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__5; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__21; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__34; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__27; lean_object* l_List_tail_x21___rarg(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__7; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__11(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__9; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__14(lean_object*, lean_object*, lean_object*); +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__4; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__2; lean_object* l_Lean_Syntax_isNatLitAux(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__5; +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__1; extern lean_object* l___private_Init_Lean_Compiler_InitAttr_2__isUnitType___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13; extern lean_object* l_Lean_Parser_declareBuiltinParser___closed__8; lean_object* lean_mk_empty_array_with_capacity(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__2(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6; -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___boxed(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_mkTermIdFromIdent(lean_object*); +extern lean_object* l_Lean_Nat_HasQuote___closed__2; lean_object* l_unreachable_x21___rarg(lean_object*); extern lean_object* l_Lean_nullKind; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__1; lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__7; -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__35; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__26; extern lean_object* l_Lean_identKind___closed__1; +lean_object* l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__2___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getOptional_x3f(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__3; +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main(lean_object*); lean_object* l_Array_eraseIdx___rarg(lean_object*, lean_object*); -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__11(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Option_HasRepr___rarg___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__18; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__36; extern lean_object* l_Lean_Parser_Term_eq___elambda__1___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__34; +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__2; lean_object* l_Lean_Format_pretty(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__1; -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__7(lean_object*); -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__11___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__34; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__4(lean_object*, lean_object*, lean_object*); uint8_t lean_name_eq(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__4___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main(lean_object*, lean_object*, lean_object*); +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__5; extern lean_object* l_Lean_Parser_Term_eq___elambda__1___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__15; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__19; lean_object* l_Lean_Syntax_getIdAt(lean_object*, lean_object*); lean_object* lean_local_ctx_mk_let_decl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__23; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__24; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__4; +lean_object* l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__30; +lean_object* l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main(lean_object*); extern lean_object* l_Prod_HasRepr___rarg___closed__1; -lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__21; -lean_object* l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__2___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__38; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__1; +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__3; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; extern lean_object* l_PersistentHashMap_mkCollisionNode___rarg___closed__1; lean_object* l_Lean_mkMVar(lean_object*); -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__7(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__4; extern lean_object* l_Array_empty___closed__1; lean_object* l_ReaderT_pure___at_Lean_Elab_Term_Quotation_HeadInfo_Inhabited___spec__1(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; extern lean_object* l_Lean_Literal_type___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__49; +lean_object* l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main___boxed(lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__9; -extern lean_object* l_Lean_Name_toExprAux___main___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__4; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__38; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__35; lean_object* l___regBuiltin_Lean_Elab_Term_Quotation_elabStxQuot___closed__1; lean_object* l_Lean_Parser_mkParserState(lean_object*); lean_object* l_List_append___rarg(lean_object*, lean_object*); -lean_object* l_Lean_Substring_HasQuote(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__1; -lean_object* l_Lean_Substring_HasQuote___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__21; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__1___boxed(lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__27; -extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__1; -lean_object* l_Lean_Substring_HasQuote___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__1___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__19; -lean_object* l_Lean_Substring_HasQuote___boxed(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__31; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__31; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__5(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__6; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__2; +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2(lean_object*); lean_object* l_Lean_Parser_mkInputContext(lean_object*, lean_object*); lean_object* lean_array_push(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; lean_object* lean_array_get_size(lean_object*); lean_object* l_Lean_Elab_Term_Quotation_HeadInfo_Inhabited___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_HeadInfo_Inhabited___closed__2; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__23; -extern lean_object* l_Lean_Parser_Term_num___elambda__1___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__2; lean_object* l_List_range(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__5; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__14; +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__11(lean_object*, lean_object*, lean_object*); lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(lean_object*, lean_object*, lean_object*); lean_object* l_Array_back___at_Lean_Parser_checkStackTopFn___spec__1(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__12; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_String_splitAux___main___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__9; extern lean_object* l_Lean_Elab_Term_mkFreshAnonymousName___rarg___closed__1; -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_unitToExpr___lambda__1___closed__3; -extern lean_object* l_Lean_Name_toExprAux___main___closed__2; +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__8; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1; +lean_object* l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__2(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_antiquotKind_x3f___boxed(lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__14(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__1; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__1; lean_object* l___regBuiltin_Lean_Elab_Term_Quotation_elabMatchSyntax___closed__1; lean_object* l_Lean_Elab_Term_Quotation_antiquotKind_x3f___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__48; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; +lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__7; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17; lean_object* lean_string_utf8_byte_size(lean_object*); lean_object* l_Lean_Elab_Term_Quotation_elabStxQuot(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_mkAtom(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__13; -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__26; -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___lambda__1___boxed(lean_object*); lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__1(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__47; -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__7; extern lean_object* l_Lean_mkTermIdFromIdent___closed__1; lean_object* l_Lean_Elab_Term_getMainModule___rarg(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__18; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__2___boxed(lean_object*, lean_object*, lean_object*); -extern lean_object* l_Nat_HasOfNat___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__25; +lean_object* l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; lean_object* l_Lean_Elab_Term_Quotation_match__syntax_expand(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_oldExpandMatchSyntax___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__8; -lean_object* l___private_Init_Lean_Elab_Quotation_1__quoteName___main(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__3; extern lean_object* l_Lean_mkAppStx___closed__8; +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__7; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__9(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_mkAppStx___closed__7; lean_object* lean_nat_add(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__5; lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__36; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__9; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__35; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__45; +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___spec__2(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__2; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__18; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__6; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__39; +lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__4; lean_object* l_Lean_Elab_Term_Quotation_oldExpandStxQuot___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__30; -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2(lean_object*); extern lean_object* l_Lean_mkTermIdFromIdent___closed__2; lean_object* l_Array_foldlStepMAux___main___at_Lean_Elab_Term_elabParen___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_mkMData(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__19; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__3; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__1; lean_object* l_List_replicate___rarg(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_getPatternVars(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__2; extern lean_object* l_Lean_Meta_run___rarg___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__1(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg(lean_object*, lean_object*); lean_object* l_List_map___main___at_Lean_Elab_Term_Quotation_oldGetPatternVars___spec__1(lean_object*); -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___boxed(lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__6; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8(lean_object*, lean_object*, lean_object*); +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__2; lean_object* l_Lean_Parser_ParserState_setPos(lean_object*, lean_object*); -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__4; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__34; lean_object* lean_array_fget(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__4; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__2___boxed(lean_object*, lean_object*, lean_object*); uint8_t lean_nat_dec_eq(lean_object*, lean_object*); lean_object* l_Lean_Syntax_findAux___main(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__3; extern lean_object* l_List_Monad; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__3; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___boxed(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Nat_HasQuote___closed__1; extern lean_object* l_Lean_Parser_Term_band___elambda__1___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__36; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__23; extern lean_object* l_Lean_numLitKind; -lean_object* l___private_Init_Lean_Elab_Quotation_1__quoteName(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder___closed__1; extern lean_object* l_Lean_choiceKind___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__1; lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__25; extern lean_object* l___private_Init_Lean_Elab_Term_15__mkPairsAux___main___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__25; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__2(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__9; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__17; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__8; lean_object* lean_expand_stx_quot(lean_object*, lean_object*); lean_object* l_Lean_Syntax_isStrLit_x3f(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__13; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__8; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__4; +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_band___elambda__1___closed__1; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__33; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__22; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__8; lean_object* l_Lean_Elab_Term_Quotation_isAntiquotSplice___boxed(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__2; extern lean_object* l___private_Init_Lean_Elab_Util_1__evalSyntaxConstantUnsafe___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15; extern lean_object* l_Lean_Parser_Syntax_paren___elambda__1___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18; lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__52; -lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM(lean_object*); -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__6(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM(lean_object*); +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__1(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__30; lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_String_HasQuote___closed__1; lean_object* l_Lean_Unhygienic_run___rarg(lean_object*); -lean_object* l_Lean_String_HasQuote(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__4; lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__6; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__47; lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__1; lean_object* l_List_lengthAux___main___rarg(lean_object*, lean_object*); -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__13(lean_object*, lean_object*, lean_object*); +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__1(lean_object*, lean_object*); extern lean_object* l_Lean_Unhygienic_MonadQuotation___closed__4; lean_object* l_Lean_Elab_Term_Quotation_isAntiquotSplicePat___boxed(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; lean_object* l_Lean_Elab_Term_Quotation_getAntiquotTerm(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__1; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___spec__1(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20; +lean_object* l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder___closed__1; lean_object* lean_mk_empty_local_ctx(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__32; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__10; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__4; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__48; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__9; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__2; uint8_t l_Array_anyRangeMAux___main___at_Lean_Elab_Term_Quotation_isAntiquotSplicePat___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; -lean_object* l_Lean_Array_hasQuote___rarg(lean_object*, lean_object*); +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__10___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Nat_repr(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__15; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__35; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__29; lean_object* l_Lean_Elab_Term_Quotation_HeadInfo_Inhabited; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__3(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16; +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__11___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__8(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__3(lean_object*); -lean_object* l_Lean_Name_hasQuote; +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__4___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__33; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56; lean_object* l_Lean_Syntax_getId(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__12; lean_object* lean_get_antiquot_vars(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__2; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__3(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_termParser___closed__2; lean_object* lean_name_mk_string(lean_object*, lean_object*); extern lean_object* l_Lean_choiceKind; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__2; extern lean_object* l_Lean_Parser_darrow___elambda__1___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; lean_object* l_Lean_Elab_Term_throwError___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__28; extern lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_Quotation_elabMatchSyntax(lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3___closed__1; +lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__6; extern lean_object* l_Lean_Elab_Exception_hasToString___closed__1; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__14; extern lean_object* l_PersistentArray_empty___closed__3; lean_object* l_Lean_Elab_Term_resolveName(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main(lean_object*); -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__9___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__9(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_getCurrMacroScope(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__2(lean_object*, lean_object*, lean_object*); -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__4(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__46; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__49; lean_object* l_List_map___main___at_Lean_Elab_Term_Quotation_oldExpandMatchSyntax___spec__1(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__12(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__16; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4; extern lean_object* l_Lean_Parser_Term_fun___elambda__1___closed__1; -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__6___boxed(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_mkAppStx___closed__6; extern lean_object* l_Lean_Options_empty; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__1; lean_object* l_List_map___main___at_Lean_Elab_Term_Quotation_oldExpandMatchSyntax___spec__2(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_beq___elambda__1___closed__1; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__10___boxed(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5; -lean_object* l_Lean_Array_hasQuote___rarg___boxed(lean_object*, lean_object*); +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__1(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6; extern lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__2; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__2; extern lean_object* l_Lean_Parser_Term_append___elambda__1___closed__1; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__9(lean_object*, lean_object*, lean_object*); +lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__3; lean_object* l_Lean_Elab_Term_Quotation_isEscapedAntiquot___boxed(lean_object*); extern lean_object* l_List_head_x21___rarg___closed__2; uint8_t l_Array_isEmpty___rarg(lean_object*); uint8_t l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___lambda__1(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__36; extern lean_object* l_Lean_firstFrontendMacroScope; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5; +lean_object* l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___boxed(lean_object*); extern lean_object* l_Lean_Parser_Term_beq___elambda__1___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; lean_object* l_Lean_FileMap_ofString(lean_object*); extern lean_object* l_Lean_Parser_Term_let___elambda__1___closed__2; lean_object* l_List_redLength___main___rarg(lean_object*); -extern lean_object* l_Lean_Name_toExprAux___main___closed__7; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_getTokenTable(lean_object*); -lean_object* l_Lean_List_hasQuote(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__19; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__10; lean_object* l_ReaderT_bind___at_Lean_Elab_Term_monadLog___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Expr_listLitAux___main___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__7; uint8_t l_Lean_Elab_Term_Quotation_isAntiquot(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___rarg(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__15; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; lean_object* l_Lean_mkFVar(lean_object*); -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__37; +lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__4; lean_object* l_Lean_Elab_Term_TermElabM_inhabited___boxed(lean_object*, lean_object*); extern lean_object* l_Lean_nullKind___closed__1; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__8(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__40; +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax(lean_object*, lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Option_hasQuote(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__1(lean_object*, lean_object*, lean_object*); +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__6(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_String_HasQuote___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__39; +lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45; uint8_t l_Lean_Syntax_isAtom(lean_object*); extern lean_object* l_Lean_nullKind___closed__2; extern lean_object* l_Lean_Parser_Term_if___elambda__1___closed__1; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__3___boxed(lean_object*, lean_object*); -extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__1; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__6; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__3; lean_object* l_List_join___main___rarg(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__16; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__10(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; extern lean_object* l_Lean_Elab_Term_termElabAttribute; -lean_object* l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__3; -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___spec__2(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__1___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__9; +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_mkAppStx___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__4; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__29; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__3(lean_object*, lean_object*); lean_object* l_Lean_KVMap_setName(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__25; lean_object* lean_local_ctx_mk_local_decl(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__27; +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_appPrec; -lean_object* l_Lean_Array_hasQuote(lean_object*); extern lean_object* l_Option_HasRepr___rarg___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__43; +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___boxed(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__5; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__32; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__10; -extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__28; +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__7(lean_object*); extern lean_object* l_Lean_Syntax_inhabited; -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__6; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__37; +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__2; extern lean_object* l_Lean_mkAppStx___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__44; extern lean_object* l_Lean_Parser_Level_paren___elambda__1___closed__3; lean_object* l_Lean_Parser_Error_toString(lean_object*); extern lean_object* l_Lean_Expr_listLitAux___main___closed__6; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__8; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__28; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__7; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__33; uint8_t l_Lean_Elab_Term_Quotation_isAntiquotSplicePat(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__10; lean_object* l_Lean_Elab_Term_getLCtx(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__17; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__42; lean_object* l_Lean_Syntax_setArg(lean_object*, lean_object*, lean_object*); -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__1(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__53; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__2; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__13(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__20; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__6(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_if___elambda__1___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__33; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___spec__1(lean_object*, lean_object*); +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__12(lean_object*, lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__1; lean_object* l_ReaderT_pure___at_Lean_Elab_Term_Quotation_HeadInfo_Inhabited___spec__1___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5; extern lean_object* l_Lean_Parser_Term_let___elambda__1___closed__1; lean_object* l_Lean_Syntax_getArgs(lean_object*); extern lean_object* l_Bool_HasRepr___closed__2; lean_object* l_Lean_Syntax_getKind(lean_object*); extern lean_object* l_Lean_Parser_Term_match__syntax___elambda__1___closed__2; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_paren___elambda__1___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__20; -lean_object* l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3(lean_object*); +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___spec__1(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26; lean_object* lean_panic_fn(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__5; lean_object* l_ReaderT_pure___at_Lean_Elab_Term_Quotation_HeadInfo_Inhabited___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__29; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_List_hasQuote___rarg(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_boolToExpr___lambda__1___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__16; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__10; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__32; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__14; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__12; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__6___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_oldParseExpr___closed__1; lean_object* l_Lean_LocalContext_mkLambda(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__25; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__2; extern lean_object* l_Lean_mkHole___closed__1; extern lean_object* l_List_foldlM___main___at_Lean_parseSearchPath___spec__8___closed__3; +lean_object* l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12; +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__1; lean_object* l_Lean_Elab_Term_adaptExpander(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__10(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_isAntiquot___boxed(lean_object*); lean_object* l_Lean_mkStxStrLit(lean_object*, lean_object*); uint8_t l_Lean_Elab_Term_Quotation_isAntiquotSplice(lean_object*); -lean_object* l_Lean_Nat_HasQuote(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__1; lean_object* lean_parse_expr(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__37; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__50; +lean_object* l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices(lean_object*); extern lean_object* l_Lean_Parser_Term_letIdDecl___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__7; extern lean_object* l___private_Init_Lean_Meta_LevelDefEq_10__processPostponedStep___closed__1; lean_object* l_Lean_mkCAppStx(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__54; extern lean_object* l_Lean_mkAppStx___closed__9; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___boxed(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__42; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__7; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__53; -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__2; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__3(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3; +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__6(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_elabStxQuot___closed__1; extern lean_object* l_Lean_Unhygienic_MonadQuotation___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6; lean_object* lean_get_namespace(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__12; uint8_t l_Lean_Syntax_isNone(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__24; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__1; extern lean_object* l_Lean_TraceState_Inhabited___closed__1; +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__5; extern lean_object* l_Lean_Parser_Syntax_atom___elambda__1___closed__1; -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__1___boxed(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__15; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__11(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_mkTermIdFrom(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__10; extern lean_object* l_Lean_Parser_Term_letIdDecl___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__4; -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__9(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main(lean_object*, lean_object*, lean_object*); +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main___spec__1(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__32; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__3___boxed(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__1; lean_object* l_Array_toList___rarg(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55; +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__3; lean_object* lean_array_pop(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__6; -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__30; +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_elabMatchSyntax(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__16; lean_object* l_Lean_Elab_Term_resolveGlobalName(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13; +lean_object* l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main(lean_object*); extern lean_object* l_Lean_Elab_Term_mkExplicitBinder___closed__4; -extern lean_object* l_Lean_Name_toExprAux___main___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__4; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__38; extern lean_object* l_Lean_mkHole___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main___boxed(lean_object*); extern lean_object* l_Lean_Parser_Term_stxQuot___elambda__1___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1(lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_Expr_arrayLit_x3f___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__46; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__34; lean_object* l___regBuiltin_Lean_Elab_Term_Quotation_elabStxQuot(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__7; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__5(lean_object*, lean_object*, lean_object*); -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__1; -lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__2(lean_object*, lean_object*, lean_object*); -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main___spec__1(lean_object*); -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__7; -lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__1(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__15; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__7; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23; +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__2; +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_mkStxLit(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__24; -lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13; lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15; extern lean_object* l_Lean_MetavarContext_Inhabited___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__5; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__20; extern lean_object* l_Lean_mkOptionalNode___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__21; +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__2; extern lean_object* l_Lean_Unhygienic_run___rarg___closed__1; +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__2(lean_object*); lean_object* l_Lean_mkNatLit(lean_object*); lean_object* l_Lean_mkStrLit(lean_object*); +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5___closed__1; +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__9___boxed(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Meta_run___rarg___closed__1; lean_object* l_Lean_mkCTermIdFrom(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__43; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__1; extern lean_object* l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__7(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__31; lean_object* l_Array_anyRangeMAux___main___at_Lean_Elab_Term_Quotation_isAntiquotSplicePat___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Meta_DiscrTree_Trie_format___main___rarg___closed__1; -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__32; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__10; +lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_List_toArrayAux___main___rarg(lean_object*, lean_object*); -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__14; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__30; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_System_FilePath_dirName___closed__1; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__10(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Prod_hasQuote___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__2; +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices(lean_object*); extern lean_object* l_Lean_arrayToExpr___rarg___closed__2; -lean_object* l_Lean_Syntax_HasQuote; lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__1; +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__4(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__12; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__13; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__9; -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__4; -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__2; -lean_object* l_Lean_Prod_hasQuote(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20; +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Message_toString(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_antiquotKind_x3f(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__2; +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__4(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__17; extern lean_object* l_Lean_mkAppStx___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__33; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__1; -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___spec__1(lean_object*); extern lean_object* l_List_zip___rarg___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26; -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6; lean_object* l_Lean_mkConst(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__14; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__9; -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__37; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__10(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; extern lean_object* l_Lean_Parser_Term_and___elambda__1___closed__1; lean_object* l_Lean_Elab_Term_Quotation_getAntiquotTerm___boxed(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__44; +extern lean_object* l_Lean_Substring_HasQuote___closed__3; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__3; uint8_t l_Lean_Elab_Term_Quotation_isEscapedAntiquot(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__1; extern lean_object* l_Lean_mkAppStx___closed__1; uint8_t l_Lean_Elab_Term_Quotation_HeadInfo_generalizes(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__8; lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand(lean_object*, lean_object*, lean_object*); +lean_object* l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_List_zipWith___main___rarg(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Option_hasQuote___rarg(lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__11; -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2(lean_object*, lean_object*, lean_object*); lean_object* lean_expand_match_syntax(lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__2; -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__2; -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__6; -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__3; -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg___closed__1; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__2; +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__1; +lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__3; extern lean_object* l_Lean_NameGenerator_Inhabited___closed__3; +lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__5; lean_object* l_Lean_Elab_Term_Quotation_unescapeAntiquot(lean_object*); -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__5; -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__2; lean_object* l_Lean_Elab_Term_Quotation_HeadInfo_generalizes___boxed(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__4; +extern lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__3; uint8_t lean_string_dec_eq(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__19; +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___boxed(lean_object*); uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__26; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__27; lean_object* l_monadInhabited___rarg(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__16; lean_object* l_Lean_Elab_Term_Quotation_elabMatchSyntax___closed__1; uint8_t l_Lean_Syntax_isIdent(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22; +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__4; extern lean_object* l_Lean_Parser_mkAntiquot___closed__1; -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__27; -lean_object* _init_l_Lean_Syntax_HasQuote() { -_start: -{ -lean_object* x_1; -x_1 = l_Nat_HasOfNat___closed__1; -return x_1; -} -} -lean_object* l_Lean_String_HasQuote(lean_object* x_1) { -_start: -{ -lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; -x_2 = lean_box(0); -x_3 = l_Lean_mkStxStrLit(x_1, x_2); -x_4 = l_Lean_mkOptionalNode___closed__2; -x_5 = lean_array_push(x_4, x_3); -x_6 = l_Lean_Parser_Term_str___elambda__1___closed__2; -x_7 = lean_alloc_ctor(1, 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_Nat_HasQuote(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; -x_2 = l_Nat_repr(x_1); -x_3 = lean_box(0); -x_4 = l_Lean_numLitKind; -x_5 = l_Lean_mkStxLit(x_4, x_2, x_3); -x_6 = l_Lean_mkOptionalNode___closed__2; -x_7 = lean_array_push(x_6, x_5); -x_8 = l_Lean_Parser_Term_num___elambda__1___closed__1; -x_9 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_9, 0, x_8); -lean_ctor_set(x_9, 1, x_7); -return x_9; -} -} -lean_object* _init_l_Lean_Substring_HasQuote___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("toSubstring"); -return x_1; -} -} -lean_object* _init_l_Lean_Substring_HasQuote___closed__2() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Literal_type___closed__5; -x_2 = l_Lean_Substring_HasQuote___closed__1; -x_3 = lean_name_mk_string(x_1, x_2); -return x_3; -} -} -lean_object* l_Lean_Substring_HasQuote(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; -x_2 = lean_box(0); -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_string_utf8_extract(x_3, x_4, x_5); -x_7 = l_Lean_mkStxStrLit(x_6, x_2); -x_8 = l_Lean_mkOptionalNode___closed__2; -x_9 = lean_array_push(x_8, x_7); -x_10 = l_Lean_Parser_Term_str___elambda__1___closed__2; -x_11 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_11, 0, x_10); -lean_ctor_set(x_11, 1, x_9); -x_12 = lean_array_push(x_8, x_11); -x_13 = l_Lean_Substring_HasQuote___closed__2; -x_14 = l_Lean_mkCAppStx(x_13, x_12); -return x_14; -} -} -lean_object* l_Lean_Substring_HasQuote___boxed(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = l_Lean_Substring_HasQuote(x_1); -lean_dec(x_1); -return x_2; -} -} -lean_object* l___private_Init_Lean_Elab_Quotation_1__quoteName___main(lean_object* x_1) { -_start: -{ -switch (lean_obj_tag(x_1)) { -case 0: -{ -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; -x_2 = l_Lean_mkAppStx___closed__1; -x_3 = lean_name_mk_string(x_1, x_2); -x_4 = l_Lean_Name_toExprAux___main___closed__1; -x_5 = lean_name_mk_string(x_3, x_4); -x_6 = l_Lean_Name_toExprAux___main___closed__2; -x_7 = lean_name_mk_string(x_5, x_6); -x_8 = lean_box(0); -x_9 = l_Lean_mkCTermIdFrom(x_8, x_7); -return x_9; -} -case 1: -{ -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; -x_10 = lean_ctor_get(x_1, 0); -lean_inc(x_10); -x_11 = lean_ctor_get(x_1, 1); -lean_inc(x_11); -lean_dec(x_1); -x_12 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_10); -x_13 = lean_box(0); -x_14 = l_Lean_mkStxStrLit(x_11, x_13); -x_15 = l_Lean_mkOptionalNode___closed__2; -x_16 = lean_array_push(x_15, x_14); -x_17 = l_Lean_Parser_Term_str___elambda__1___closed__2; -x_18 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_18, 0, x_17); -lean_ctor_set(x_18, 1, x_16); -x_19 = l_Lean_mkAppStx___closed__9; -x_20 = lean_array_push(x_19, x_12); -x_21 = lean_array_push(x_20, x_18); -x_22 = l_Lean_Name_toExprAux___main___closed__4; -x_23 = l_Lean_mkCAppStx(x_22, x_21); -return x_23; -} -default: -{ -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; -x_24 = lean_ctor_get(x_1, 0); -lean_inc(x_24); -x_25 = lean_ctor_get(x_1, 1); -lean_inc(x_25); -lean_dec(x_1); -x_26 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_24); -x_27 = l_Nat_repr(x_25); -x_28 = lean_box(0); -x_29 = l_Lean_numLitKind; -x_30 = l_Lean_mkStxLit(x_29, x_27, x_28); -x_31 = l_Lean_mkOptionalNode___closed__2; -x_32 = lean_array_push(x_31, x_30); -x_33 = l_Lean_Parser_Term_num___elambda__1___closed__1; -x_34 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_34, 0, x_33); -lean_ctor_set(x_34, 1, x_32); -x_35 = l_Lean_mkAppStx___closed__9; -x_36 = lean_array_push(x_35, x_26); -x_37 = lean_array_push(x_36, x_34); -x_38 = l_Lean_Name_toExprAux___main___closed__7; -x_39 = l_Lean_mkCAppStx(x_38, x_37); -return x_39; -} -} -} -} -lean_object* l___private_Init_Lean_Elab_Quotation_1__quoteName(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_1); -return x_2; -} -} -lean_object* _init_l_Lean_Name_hasQuote___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_1__quoteName), 1, 0); -return x_1; -} -} -lean_object* _init_l_Lean_Name_hasQuote() { -_start: -{ -lean_object* x_1; -x_1 = l_Lean_Name_hasQuote___closed__1; -return x_1; -} -} -lean_object* l_Lean_Prod_hasQuote___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; -x_4 = lean_ctor_get(x_3, 0); -lean_inc(x_4); -x_5 = lean_ctor_get(x_3, 1); -lean_inc(x_5); -lean_dec(x_3); -x_6 = lean_apply_1(x_1, x_4); -x_7 = lean_apply_1(x_2, x_5); -x_8 = l_Lean_mkAppStx___closed__9; -x_9 = lean_array_push(x_8, x_6); -x_10 = lean_array_push(x_9, x_7); -x_11 = l___private_Init_Lean_Elab_Term_15__mkPairsAux___main___closed__4; -x_12 = l_Lean_mkCAppStx(x_11, x_10); -return x_12; -} -} -lean_object* l_Lean_Prod_hasQuote(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; -x_3 = lean_alloc_closure((void*)(l_Lean_Prod_hasQuote___rarg), 3, 0); -return x_3; -} -} -lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg___closed__1() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = lean_box(0); -x_2 = l_Lean_Expr_listLitAux___main___closed__4; -x_3 = l_Lean_mkCTermIdFrom(x_1, x_2); -return x_3; -} -} -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg(lean_object* x_1, lean_object* x_2) { -_start: -{ -if (lean_obj_tag(x_2) == 0) -{ -lean_object* x_3; -lean_dec(x_1); -x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg___closed__1; -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_11; lean_object* x_12; -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); -lean_inc(x_1); -x_6 = lean_apply_1(x_1, x_4); -x_7 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg(x_1, x_5); -x_8 = l_Lean_mkAppStx___closed__9; -x_9 = lean_array_push(x_8, x_6); -x_10 = lean_array_push(x_9, x_7); -x_11 = l_Lean_Expr_listLitAux___main___closed__6; -x_12 = l_Lean_mkCAppStx(x_11, x_10); -return x_12; -} -} -} -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg), 2, 0); -return x_2; -} -} -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___rarg(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; -x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg(x_1, x_2); -return x_3; -} -} -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_2__quoteList___rarg), 2, 0); -return x_2; -} -} -lean_object* l_Lean_List_hasQuote___rarg(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_2__quoteList___rarg), 2, 1); -lean_closure_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* l_Lean_List_hasQuote(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l_Lean_List_hasQuote___rarg), 1, 0); -return x_2; -} -} -lean_object* l_Lean_Array_hasQuote___rarg(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; -x_3 = l_Array_toList___rarg(x_2); -x_4 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg(x_1, x_3); -x_5 = l_Lean_mkOptionalNode___closed__2; -x_6 = lean_array_push(x_5, x_4); -x_7 = l_Lean_Expr_arrayLit_x3f___closed__2; -x_8 = l_Lean_mkCAppStx(x_7, x_6); -return x_8; -} -} -lean_object* l_Lean_Array_hasQuote(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l_Lean_Array_hasQuote___rarg___boxed), 2, 0); -return x_2; -} -} -lean_object* l_Lean_Array_hasQuote___rarg___boxed(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; -x_3 = l_Lean_Array_hasQuote___rarg(x_1, x_2); -lean_dec(x_2); -return x_3; -} -} -lean_object* _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("Option"); -return x_1; -} -} -lean_object* _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__2() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__1; -x_3 = lean_name_mk_string(x_1, x_2); -return x_3; -} -} -lean_object* _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__3() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__2; -x_2 = l_Option_HasRepr___rarg___closed__1; -x_3 = lean_name_mk_string(x_1, x_2); -return x_3; -} -} -lean_object* _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__4() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__3; -x_3 = l_Lean_mkTermIdFrom(x_1, x_2); -return x_3; -} -} -lean_object* _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("some"); -return x_1; -} -} -lean_object* _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__2; -x_2 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5; -x_3 = lean_name_mk_string(x_1, x_2); -return x_3; -} -} -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg(lean_object* x_1, lean_object* x_2) { -_start: -{ -if (lean_obj_tag(x_2) == 0) -{ -lean_object* x_3; -lean_dec(x_1); -x_3 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__4; -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; -x_4 = lean_ctor_get(x_2, 0); -lean_inc(x_4); -lean_dec(x_2); -x_5 = lean_apply_1(x_1, x_4); -x_6 = l_Lean_mkOptionalNode___closed__2; -x_7 = lean_array_push(x_6, x_5); -x_8 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6; -x_9 = l_Lean_mkCAppStx(x_8, x_7); -return x_9; -} -} -} -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg), 2, 0); -return x_2; -} -} -lean_object* l_Lean_Option_hasQuote___rarg(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg), 2, 1); -lean_closure_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* l_Lean_Option_hasQuote(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l_Lean_Option_hasQuote___rarg), 1, 0); -return x_2; -} -} uint8_t l_Lean_Elab_Term_Quotation_isAntiquot(lean_object* x_1) { _start: { @@ -1397,7 +935,7 @@ x_3 = lean_box(x_2); return x_3; } } -lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__1(lean_object* x_1, lean_object* x_2) { +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__1(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; uint8_t x_4; @@ -1416,7 +954,7 @@ x_5 = lean_array_fget(x_2, x_1); x_6 = lean_unsigned_to_nat(0u); x_7 = lean_array_fset(x_2, x_1, x_6); x_8 = x_5; -x_9 = l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main(x_8); +x_9 = l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main(x_8); x_10 = lean_unsigned_to_nat(1u); x_11 = lean_nat_add(x_1, x_10); x_12 = x_9; @@ -1428,7 +966,7 @@ goto _start; } } } -lean_object* l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; uint8_t x_5; @@ -1516,7 +1054,7 @@ return x_23; } } } -lean_object* l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main(lean_object* x_1) { +lean_object* l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 1) @@ -1560,13 +1098,13 @@ lean_object* x_17; lean_object* x_18; lean_dec(x_4); lean_dec(x_2); x_17 = lean_unsigned_to_nat(0u); -x_18 = l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__2(x_12, x_3, x_17); +x_18 = l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__2(x_12, x_3, x_17); if (lean_obj_tag(x_18) == 0) { lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; x_19 = lean_name_mk_string(x_12, x_14); x_20 = x_3; -x_21 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__1(x_17, x_20); +x_21 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__1(x_17, x_20); x_22 = x_21; x_23 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_23, 0, x_19); @@ -1606,7 +1144,7 @@ lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_obj lean_dec(x_5); x_6 = x_3; x_7 = lean_unsigned_to_nat(0u); -x_8 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__1(x_7, x_6); +x_8 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__1(x_7, x_6); x_9 = x_8; if (lean_is_scalar(x_4)) { x_10 = lean_alloc_ctor(1, 2, 0); @@ -1624,25 +1162,25 @@ return x_1; } } } -lean_object* l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main___spec__2(x_1, x_2, x_3); +x_4 = l_Array_findMAux___main___at___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main___spec__2(x_1, x_2, x_3); lean_dec(x_2); lean_dec(x_1); return x_4; } } -lean_object* l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices(lean_object* x_1) { +lean_object* l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main(x_1); +x_2 = l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main(x_1); return x_2; } } -lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__1() { +lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__1() { _start: { lean_object* x_1; @@ -1650,22 +1188,22 @@ x_1 = lean_mk_string("Array.push"); return x_1; } } -lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__2() { +lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__1; +x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__1; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__3() { +lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__1; +x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__2; +x_3 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__2; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -1673,7 +1211,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__4() { +lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__4() { _start: { lean_object* x_1; @@ -1681,7 +1219,7 @@ x_1 = lean_mk_string("push"); return x_1; } } -lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__5() { +lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__5() { _start: { lean_object* x_1; @@ -1689,22 +1227,22 @@ x_1 = lean_mk_string("Array.append"); return x_1; } } -lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__6() { +lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__6() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__5; +x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__5; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__7() { +lean_object* _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__5; +x_1 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__5; x_2 = lean_unsigned_to_nat(0u); -x_3 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__6; +x_3 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__6; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -1712,7 +1250,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, 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* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, 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) { _start: { lean_object* x_17; uint8_t x_18; @@ -1796,7 +1334,7 @@ lean_inc(x_9); x_74 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_74, 0, x_73); lean_ctor_set(x_74, 1, x_9); -x_75 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__7; +x_75 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__7; lean_inc(x_6); x_76 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_76, 0, x_6); @@ -1837,7 +1375,7 @@ block_56: lean_object* x_24; lean_dec(x_23); lean_inc(x_15); -x_24 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main(x_20, x_15, x_16); +x_24 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main(x_20, x_15, x_16); if (lean_obj_tag(x_24) == 0) { lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; @@ -1861,7 +1399,7 @@ lean_dec(x_30); x_33 = l_Lean_mkAppStx___closed__7; lean_inc(x_3); x_34 = lean_name_mk_string(x_3, x_33); -x_35 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__4; +x_35 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__4; lean_inc(x_7); x_36 = lean_name_mk_string(x_7, x_35); lean_inc(x_36); @@ -1874,7 +1412,7 @@ lean_inc(x_9); x_39 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_39, 0, x_38); lean_ctor_set(x_39, 1, x_9); -x_40 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__3; +x_40 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__3; lean_inc(x_6); x_41 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_41, 0, x_6); @@ -1945,13 +1483,23 @@ return x_55; } } } -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__3(lean_object* x_1) { +lean_object* _init_l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Expr_listLitAux___main___closed__4; +x_3 = l_Lean_mkCTermIdFrom(x_1, x_2); +return x_3; +} +} +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) { lean_object* x_2; -x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg___closed__1; +x_2 = l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3___closed__1; return x_2; } else @@ -1966,11 +1514,11 @@ x_5 = lean_box(0); x_6 = l_Lean_mkStxStrLit(x_3, x_5); x_7 = l_Lean_mkOptionalNode___closed__2; x_8 = lean_array_push(x_7, x_6); -x_9 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_9 = l_Lean_String_HasQuote___closed__2; x_10 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_10, 0, x_9); lean_ctor_set(x_10, 1, x_8); -x_11 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__3(x_4); +x_11 = l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3(x_4); x_12 = l_Lean_mkAppStx___closed__9; x_13 = lean_array_push(x_12, x_10); x_14 = lean_array_push(x_13, x_11); @@ -1980,13 +1528,13 @@ return x_16; } } } -lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__2(lean_object* x_1) { +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__2(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) { lean_object* x_2; -x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg___closed__1; +x_2 = l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3___closed__1; return x_2; } else @@ -1997,14 +1545,14 @@ lean_inc(x_3); x_4 = lean_ctor_get(x_1, 1); lean_inc(x_4); lean_dec(x_1); -x_5 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__2(x_4); +x_5 = l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__2(x_4); x_6 = lean_ctor_get(x_3, 0); lean_inc(x_6); x_7 = lean_ctor_get(x_3, 1); lean_inc(x_7); lean_dec(x_3); -x_8 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_6); -x_9 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__3(x_7); +x_8 = l___private_Init_Lean_Syntax_7__quoteName___main(x_6); +x_9 = l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3(x_7); x_10 = l_Lean_mkAppStx___closed__9; x_11 = lean_array_push(x_10, x_8); x_12 = lean_array_push(x_11, x_9); @@ -2018,7 +1566,7 @@ return x_18; } } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1() { _start: { lean_object* x_1; @@ -2027,7 +1575,7 @@ lean_closure_set(x_1, 0, lean_box(0)); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__2() { _start: { lean_object* x_1; @@ -2035,22 +1583,22 @@ x_1 = lean_mk_string("Array.empty"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__3() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__2; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__2; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__4() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__4() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__2; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__2; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__3; +x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__3; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2058,7 +1606,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__5() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__5() { _start: { lean_object* x_1; @@ -2066,41 +1614,41 @@ x_1 = lean_mk_string("empty"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_arrayToExpr___rarg___closed__2; -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__5; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__5; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__7() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6; 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___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__8() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__7; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__7; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__9() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__9() { _start: { lean_object* x_1; @@ -2108,22 +1656,22 @@ x_1 = lean_mk_string("Syntax.node"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__10() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__10() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__9; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__9; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__9; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__9; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__10; +x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__10; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2131,7 +1679,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2141,17 +1689,17 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12; x_2 = l_Lean_Meta_DiscrTree_Trie_format___main___rarg___closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__14() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__14() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2161,31 +1709,31 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__15() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__15() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__14; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__14; 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___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__15; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__15; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__17() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__17() { _start: { lean_object* x_1; @@ -2193,27 +1741,27 @@ x_1 = lean_mk_string("unexpected antiquotation splice"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__18() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__18() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__17; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__17; x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__19() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__19() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__18; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__18; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__20() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__20() { _start: { lean_object* x_1; @@ -2221,22 +1769,22 @@ x_1 = lean_mk_string("Syntax.atom"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__21() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__21() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__20; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__20; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__20; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__20; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__21; +x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__21; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2244,17 +1792,17 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12; x_2 = l_Lean_Parser_Syntax_atom___elambda__1___closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__24() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__24() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2264,31 +1812,31 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__25() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__25() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__24; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__24; 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___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__25; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__25; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__27() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__27() { _start: { lean_object* x_1; lean_object* x_2; @@ -2297,13 +1845,13 @@ x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Option_HasRepr___rarg___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__27; +x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__27; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2311,7 +1859,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2321,31 +1869,31 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__30() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__30() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__3; +x_2 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__3; 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___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__30; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__30; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__32() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__32() { _start: { lean_object* x_1; @@ -2353,22 +1901,22 @@ x_1 = lean_mk_string("Syntax.ident"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__33() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__33() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__32; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__32; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__34() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__34() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__32; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__32; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__33; +x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__33; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2376,17 +1924,17 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__35() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__35() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12; x_2 = l_Lean_identKind___closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__36() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__36() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2396,31 +1944,41 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__37() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__37() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__36; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__36; 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___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__38() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__38() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__37; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__37; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__39() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__39() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Literal_type___closed__5; +x_2 = l_Lean_Substring_HasQuote___closed__3; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__40() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2432,17 +1990,17 @@ lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_empty___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__39; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__40; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__42() { _start: { lean_object* x_1; @@ -2450,22 +2008,22 @@ x_1 = lean_mk_string("addMacroScope"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__42() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__43() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__42; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__43() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__44() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__42; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__42; +x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__43; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2473,51 +2031,51 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__44() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__42; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__45() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__46() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_mkAppStx___closed__2; -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__42; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__46() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__47() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__45; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__46; 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___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__47() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__48() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__46; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__47; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__48() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__49() { _start: { lean_object* x_1; @@ -2525,22 +2083,22 @@ x_1 = lean_mk_string("mainModule"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__49() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__50() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__48; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__49; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__48; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__49; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__49; +x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__50; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2548,17 +2106,17 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__48; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__49; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__52() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__53() { _start: { lean_object* x_1; @@ -2566,22 +2124,22 @@ x_1 = lean_mk_string("scp"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__53() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__54() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__52; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__53; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__52; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__53; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__53; +x_3 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__54; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -2589,17 +2147,17 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__52; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__53; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -2611,14 +2169,14 @@ lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { switch (lean_obj_tag(x_1)) { case 0: { lean_object* x_4; lean_object* x_5; lean_object* x_6; -x_4 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_4 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_5 = l_unreachable_x21___rarg(x_4); x_6 = lean_apply_2(x_5, x_2, x_3); return x_6; @@ -2659,7 +2217,7 @@ return x_119; else { lean_object* x_120; lean_object* x_121; -x_120 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__19; +x_120 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__19; x_121 = l_Lean_Elab_Term_throwError___rarg(x_1, x_120, x_2, x_3); lean_dec(x_1); return x_121; @@ -2690,11 +2248,11 @@ x_14 = lean_ctor_get(x_12, 1); lean_inc(x_14); lean_dec(x_12); x_15 = lean_box(0); -x_16 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6; +x_16 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6; x_17 = l_Lean_addMacroScope(x_13, x_16, x_10); x_18 = lean_box(0); -x_19 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__4; -x_20 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__8; +x_19 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__4; +x_20 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__8; x_21 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_21, 0, x_15); lean_ctor_set(x_21, 1, x_19); @@ -2717,7 +2275,7 @@ x_31 = l_Lean_arrayToExpr___rarg___closed__2; x_32 = l_Lean_nullKind___closed__2; x_33 = lean_unsigned_to_nat(0u); lean_inc(x_2); -x_34 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1(x_1, x_7, x_30, x_26, x_22, x_15, x_31, x_18, x_18, x_32, x_24, x_29, x_33, x_27, x_2, x_14); +x_34 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1(x_1, x_7, x_30, x_26, x_22, x_15, x_31, x_18, x_18, x_32, x_24, x_29, x_33, x_27, x_2, x_14); lean_dec(x_29); x_35 = !lean_is_exclusive(x_1); if (x_35 == 0) @@ -2748,10 +2306,10 @@ if (x_44 == 0) { lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; x_45 = lean_ctor_get(x_43, 0); -x_46 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13; +x_46 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13; x_47 = l_Lean_addMacroScope(x_45, x_46, x_41); -x_48 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11; -x_49 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16; +x_48 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11; +x_49 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16; x_50 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_50, 0, x_15); lean_ctor_set(x_50, 1, x_48); @@ -2762,7 +2320,7 @@ x_52 = lean_array_push(x_51, x_24); lean_ctor_set(x_1, 1, x_52); lean_ctor_set(x_1, 0, x_26); x_53 = lean_array_push(x_22, x_1); -x_54 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_7); +x_54 = l___private_Init_Lean_Syntax_7__quoteName___main(x_7); x_55 = lean_array_push(x_22, x_54); x_56 = lean_array_push(x_55, x_38); x_57 = lean_alloc_ctor(1, 2, 0); @@ -2784,10 +2342,10 @@ x_62 = lean_ctor_get(x_43, 1); lean_inc(x_62); lean_inc(x_61); lean_dec(x_43); -x_63 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13; +x_63 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13; x_64 = l_Lean_addMacroScope(x_61, x_63, x_41); -x_65 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11; -x_66 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16; +x_65 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11; +x_66 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16; x_67 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_67, 0, x_15); lean_ctor_set(x_67, 1, x_65); @@ -2798,7 +2356,7 @@ x_69 = lean_array_push(x_68, x_24); lean_ctor_set(x_1, 1, x_69); lean_ctor_set(x_1, 0, x_26); x_70 = lean_array_push(x_22, x_1); -x_71 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_7); +x_71 = l___private_Init_Lean_Syntax_7__quoteName___main(x_7); x_72 = lean_array_push(x_22, x_71); x_73 = lean_array_push(x_72, x_38); x_74 = lean_alloc_ctor(1, 2, 0); @@ -2872,10 +2430,10 @@ if (lean_is_exclusive(x_88)) { lean_dec_ref(x_88); x_91 = lean_box(0); } -x_92 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13; +x_92 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13; x_93 = l_Lean_addMacroScope(x_89, x_92, x_86); -x_94 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11; -x_95 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16; +x_94 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11; +x_95 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16; x_96 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_96, 0, x_15); lean_ctor_set(x_96, 1, x_94); @@ -2887,7 +2445,7 @@ x_99 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_99, 0, x_26); lean_ctor_set(x_99, 1, x_98); x_100 = lean_array_push(x_22, x_99); -x_101 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_7); +x_101 = l___private_Init_Lean_Syntax_7__quoteName___main(x_7); x_102 = lean_array_push(x_22, x_101); x_103 = lean_array_push(x_102, x_83); x_104 = lean_alloc_ctor(1, 2, 0); @@ -2960,12 +2518,12 @@ if (x_130 == 0) lean_object* x_131; 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; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; x_131 = lean_ctor_get(x_129, 0); x_132 = lean_box(0); -x_133 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23; +x_133 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23; lean_inc(x_127); lean_inc(x_131); x_134 = l_Lean_addMacroScope(x_131, x_133, x_127); -x_135 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22; -x_136 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26; +x_135 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22; +x_136 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26; x_137 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_137, 0, x_132); lean_ctor_set(x_137, 1, x_135); @@ -2980,10 +2538,10 @@ lean_ctor_set_tag(x_1, 1); lean_ctor_set(x_1, 1, x_141); lean_ctor_set(x_1, 0, x_142); x_143 = lean_array_push(x_138, x_1); -x_144 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_144 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; x_145 = l_Lean_addMacroScope(x_131, x_144, x_127); -x_146 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_147 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_146 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_147 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_148 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_148, 0, x_132); lean_ctor_set(x_148, 1, x_146); @@ -2998,7 +2556,7 @@ x_152 = lean_array_push(x_138, x_151); x_153 = l_Lean_mkStxStrLit(x_124, x_132); x_154 = l_Lean_mkOptionalNode___closed__2; x_155 = lean_array_push(x_154, x_153); -x_156 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_156 = l_Lean_String_HasQuote___closed__2; x_157 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_157, 0, x_156); lean_ctor_set(x_157, 1, x_155); @@ -3024,12 +2582,12 @@ lean_inc(x_165); lean_inc(x_164); lean_dec(x_129); x_166 = lean_box(0); -x_167 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23; +x_167 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23; lean_inc(x_127); lean_inc(x_164); x_168 = l_Lean_addMacroScope(x_164, x_167, x_127); -x_169 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22; -x_170 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26; +x_169 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22; +x_170 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26; x_171 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_171, 0, x_166); lean_ctor_set(x_171, 1, x_169); @@ -3044,10 +2602,10 @@ lean_ctor_set_tag(x_1, 1); lean_ctor_set(x_1, 1, x_175); lean_ctor_set(x_1, 0, x_176); x_177 = lean_array_push(x_172, x_1); -x_178 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_178 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; x_179 = l_Lean_addMacroScope(x_164, x_178, x_127); -x_180 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_181 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_180 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_181 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_182 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_182, 0, x_166); lean_ctor_set(x_182, 1, x_180); @@ -3062,7 +2620,7 @@ x_186 = lean_array_push(x_172, x_185); x_187 = l_Lean_mkStxStrLit(x_124, x_166); x_188 = l_Lean_mkOptionalNode___closed__2; x_189 = lean_array_push(x_188, x_187); -x_190 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_190 = l_Lean_String_HasQuote___closed__2; x_191 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_191, 0, x_190); lean_ctor_set(x_191, 1, x_189); @@ -3109,12 +2667,12 @@ if (lean_is_exclusive(x_203)) { x_206 = lean_box(0); } x_207 = lean_box(0); -x_208 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23; +x_208 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23; lean_inc(x_201); lean_inc(x_204); x_209 = l_Lean_addMacroScope(x_204, x_208, x_201); -x_210 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22; -x_211 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26; +x_210 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22; +x_211 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26; x_212 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_212, 0, x_207); lean_ctor_set(x_212, 1, x_210); @@ -3129,10 +2687,10 @@ x_218 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_218, 0, x_217); lean_ctor_set(x_218, 1, x_216); x_219 = lean_array_push(x_213, x_218); -x_220 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_220 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; x_221 = l_Lean_addMacroScope(x_204, x_220, x_201); -x_222 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_223 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_222 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_223 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_224 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_224, 0, x_207); lean_ctor_set(x_224, 1, x_222); @@ -3147,7 +2705,7 @@ x_228 = lean_array_push(x_213, x_227); x_229 = l_Lean_mkStxStrLit(x_199, x_207); x_230 = l_Lean_mkOptionalNode___closed__2; x_231 = lean_array_push(x_230, x_229); -x_232 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_232 = l_Lean_String_HasQuote___closed__2; x_233 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_233, 0, x_232); lean_ctor_set(x_233, 1, x_231); @@ -3191,7 +2749,7 @@ x_248 = lean_ctor_get(x_246, 1); lean_inc(x_248); lean_dec(x_246); x_249 = l_List_append___rarg(x_247, x_244); -x_250 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_243); +x_250 = l___private_Init_Lean_Syntax_7__quoteName___main(x_243); x_251 = l_Lean_Elab_Term_getCurrMacroScope(x_2, x_248); lean_dec(x_2); x_252 = lean_ctor_get(x_251, 0); @@ -3206,13 +2764,13 @@ if (x_255 == 0) lean_object* x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; 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_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; x_256 = lean_ctor_get(x_254, 0); x_257 = lean_box(0); -x_258 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__35; +x_258 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__35; lean_inc(x_252); lean_inc(x_256); x_259 = l_Lean_addMacroScope(x_256, x_258, x_252); x_260 = lean_box(0); -x_261 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__34; -x_262 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__38; +x_261 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__34; +x_262 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__38; lean_ctor_set(x_1, 3, x_262); lean_ctor_set(x_1, 2, x_259); lean_ctor_set(x_1, 1, x_261); @@ -3226,12 +2784,12 @@ x_268 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_268, 0, x_267); lean_ctor_set(x_268, 1, x_266); x_269 = lean_array_push(x_263, x_268); -x_270 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_270 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; lean_inc(x_252); lean_inc(x_256); x_271 = l_Lean_addMacroScope(x_256, x_270, x_252); -x_272 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_273 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_272 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_273 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_274 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_274, 0, x_257); lean_ctor_set(x_274, 1, x_272); @@ -3243,12 +2801,12 @@ x_277 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_277, 0, x_267); lean_ctor_set(x_277, 1, x_276); x_278 = lean_array_push(x_263, x_277); -x_279 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__44; +x_279 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45; lean_inc(x_252); lean_inc(x_256); x_280 = l_Lean_addMacroScope(x_256, x_279, x_252); -x_281 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__43; -x_282 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__47; +x_281 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__44; +x_282 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__48; x_283 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_283, 0, x_257); lean_ctor_set(x_283, 1, x_281); @@ -3260,11 +2818,11 @@ x_286 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_286, 0, x_267); lean_ctor_set(x_286, 1, x_285); x_287 = lean_array_push(x_263, x_286); -x_288 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51; +x_288 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52; lean_inc(x_252); lean_inc(x_256); x_289 = l_Lean_addMacroScope(x_256, x_288, x_252); -x_290 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50; +x_290 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51; x_291 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_291, 0, x_257); lean_ctor_set(x_291, 1, x_290); @@ -3277,9 +2835,9 @@ lean_ctor_set(x_294, 0, x_267); lean_ctor_set(x_294, 1, x_293); x_295 = lean_array_push(x_263, x_294); x_296 = lean_array_push(x_295, x_250); -x_297 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55; +x_297 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56; x_298 = l_Lean_addMacroScope(x_256, x_297, x_252); -x_299 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54; +x_299 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55; x_300 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_300, 0, x_257); lean_ctor_set(x_300, 1, x_299); @@ -3305,15 +2863,15 @@ x_311 = lean_array_push(x_310, x_265); x_312 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_312, 0, x_305); lean_ctor_set(x_312, 1, x_311); -x_313 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_313 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_314 = lean_array_push(x_313, x_312); -x_315 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_315 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_316 = lean_array_push(x_314, x_315); x_317 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_318 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_318, 0, x_317); lean_ctor_set(x_318, 1, x_316); -x_319 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__2(x_249); +x_319 = l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__2(x_249); x_320 = lean_ctor_get(x_242, 0); lean_inc(x_320); x_321 = lean_ctor_get(x_242, 1); @@ -3328,12 +2886,12 @@ lean_dec(x_320); x_324 = l_Lean_mkStxStrLit(x_323, x_257); x_325 = l_Lean_mkOptionalNode___closed__2; x_326 = lean_array_push(x_325, x_324); -x_327 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_327 = l_Lean_String_HasQuote___closed__2; x_328 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_328, 0, x_327); lean_ctor_set(x_328, 1, x_326); x_329 = lean_array_push(x_325, x_328); -x_330 = l_Lean_Substring_HasQuote___closed__2; +x_330 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__39; x_331 = l_Lean_mkCAppStx(x_330, x_329); x_332 = lean_array_push(x_278, x_331); x_333 = lean_array_push(x_332, x_318); @@ -3357,13 +2915,13 @@ lean_inc(x_339); lean_inc(x_338); lean_dec(x_254); x_340 = lean_box(0); -x_341 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__35; +x_341 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__35; lean_inc(x_252); lean_inc(x_338); x_342 = l_Lean_addMacroScope(x_338, x_341, x_252); x_343 = lean_box(0); -x_344 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__34; -x_345 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__38; +x_344 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__34; +x_345 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__38; lean_ctor_set(x_1, 3, x_345); lean_ctor_set(x_1, 2, x_342); lean_ctor_set(x_1, 1, x_344); @@ -3377,12 +2935,12 @@ x_351 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_351, 0, x_350); lean_ctor_set(x_351, 1, x_349); x_352 = lean_array_push(x_346, x_351); -x_353 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_353 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; lean_inc(x_252); lean_inc(x_338); x_354 = l_Lean_addMacroScope(x_338, x_353, x_252); -x_355 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_356 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_355 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_356 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_357 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_357, 0, x_340); lean_ctor_set(x_357, 1, x_355); @@ -3394,12 +2952,12 @@ x_360 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_360, 0, x_350); lean_ctor_set(x_360, 1, x_359); x_361 = lean_array_push(x_346, x_360); -x_362 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__44; +x_362 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45; lean_inc(x_252); lean_inc(x_338); x_363 = l_Lean_addMacroScope(x_338, x_362, x_252); -x_364 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__43; -x_365 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__47; +x_364 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__44; +x_365 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__48; x_366 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_366, 0, x_340); lean_ctor_set(x_366, 1, x_364); @@ -3411,11 +2969,11 @@ x_369 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_369, 0, x_350); lean_ctor_set(x_369, 1, x_368); x_370 = lean_array_push(x_346, x_369); -x_371 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51; +x_371 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52; lean_inc(x_252); lean_inc(x_338); x_372 = l_Lean_addMacroScope(x_338, x_371, x_252); -x_373 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50; +x_373 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51; x_374 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_374, 0, x_340); lean_ctor_set(x_374, 1, x_373); @@ -3428,9 +2986,9 @@ lean_ctor_set(x_377, 0, x_350); lean_ctor_set(x_377, 1, x_376); x_378 = lean_array_push(x_346, x_377); x_379 = lean_array_push(x_378, x_250); -x_380 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55; +x_380 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56; x_381 = l_Lean_addMacroScope(x_338, x_380, x_252); -x_382 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54; +x_382 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55; x_383 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_383, 0, x_340); lean_ctor_set(x_383, 1, x_382); @@ -3456,15 +3014,15 @@ x_394 = lean_array_push(x_393, x_348); x_395 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_395, 0, x_388); lean_ctor_set(x_395, 1, x_394); -x_396 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_396 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_397 = lean_array_push(x_396, x_395); -x_398 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_398 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_399 = lean_array_push(x_397, x_398); x_400 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_401 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_401, 0, x_400); lean_ctor_set(x_401, 1, x_399); -x_402 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__2(x_249); +x_402 = l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__2(x_249); x_403 = lean_ctor_get(x_242, 0); lean_inc(x_403); x_404 = lean_ctor_get(x_242, 1); @@ -3479,12 +3037,12 @@ lean_dec(x_403); x_407 = l_Lean_mkStxStrLit(x_406, x_340); x_408 = l_Lean_mkOptionalNode___closed__2; x_409 = lean_array_push(x_408, x_407); -x_410 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_410 = l_Lean_String_HasQuote___closed__2; x_411 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_411, 0, x_410); lean_ctor_set(x_411, 1, x_409); x_412 = lean_array_push(x_408, x_411); -x_413 = l_Lean_Substring_HasQuote___closed__2; +x_413 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__39; x_414 = l_Lean_mkCAppStx(x_413, x_412); x_415 = lean_array_push(x_361, x_414); x_416 = lean_array_push(x_415, x_401); @@ -3520,7 +3078,7 @@ x_427 = lean_ctor_get(x_425, 1); lean_inc(x_427); lean_dec(x_425); x_428 = l_List_append___rarg(x_426, x_424); -x_429 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_423); +x_429 = l___private_Init_Lean_Syntax_7__quoteName___main(x_423); x_430 = l_Lean_Elab_Term_getCurrMacroScope(x_2, x_427); lean_dec(x_2); x_431 = lean_ctor_get(x_430, 0); @@ -3542,13 +3100,13 @@ if (lean_is_exclusive(x_433)) { x_436 = lean_box(0); } x_437 = lean_box(0); -x_438 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__35; +x_438 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__35; lean_inc(x_431); lean_inc(x_434); x_439 = l_Lean_addMacroScope(x_434, x_438, x_431); x_440 = lean_box(0); -x_441 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__34; -x_442 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__38; +x_441 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__34; +x_442 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__38; x_443 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_443, 0, x_437); lean_ctor_set(x_443, 1, x_441); @@ -3563,12 +3121,12 @@ x_449 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_449, 0, x_448); lean_ctor_set(x_449, 1, x_447); x_450 = lean_array_push(x_444, x_449); -x_451 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29; +x_451 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29; lean_inc(x_431); lean_inc(x_434); x_452 = l_Lean_addMacroScope(x_434, x_451, x_431); -x_453 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28; -x_454 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31; +x_453 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28; +x_454 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31; x_455 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_455, 0, x_437); lean_ctor_set(x_455, 1, x_453); @@ -3580,12 +3138,12 @@ x_458 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_458, 0, x_448); lean_ctor_set(x_458, 1, x_457); x_459 = lean_array_push(x_444, x_458); -x_460 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__44; +x_460 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45; lean_inc(x_431); lean_inc(x_434); x_461 = l_Lean_addMacroScope(x_434, x_460, x_431); -x_462 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__43; -x_463 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__47; +x_462 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__44; +x_463 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__48; x_464 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_464, 0, x_437); lean_ctor_set(x_464, 1, x_462); @@ -3597,11 +3155,11 @@ x_467 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_467, 0, x_448); lean_ctor_set(x_467, 1, x_466); x_468 = lean_array_push(x_444, x_467); -x_469 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51; +x_469 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52; lean_inc(x_431); lean_inc(x_434); x_470 = l_Lean_addMacroScope(x_434, x_469, x_431); -x_471 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50; +x_471 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51; x_472 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_472, 0, x_437); lean_ctor_set(x_472, 1, x_471); @@ -3614,9 +3172,9 @@ lean_ctor_set(x_475, 0, x_448); lean_ctor_set(x_475, 1, x_474); x_476 = lean_array_push(x_444, x_475); x_477 = lean_array_push(x_476, x_429); -x_478 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55; +x_478 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56; x_479 = l_Lean_addMacroScope(x_434, x_478, x_431); -x_480 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54; +x_480 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55; x_481 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_481, 0, x_437); lean_ctor_set(x_481, 1, x_480); @@ -3642,15 +3200,15 @@ x_492 = lean_array_push(x_491, x_446); x_493 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_493, 0, x_486); lean_ctor_set(x_493, 1, x_492); -x_494 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_494 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_495 = lean_array_push(x_494, x_493); -x_496 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_496 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_497 = lean_array_push(x_495, x_496); x_498 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_499 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_499, 0, x_498); lean_ctor_set(x_499, 1, x_497); -x_500 = l___private_Init_Lean_Elab_Quotation_2__quoteList___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__2(x_428); +x_500 = l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__2(x_428); x_501 = lean_ctor_get(x_422, 0); lean_inc(x_501); x_502 = lean_ctor_get(x_422, 1); @@ -3665,12 +3223,12 @@ lean_dec(x_501); x_505 = l_Lean_mkStxStrLit(x_504, x_437); x_506 = l_Lean_mkOptionalNode___closed__2; x_507 = lean_array_push(x_506, x_505); -x_508 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_508 = l_Lean_String_HasQuote___closed__2; x_509 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_509, 0, x_508); lean_ctor_set(x_509, 1, x_507); x_510 = lean_array_push(x_506, x_509); -x_511 = l_Lean_Substring_HasQuote___closed__2; +x_511 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__39; x_512 = l_Lean_mkCAppStx(x_511, x_510); x_513 = lean_array_push(x_459, x_512); x_514 = lean_array_push(x_513, x_499); @@ -3695,22 +3253,22 @@ return x_519; } } } -lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, 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* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, 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) { _start: { lean_object* x_17; -x_17 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16); +x_17 = l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16); lean_dec(x_12); lean_dec(x_2); lean_dec(x_1); return x_17; } } -lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main(x_1, x_2, x_3); +x_4 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main(x_1, x_2, x_3); return x_4; } } @@ -4074,9 +3632,9 @@ _start: lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; x_4 = lean_unsigned_to_nat(1u); x_5 = l_Lean_Syntax_getArg(x_1, x_4); -x_6 = l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main(x_5); +x_6 = l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main(x_5); lean_inc(x_2); -x_7 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main(x_6, x_2, x_3); +x_7 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main(x_6, x_2, x_3); 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_object* x_13; uint8_t x_14; @@ -4137,11 +3695,11 @@ x_37 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_37, 0, x_27); lean_ctor_set(x_37, 1, x_36); x_38 = lean_array_push(x_23, x_37); -x_39 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55; +x_39 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56; lean_inc(x_11); lean_inc(x_15); x_40 = l_Lean_addMacroScope(x_15, x_39, x_11); -x_41 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54; +x_41 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55; x_42 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_42, 0, x_16); lean_ctor_set(x_42, 1, x_41); @@ -4178,11 +3736,11 @@ x_60 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_60, 0, x_27); lean_ctor_set(x_60, 1, x_59); x_61 = lean_array_push(x_23, x_60); -x_62 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51; +x_62 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52; lean_inc(x_11); lean_inc(x_15); x_63 = l_Lean_addMacroScope(x_15, x_62, x_11); -x_64 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50; +x_64 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51; x_65 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_65, 0, x_16); lean_ctor_set(x_65, 1, x_64); @@ -4233,9 +3791,9 @@ x_91 = lean_array_push(x_90, x_25); x_92 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_92, 0, x_47); lean_ctor_set(x_92, 1, x_91); -x_93 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_93 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_94 = lean_array_push(x_93, x_92); -x_95 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_95 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_96 = lean_array_push(x_94, x_95); x_97 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_98 = lean_alloc_ctor(1, 2, 0); @@ -4322,11 +3880,11 @@ x_138 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_138, 0, x_128); lean_ctor_set(x_138, 1, x_137); x_139 = lean_array_push(x_124, x_138); -x_140 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55; +x_140 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56; lean_inc(x_11); lean_inc(x_115); x_141 = l_Lean_addMacroScope(x_115, x_140, x_11); -x_142 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54; +x_142 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55; x_143 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_143, 0, x_117); lean_ctor_set(x_143, 1, x_142); @@ -4363,11 +3921,11 @@ x_161 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_161, 0, x_128); lean_ctor_set(x_161, 1, x_160); x_162 = lean_array_push(x_124, x_161); -x_163 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51; +x_163 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52; lean_inc(x_11); lean_inc(x_115); x_164 = l_Lean_addMacroScope(x_115, x_163, x_11); -x_165 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50; +x_165 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51; x_166 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_166, 0, x_117); lean_ctor_set(x_166, 1, x_165); @@ -4418,9 +3976,9 @@ x_192 = lean_array_push(x_191, x_126); x_193 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_193, 0, x_148); lean_ctor_set(x_193, 1, x_192); -x_194 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_194 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_195 = lean_array_push(x_194, x_193); -x_196 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_196 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_197 = lean_array_push(x_195, x_196); x_198 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_199 = lean_alloc_ctor(1, 2, 0); @@ -4684,7 +4242,7 @@ x_4 = lean_box(x_3); return x_4; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; @@ -4694,7 +4252,7 @@ lean_ctor_set(x_4, 1, x_3); return x_4; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; @@ -4704,7 +4262,7 @@ lean_ctor_set(x_4, 1, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__1() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -4716,17 +4274,17 @@ lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_empty___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__1; +x_2 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__1; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__3() { _start: { lean_object* x_1; @@ -4734,19 +4292,19 @@ x_1 = lean_mk_string(":="); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__3; +x_2 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__3; x_3 = lean_alloc_ctor(2, 2, 0); lean_ctor_set(x_3, 0, x_1); lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__5() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__5() { _start: { lean_object* x_1; @@ -4754,22 +4312,22 @@ x_1 = lean_mk_string("discr"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__6() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__6() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__5; +x_1 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__5; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__5; +x_1 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__5; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__6; +x_3 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__6; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -4777,17 +4335,17 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__5; +x_2 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__5; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__9() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__9() { _start: { lean_object* x_1; @@ -4795,19 +4353,19 @@ x_1 = lean_mk_string(";"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__9; +x_2 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__9; 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* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; @@ -4829,12 +4387,12 @@ x_13 = lean_array_push(x_12, x_1); x_14 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_15 = lean_array_push(x_13, x_14); x_16 = lean_array_push(x_15, x_14); -x_17 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_17 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_18 = lean_array_push(x_16, x_17); -x_19 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_19 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_20 = l_Lean_addMacroScope(x_10, x_19, x_6); x_21 = lean_box(0); -x_22 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_22 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_23 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_23, 0, x_11); lean_ctor_set(x_23, 1, x_22); @@ -4851,9 +4409,9 @@ x_29 = l_Lean_Parser_Term_letIdDecl___closed__2; x_30 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_30, 0, x_29); lean_ctor_set(x_30, 1, x_28); -x_31 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_31 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_32 = lean_array_push(x_31, x_30); -x_33 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_33 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_34 = lean_array_push(x_32, x_33); x_35 = lean_array_push(x_34, x_2); x_36 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -4877,12 +4435,12 @@ x_42 = lean_array_push(x_41, x_1); x_43 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_44 = lean_array_push(x_42, x_43); x_45 = lean_array_push(x_44, x_43); -x_46 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_46 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_47 = lean_array_push(x_45, x_46); -x_48 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_48 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_49 = l_Lean_addMacroScope(x_38, x_48, x_6); x_50 = lean_box(0); -x_51 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_51 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_52 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_52, 0, x_40); lean_ctor_set(x_52, 1, x_51); @@ -4899,9 +4457,9 @@ x_58 = l_Lean_Parser_Term_letIdDecl___closed__2; x_59 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_59, 0, x_58); lean_ctor_set(x_59, 1, x_57); -x_60 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_60 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_61 = lean_array_push(x_60, x_59); -x_62 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_62 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_63 = lean_array_push(x_61, x_62); x_64 = lean_array_push(x_63, x_2); x_65 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -4915,7 +4473,7 @@ return x_67; } } } -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__1(lean_object* x_1) { +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__1(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) @@ -4935,7 +4493,7 @@ return x_5; } } } -lean_object* _init_l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__1() { +lean_object* _init_l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__1() { _start: { lean_object* x_1; lean_object* x_2; @@ -4944,17 +4502,17 @@ x_2 = l_Lean_mkAtom(x_1); return x_2; } } -lean_object* _init_l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__2() { +lean_object* _init_l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_declareBuiltinParser___closed__8; -x_2 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__1; +x_2 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__1; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; uint8_t x_5; @@ -4974,7 +4532,7 @@ x_6 = lean_array_fget(x_3, x_2); x_7 = lean_unsigned_to_nat(0u); x_8 = lean_array_fset(x_3, x_2, x_7); x_9 = x_6; -x_10 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__2; +x_10 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__2; x_11 = lean_array_push(x_10, x_9); x_12 = l_Lean_Elab_Term_mkExplicitBinder___closed__4; x_13 = lean_array_push(x_11, x_12); @@ -4993,7 +4551,7 @@ goto _start; } } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__1() { _start: { lean_object* x_1; @@ -5001,50 +4559,51 @@ x_1 = lean_mk_string("match_syntax: unexpected pattern kind "); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__1; x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__3() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__2; +x_1 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__2; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; x_5 = lean_box(0); -x_6 = lean_unsigned_to_nat(0u); +x_6 = 0; +x_7 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_7 = l_Lean_Syntax_formatStxAux___main(x_5, x_6, x_1); -x_8 = l_Lean_Options_empty; -x_9 = l_Lean_Format_pretty(x_7, x_8); -x_10 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_10, 0, x_9); -x_11 = lean_alloc_ctor(0, 1, 0); +x_8 = l_Lean_Syntax_formatStxAux___main(x_5, x_6, x_7, x_1); +x_9 = l_Lean_Options_empty; +x_10 = l_Lean_Format_pretty(x_8, x_9); +x_11 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_11, 0, x_10); -x_12 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__3; -x_13 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_13, 0, x_12); -lean_ctor_set(x_13, 1, x_11); -x_14 = l_Lean_Elab_Term_throwError___rarg(x_1, x_13, x_3, x_4); +x_12 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_12, 0, x_11); +x_13 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__3; +x_14 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_12); +x_15 = l_Lean_Elab_Term_throwError___rarg(x_1, x_14, x_3, x_4); lean_dec(x_1); -return x_14; +return x_15; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__1() { _start: { lean_object* x_1; @@ -5052,22 +4611,22 @@ x_1 = lean_mk_string("Syntax.getArgs"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__1; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__2; +x_3 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__2; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -5075,7 +4634,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__4() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__4() { _start: { lean_object* x_1; @@ -5083,17 +4642,17 @@ x_1 = lean_mk_string("getArgs"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12; -x_2 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__4; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12; +x_2 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__4; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__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* x_7) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__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* x_7) { _start: { lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; @@ -5121,17 +4680,17 @@ x_20 = lean_array_push(x_19, x_2); x_21 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_22 = lean_array_push(x_20, x_21); x_23 = lean_array_push(x_22, x_21); -x_24 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_24 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_25 = lean_array_push(x_23, x_24); x_26 = l_Lean_mkAppStx___closed__7; x_27 = lean_name_mk_string(x_1, x_26); -x_28 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5; +x_28 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5; lean_inc(x_9); lean_inc(x_13); x_29 = l_Lean_addMacroScope(x_13, x_28, x_9); x_30 = l_Lean_Parser_Syntax_paren___elambda__1___closed__1; x_31 = lean_name_mk_string(x_3, x_30); -x_32 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__4; +x_32 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__4; x_33 = lean_name_mk_string(x_31, x_32); x_34 = lean_box(0); x_35 = lean_alloc_ctor(0, 2, 0); @@ -5140,7 +4699,7 @@ lean_ctor_set(x_35, 1, x_34); x_36 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_36, 0, x_35); lean_ctor_set(x_36, 1, x_34); -x_37 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3; +x_37 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3; x_38 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_38, 0, x_16); lean_ctor_set(x_38, 1, x_37); @@ -5153,9 +4712,9 @@ x_41 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_41, 0, x_4); lean_ctor_set(x_41, 1, x_40); x_42 = lean_array_push(x_19, x_41); -x_43 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_43 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_44 = l_Lean_addMacroScope(x_13, x_43, x_9); -x_45 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_45 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_46 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_46, 0, x_16); lean_ctor_set(x_46, 1, x_45); @@ -5179,9 +4738,9 @@ x_55 = lean_array_push(x_25, x_54); x_56 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_56, 0, x_18); lean_ctor_set(x_56, 1, x_55); -x_57 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_57 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_58 = lean_array_push(x_57, x_56); -x_59 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_59 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_60 = lean_array_push(x_58, x_59); x_61 = lean_array_push(x_60, x_5); x_62 = lean_alloc_ctor(1, 2, 0); @@ -5210,17 +4769,17 @@ x_71 = lean_array_push(x_70, x_2); x_72 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_73 = lean_array_push(x_71, x_72); x_74 = lean_array_push(x_73, x_72); -x_75 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_75 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_76 = lean_array_push(x_74, x_75); x_77 = l_Lean_mkAppStx___closed__7; x_78 = lean_name_mk_string(x_1, x_77); -x_79 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5; +x_79 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5; lean_inc(x_9); lean_inc(x_63); x_80 = l_Lean_addMacroScope(x_63, x_79, x_9); x_81 = l_Lean_Parser_Syntax_paren___elambda__1___closed__1; x_82 = lean_name_mk_string(x_3, x_81); -x_83 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__4; +x_83 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__4; x_84 = lean_name_mk_string(x_82, x_83); x_85 = lean_box(0); x_86 = lean_alloc_ctor(0, 2, 0); @@ -5229,7 +4788,7 @@ lean_ctor_set(x_86, 1, x_85); x_87 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_87, 0, x_86); lean_ctor_set(x_87, 1, x_85); -x_88 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3; +x_88 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3; x_89 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_89, 0, x_67); lean_ctor_set(x_89, 1, x_88); @@ -5242,9 +4801,9 @@ x_92 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_92, 0, x_4); lean_ctor_set(x_92, 1, x_91); x_93 = lean_array_push(x_70, x_92); -x_94 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_94 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_95 = l_Lean_addMacroScope(x_63, x_94, x_9); -x_96 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_96 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_97 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_97, 0, x_67); lean_ctor_set(x_97, 1, x_96); @@ -5268,9 +4827,9 @@ x_106 = lean_array_push(x_76, x_105); x_107 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_107, 0, x_69); lean_ctor_set(x_107, 1, x_106); -x_108 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_108 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_109 = lean_array_push(x_108, x_107); -x_110 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_110 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_111 = lean_array_push(x_109, x_110); x_112 = lean_array_push(x_111, x_5); x_113 = lean_alloc_ctor(1, 2, 0); @@ -5283,7 +4842,7 @@ return x_114; } } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__1() { _start: { lean_object* x_1; @@ -5291,59 +4850,60 @@ x_1 = lean_mk_string("match_syntax: antiquotation must be variable "); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__1; x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__3() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__2; +x_1 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__2; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; x_5 = lean_box(0); -x_6 = lean_unsigned_to_nat(0u); +x_6 = 0; +x_7 = lean_unsigned_to_nat(0u); lean_inc(x_1); -x_7 = l_Lean_Syntax_formatStxAux___main(x_5, x_6, x_1); -x_8 = l_Lean_Options_empty; -x_9 = l_Lean_Format_pretty(x_7, x_8); -x_10 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_10, 0, x_9); -x_11 = lean_alloc_ctor(0, 1, 0); +x_8 = l_Lean_Syntax_formatStxAux___main(x_5, x_6, x_7, x_1); +x_9 = l_Lean_Options_empty; +x_10 = l_Lean_Format_pretty(x_8, x_9); +x_11 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_11, 0, x_10); -x_12 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__3; -x_13 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_13, 0, x_12); -lean_ctor_set(x_13, 1, x_11); -x_14 = l_Lean_Elab_Term_throwError___rarg(x_1, x_13, x_3, x_4); +x_12 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_12, 0, x_11); +x_13 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__3; +x_14 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_12); +x_15 = l_Lean_Elab_Term_throwError___rarg(x_1, x_14, x_3, x_4); lean_dec(x_1); -return x_14; +return x_15; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__4(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; -x_5 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__19; +x_5 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__19; x_6 = l_Lean_Elab_Term_throwError___rarg(x_1, x_5, x_3, x_4); return x_6; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__5(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; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; @@ -5370,12 +4930,12 @@ x_19 = lean_array_push(x_18, x_2); x_20 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_21 = lean_array_push(x_19, x_20); x_22 = lean_array_push(x_21, x_20); -x_23 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_23 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_24 = lean_array_push(x_22, x_23); -x_25 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_25 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_26 = l_Lean_addMacroScope(x_12, x_25, x_8); x_27 = lean_box(0); -x_28 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_28 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_29 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_29, 0, x_15); lean_ctor_set(x_29, 1, x_28); @@ -5390,9 +4950,9 @@ x_33 = lean_array_push(x_24, x_32); x_34 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_34, 0, x_17); lean_ctor_set(x_34, 1, x_33); -x_35 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_35 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_36 = lean_array_push(x_35, x_34); -x_37 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_37 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_38 = lean_array_push(x_36, x_37); x_39 = lean_array_push(x_38, x_4); x_40 = lean_alloc_ctor(1, 2, 0); @@ -5420,12 +4980,12 @@ x_49 = lean_array_push(x_48, x_2); x_50 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_51 = lean_array_push(x_49, x_50); x_52 = lean_array_push(x_51, x_50); -x_53 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_53 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_54 = lean_array_push(x_52, x_53); -x_55 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_55 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_56 = l_Lean_addMacroScope(x_41, x_55, x_8); x_57 = lean_box(0); -x_58 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_58 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_59 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_59, 0, x_45); lean_ctor_set(x_59, 1, x_58); @@ -5440,9 +5000,9 @@ x_63 = lean_array_push(x_54, x_62); x_64 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_64, 0, x_47); lean_ctor_set(x_64, 1, x_63); -x_65 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_65 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_66 = lean_array_push(x_65, x_64); -x_67 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_67 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_68 = lean_array_push(x_66, x_67); x_69 = lean_array_push(x_68, x_4); x_70 = lean_alloc_ctor(1, 2, 0); @@ -5455,23 +5015,23 @@ return x_71; } } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__1() { _start: { lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__1___boxed), 3, 0); +x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__1___boxed), 3, 0); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__2() { _start: { lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__2___boxed), 3, 0); +x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__2___boxed), 3, 0); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__3() { _start: { lean_object* x_1; @@ -5479,12 +5039,12 @@ x_1 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lean_Elab_Term_Quotation_He return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__4() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__4() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__3; +x_2 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__3; x_3 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_3, 0, x_1); lean_ctor_set(x_3, 1, x_1); @@ -5492,12 +5052,12 @@ lean_ctor_set(x_3, 2, x_2); return x_3; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo(lean_object* x_1) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo(lean_object* x_1) { _start: { lean_object* x_2; lean_object* x_3; lean_object* x_4; uint8_t x_5; x_2 = lean_ctor_get(x_1, 0); -x_3 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__1(x_2); +x_3 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__1(x_2); x_4 = l_Lean_mkTermIdFromIdent___closed__2; lean_inc(x_3); x_5 = l_Lean_Syntax_isOfKind(x_3, x_4); @@ -5516,7 +5076,7 @@ x_9 = l_Lean_Syntax_isOfKind(x_3, x_8); if (x_9 == 0) { lean_object* x_10; lean_object* x_11; lean_object* x_12; -x_10 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___boxed), 4, 1); +x_10 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___boxed), 4, 1); lean_closure_set(x_10, 0, x_3); x_11 = lean_box(0); x_12 = lean_alloc_ctor(0, 3, 0); @@ -5592,7 +5152,7 @@ if (x_59 == 0) { lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_dec(x_58); -x_60 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___boxed), 4, 1); +x_60 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___boxed), 4, 1); lean_closure_set(x_60, 0, x_56); x_61 = lean_box(0); x_62 = lean_alloc_ctor(0, 3, 0); @@ -5605,7 +5165,7 @@ else { lean_object* x_63; lean_object* x_64; lean_object* x_65; x_63 = lean_box(0); -x_64 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___boxed), 4, 1); +x_64 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___boxed), 4, 1); lean_closure_set(x_64, 0, x_56); x_65 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_65, 0, x_58); @@ -5619,7 +5179,7 @@ else lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_dec(x_58); lean_dec(x_56); -x_66 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__4___boxed), 4, 1); +x_66 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__4___boxed), 4, 1); lean_closure_set(x_66, 0, x_14); x_67 = lean_box(0); x_68 = lean_alloc_ctor(0, 3, 0); @@ -5643,7 +5203,7 @@ else { lean_object* x_75; lean_dec(x_14); -x_75 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__4; +x_75 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__4; return x_75; } block_50: @@ -5659,14 +5219,14 @@ x_17 = l_Lean_Elab_Term_Quotation_unescapeAntiquot(x_14); x_18 = l_Lean_Syntax_getArgs(x_17); x_19 = x_18; x_20 = lean_unsigned_to_nat(0u); -x_21 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2(x_8, x_20, x_19); +x_21 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2(x_8, x_20, x_19); x_22 = x_21; x_23 = l_Lean_Syntax_getKind(x_17); x_24 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_24, 0, x_23); x_25 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_25, 0, x_22); -x_26 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__1; +x_26 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__1; x_27 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_27, 0, x_24); lean_ctor_set(x_27, 1, x_25); @@ -5688,14 +5248,14 @@ x_31 = l_Lean_Elab_Term_Quotation_unescapeAntiquot(x_14); x_32 = l_Lean_Syntax_getArgs(x_31); x_33 = x_32; x_34 = lean_unsigned_to_nat(0u); -x_35 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2(x_8, x_34, x_33); +x_35 = l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2(x_8, x_34, x_33); x_36 = x_35; x_37 = l_Lean_Syntax_getKind(x_31); x_38 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_38, 0, x_37); x_39 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_39, 0, x_36); -x_40 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__2; +x_40 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__2; x_41 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_41, 0, x_38); lean_ctor_set(x_41, 1, x_39); @@ -5712,7 +5272,7 @@ x_44 = l_Lean_Elab_Term_Quotation_getAntiquotTerm(x_43); lean_dec(x_43); x_45 = l_Lean_mkAppStx___closed__6; x_46 = l_Lean_mkAppStx___closed__2; -x_47 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___boxed), 7, 4); +x_47 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___boxed), 7, 4); lean_closure_set(x_47, 0, x_45); lean_closure_set(x_47, 1, x_44); lean_closure_set(x_47, 2, x_46); @@ -5732,7 +5292,7 @@ else { lean_object* x_76; lean_dec(x_3); -x_76 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__4; +x_76 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__4; return x_76; } } @@ -5740,7 +5300,7 @@ else { lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; x_77 = l_Lean_mkAppStx___closed__6; -x_78 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__5___boxed), 6, 3); +x_78 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__5___boxed), 6, 3); lean_closure_set(x_78, 0, x_77); lean_closure_set(x_78, 1, x_3); lean_closure_set(x_78, 2, x_4); @@ -5753,98 +5313,98 @@ return x_80; } } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__1(x_1, x_2, x_3); +x_4 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__1(x_1, x_2, x_3); lean_dec(x_2); return x_4; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__2(x_1, x_2, x_3); +x_4 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__2(x_1, x_2, x_3); lean_dec(x_2); return x_4; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___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_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3(x_1, x_2, x_3, x_4); +x_5 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3(x_1, x_2, x_3, x_4); lean_dec(x_3); return x_5; } } -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__1___boxed(lean_object* x_1) { +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__1___boxed(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__1(x_1); +x_2 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__1(x_1); lean_dec(x_1); return x_2; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { lean_object* x_5; -x_5 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1(x_1, x_2, x_3, x_4); +x_5 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1(x_1, x_2, x_3, x_4); lean_dec(x_2); return x_5; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { _start: { lean_object* x_8; -x_8 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +x_8 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7); lean_dec(x_6); return x_8; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___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_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3(x_1, x_2, x_3, x_4); +x_5 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3(x_1, x_2, x_3, x_4); lean_dec(x_2); return x_5; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__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___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__4(x_1, x_2, x_3, x_4); +x_5 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__4(x_1, x_2, x_3, x_4); lean_dec(x_2); lean_dec(x_1); return x_5; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { _start: { lean_object* x_7; -x_7 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__5(x_1, x_2, x_3, x_4, x_5, x_6); +x_7 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__5(x_1, x_2, x_3, x_4, x_5, x_6); lean_dec(x_5); return x_7; } } -lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___boxed(lean_object* x_1) { +lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___boxed(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo(x_1); +x_2 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo(x_1); lean_dec(x_1); return x_2; } } -lean_object* l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; @@ -5859,15 +5419,15 @@ x_8 = lean_apply_3(x_2, x_6, x_3, x_7); return x_8; } } -lean_object* l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1(lean_object* x_1, lean_object* x_2) { +lean_object* l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 0); +x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 0); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__1() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -5879,69 +5439,69 @@ lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_empty___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__1; +x_2 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__1; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_mkHole___closed__2; -x_2 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__2; +x_2 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__2; 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* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; lean_object* x_5; -x_4 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__3; +x_4 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__3; x_5 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_5, 0, x_4); lean_ctor_set(x_5, 1, x_3); return x_5; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__1() { _start: { lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___boxed), 3, 0); +x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___boxed), 3, 0); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_2 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__1; -x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_2 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__1; +x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_3, 0, x_1); lean_closure_set(x_3, 1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__3() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__2; +x_1 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__2; x_2 = l_Lean_Unhygienic_run___rarg(x_1); return x_2; } } -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat(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; @@ -5955,7 +5515,7 @@ lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_dec(x_5); lean_dec(x_2); lean_dec(x_1); -x_7 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_7 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_8 = l_unreachable_x21___rarg(x_7); x_9 = lean_apply_2(x_8, x_3, x_4); return x_9; @@ -5984,7 +5544,7 @@ lean_dec(x_6); x_16 = lean_ctor_get(x_10, 2); lean_inc(x_16); lean_dec(x_10); -x_17 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__3; +x_17 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__3; x_18 = l_List_replicate___rarg(x_1, x_17); x_19 = lean_apply_3(x_16, x_13, x_3, x_4); if (lean_obj_tag(x_19) == 0) @@ -6056,7 +5616,7 @@ lean_dec(x_6); x_33 = lean_ctor_get(x_10, 2); lean_inc(x_33); lean_dec(x_10); -x_34 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__3; +x_34 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__3; x_35 = l_List_replicate___rarg(x_1, x_34); x_36 = lean_apply_3(x_33, x_31, x_3, x_4); if (lean_obj_tag(x_36) == 0) @@ -6272,17 +5832,17 @@ return x_81; } } } -lean_object* l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1(x_1, x_2, x_3); +x_4 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1(x_1, x_2, x_3); lean_dec(x_2); lean_dec(x_1); return x_4; } } -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__1(lean_object* x_1) { +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__1(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) @@ -6300,9 +5860,9 @@ if (x_3 == 0) lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; x_4 = lean_ctor_get(x_1, 0); x_5 = lean_ctor_get(x_1, 1); -x_6 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo(x_4); +x_6 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo(x_4); lean_dec(x_4); -x_7 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__1(x_5); +x_7 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__1(x_5); lean_ctor_set(x_1, 1, x_7); lean_ctor_set(x_1, 0, x_6); return x_1; @@ -6315,9 +5875,9 @@ x_9 = lean_ctor_get(x_1, 1); lean_inc(x_9); lean_inc(x_8); lean_dec(x_1); -x_10 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo(x_8); +x_10 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo(x_8); lean_dec(x_8); -x_11 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__1(x_9); +x_11 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__1(x_9); x_12 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_12, 0, x_10); lean_ctor_set(x_12, 1, x_11); @@ -6326,7 +5886,7 @@ return x_12; } } } -lean_object* _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__1() { +lean_object* _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__1() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -6336,11 +5896,11 @@ x_3 = l_monadInhabited___rarg(x_1, x_2); return x_3; } } -lean_object* _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__2() { +lean_object* _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__1; +x_1 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__1; x_2 = l_Lean_Syntax_inhabited; x_3 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_3, 0, x_1); @@ -6348,25 +5908,25 @@ lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__3() { +lean_object* _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Elab_Term_Quotation_HeadInfo_Inhabited; -x_2 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__2; +x_2 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__2; x_3 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_3, 0, x_1); lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2(lean_object* x_1) { +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) { lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_2 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__3; +x_2 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__3; x_3 = l_List_head_x21___rarg___closed__2; x_4 = lean_panic_fn(x_2, x_3); return x_4; @@ -6380,7 +5940,7 @@ return x_5; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__3(lean_object* x_1, lean_object* x_2) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__3(lean_object* x_1, lean_object* x_2) { _start: { if (lean_obj_tag(x_2) == 0) @@ -6410,7 +5970,7 @@ goto _start; } } } -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_2) == 0) @@ -6483,7 +6043,7 @@ goto _start; } } } -lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5___closed__1() { +lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5___closed__1() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -6493,7 +6053,7 @@ x_3 = l_List_lengthAux___main___rarg(x_1, x_2); return x_3; } } -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_1) == 0) @@ -6515,9 +6075,9 @@ if (x_6 == 0) lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; x_7 = lean_ctor_get(x_1, 0); x_8 = lean_ctor_get(x_1, 1); -x_9 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5___closed__1; +x_9 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5___closed__1; lean_inc(x_2); -x_10 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat(x_9, x_7, x_2, x_3); +x_10 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat(x_9, x_7, x_2, x_3); if (lean_obj_tag(x_10) == 0) { lean_object* x_11; lean_object* x_12; lean_object* x_13; @@ -6526,7 +6086,7 @@ lean_inc(x_11); x_12 = lean_ctor_get(x_10, 1); lean_inc(x_12); lean_dec(x_10); -x_13 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5(x_8, x_2, x_12); +x_13 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5(x_8, x_2, x_12); if (lean_obj_tag(x_13) == 0) { uint8_t x_14; @@ -6615,9 +6175,9 @@ x_28 = lean_ctor_get(x_1, 1); lean_inc(x_28); lean_inc(x_27); lean_dec(x_1); -x_29 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5___closed__1; +x_29 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5___closed__1; lean_inc(x_2); -x_30 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat(x_29, x_27, x_2, x_3); +x_30 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat(x_29, x_27, x_2, x_3); if (lean_obj_tag(x_30) == 0) { lean_object* x_31; lean_object* x_32; lean_object* x_33; @@ -6626,7 +6186,7 @@ lean_inc(x_31); x_32 = lean_ctor_get(x_30, 1); lean_inc(x_32); lean_dec(x_30); -x_33 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5(x_28, x_2, x_32); +x_33 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5(x_28, x_2, x_32); 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; @@ -6710,7 +6270,7 @@ return x_46; } } } -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_2) == 0) @@ -6783,7 +6343,7 @@ goto _start; } } } -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__7(lean_object* x_1) { +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__7(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) @@ -6804,7 +6364,7 @@ x_5 = lean_ctor_get(x_1, 1); x_6 = lean_ctor_get(x_4, 1); lean_inc(x_6); lean_dec(x_4); -x_7 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__7(x_5); +x_7 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__7(x_5); lean_ctor_set(x_1, 1, x_7); lean_ctor_set(x_1, 0, x_6); return x_1; @@ -6820,7 +6380,7 @@ lean_dec(x_1); x_10 = lean_ctor_get(x_8, 1); lean_inc(x_10); lean_dec(x_8); -x_11 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__7(x_9); +x_11 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__7(x_9); x_12 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_12, 0, x_10); lean_ctor_set(x_12, 1, x_11); @@ -6829,7 +6389,7 @@ return x_12; } } } -lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__1() { +lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__1() { _start: { lean_object* x_1; @@ -6837,22 +6397,22 @@ x_1 = lean_mk_string("Syntax.getArg"); return x_1; } } -lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__2() { +lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__1; +x_1 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__1; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__3() { +lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__1; +x_1 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__2; +x_3 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__2; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -6860,7 +6420,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__4() { +lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__4() { _start: { lean_object* x_1; @@ -6868,51 +6428,51 @@ x_1 = lean_mk_string("getArg"); return x_1; } } -lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__5() { +lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12; -x_2 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__4; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12; +x_2 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__4; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__6() { +lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l___private_Init_Lean_Elab_Util_1__evalSyntaxConstantUnsafe___closed__1; -x_2 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__4; +x_2 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__4; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__7() { +lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__6; +x_2 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__6; 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_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__8() { +lean_object* _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__7; +x_2 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__7; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_1) == 0) @@ -6946,13 +6506,13 @@ x_14 = lean_ctor_get(x_12, 1); lean_inc(x_14); lean_dec(x_12); x_15 = lean_box(0); -x_16 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__5; +x_16 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__5; lean_inc(x_10); lean_inc(x_13); x_17 = l_Lean_addMacroScope(x_13, x_16, x_10); x_18 = lean_box(0); -x_19 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__3; -x_20 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__8; +x_19 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__3; +x_20 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__8; x_21 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_21, 0, x_15); lean_ctor_set(x_21, 1, x_19); @@ -6967,9 +6527,9 @@ x_27 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_27, 0, x_26); lean_ctor_set(x_27, 1, x_25); x_28 = lean_array_push(x_22, x_27); -x_29 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_29 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_30 = l_Lean_addMacroScope(x_13, x_29, x_10); -x_31 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_31 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_32 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_32, 0, x_15); lean_ctor_set(x_32, 1, x_31); @@ -6986,7 +6546,7 @@ x_38 = l_Lean_numLitKind; x_39 = l_Lean_mkStxLit(x_38, x_37, x_15); x_40 = l_Lean_mkOptionalNode___closed__2; x_41 = lean_array_push(x_40, x_39); -x_42 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_42 = l_Lean_Nat_HasQuote___closed__2; x_43 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_43, 0, x_42); lean_ctor_set(x_43, 1, x_41); @@ -7000,7 +6560,7 @@ x_48 = l_Lean_mkAppStx___closed__8; x_49 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_49, 0, x_48); lean_ctor_set(x_49, 1, x_47); -x_50 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8(x_8, x_2, x_14); +x_50 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8(x_8, x_2, x_14); x_51 = !lean_is_exclusive(x_50); if (x_51 == 0) { @@ -7048,13 +6608,13 @@ x_63 = lean_ctor_get(x_61, 1); lean_inc(x_63); lean_dec(x_61); x_64 = lean_box(0); -x_65 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__5; +x_65 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__5; lean_inc(x_59); lean_inc(x_62); x_66 = l_Lean_addMacroScope(x_62, x_65, x_59); x_67 = lean_box(0); -x_68 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__3; -x_69 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__8; +x_68 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__3; +x_69 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__8; x_70 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_70, 0, x_64); lean_ctor_set(x_70, 1, x_68); @@ -7069,9 +6629,9 @@ x_76 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_76, 0, x_75); lean_ctor_set(x_76, 1, x_74); x_77 = lean_array_push(x_71, x_76); -x_78 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_78 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_79 = l_Lean_addMacroScope(x_62, x_78, x_59); -x_80 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_80 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_81 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_81, 0, x_64); lean_ctor_set(x_81, 1, x_80); @@ -7088,7 +6648,7 @@ x_87 = l_Lean_numLitKind; x_88 = l_Lean_mkStxLit(x_87, x_86, x_64); x_89 = l_Lean_mkOptionalNode___closed__2; x_90 = lean_array_push(x_89, x_88); -x_91 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_91 = l_Lean_Nat_HasQuote___closed__2; x_92 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_92, 0, x_91); lean_ctor_set(x_92, 1, x_90); @@ -7102,7 +6662,7 @@ x_97 = l_Lean_mkAppStx___closed__8; x_98 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_98, 0, x_97); lean_ctor_set(x_98, 1, x_96); -x_99 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8(x_57, x_2, x_63); +x_99 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8(x_57, x_2, x_63); x_100 = lean_ctor_get(x_99, 0); lean_inc(x_100); x_101 = lean_ctor_get(x_99, 1); @@ -7130,7 +6690,7 @@ return x_104; } } } -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__9(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__9(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_2) == 0) @@ -7203,7 +6763,7 @@ goto _start; } } } -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__10(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__10(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { if (lean_obj_tag(x_2) == 0) @@ -7228,7 +6788,7 @@ x_9 = lean_ctor_get(x_2, 1); x_10 = lean_unsigned_to_nat(0u); x_11 = l_List_lengthAux___main___rarg(x_1, x_10); lean_inc(x_3); -x_12 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat(x_11, x_8, x_3, x_4); +x_12 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat(x_11, x_8, x_3, x_4); if (lean_obj_tag(x_12) == 0) { lean_object* x_13; lean_object* x_14; lean_object* x_15; @@ -7237,7 +6797,7 @@ lean_inc(x_13); x_14 = lean_ctor_get(x_12, 1); lean_inc(x_14); lean_dec(x_12); -x_15 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__10(x_1, x_9, x_3, x_14); +x_15 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__10(x_1, x_9, x_3, x_14); if (lean_obj_tag(x_15) == 0) { uint8_t x_16; @@ -7329,7 +6889,7 @@ lean_dec(x_2); x_31 = lean_unsigned_to_nat(0u); x_32 = l_List_lengthAux___main___rarg(x_1, x_31); lean_inc(x_3); -x_33 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat(x_32, x_29, x_3, x_4); +x_33 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat(x_32, x_29, x_3, x_4); if (lean_obj_tag(x_33) == 0) { lean_object* x_34; lean_object* x_35; lean_object* x_36; @@ -7338,7 +6898,7 @@ lean_inc(x_34); x_35 = lean_ctor_get(x_33, 1); lean_inc(x_35); lean_dec(x_33); -x_36 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__10(x_1, x_30, x_3, x_35); +x_36 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__10(x_1, x_30, x_3, x_35); 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; @@ -7422,7 +6982,7 @@ return x_49; } } } -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__11(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__11(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_2) == 0) @@ -7495,7 +7055,7 @@ goto _start; } } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__1() { _start: { lean_object* x_1; @@ -7503,27 +7063,27 @@ x_1 = lean_mk_string("non-exhaustive 'match_syntax'"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__1; x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__3() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__2; +x_1 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__2; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__4() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__4() { _start: { lean_object* x_1; @@ -7531,22 +7091,22 @@ x_1 = lean_mk_string("Syntax.isOfKind"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__5() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__5() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__4; +x_1 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__4; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__4; +x_1 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__4; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__5; +x_3 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__5; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -7554,7 +7114,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__7() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__7() { _start: { lean_object* x_1; @@ -7562,51 +7122,51 @@ x_1 = lean_mk_string("isOfKind"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12; -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__7; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__7; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__9() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__9() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l___private_Init_Lean_Elab_Util_1__evalSyntaxConstantUnsafe___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__7; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__7; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__10() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__10() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__9; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__9; 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___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__10; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__10; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__12() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__12() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -7618,27 +7178,27 @@ lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__13() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__13() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_empty___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__12; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__12; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__13; +x_1 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__13; x_2 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -7650,7 +7210,7 @@ lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__16() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__16() { _start: { lean_object* x_1; lean_object* x_2; @@ -7659,13 +7219,13 @@ x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Bool_HasRepr___closed__2; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__16; +x_3 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__16; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -7673,7 +7233,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -7683,7 +7243,7 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__19() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__19() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -7695,19 +7255,19 @@ lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__19; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___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); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__21() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__21() { _start: { lean_object* x_1; @@ -7715,19 +7275,19 @@ x_1 = lean_mk_string("then"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__21; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__21; 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* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__23() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__23() { _start: { lean_object* x_1; @@ -7735,19 +7295,19 @@ x_1 = lean_mk_string("else"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__23; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__23; 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* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__25() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__25() { _start: { lean_object* x_1; @@ -7755,19 +7315,19 @@ x_1 = lean_mk_string("&&"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__26() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__26() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__25; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__25; 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* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__27() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__27() { _start: { lean_object* x_1; @@ -7775,22 +7335,22 @@ x_1 = lean_mk_string("Array.size"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__28() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__28() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__27; +x_1 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__27; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__29() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__29() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__27; +x_1 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__27; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__28; +x_3 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__28; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -7798,7 +7358,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__30() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__30() { _start: { lean_object* x_1; @@ -7806,75 +7366,75 @@ x_1 = lean_mk_string("size"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__31() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__31() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_arrayToExpr___rarg___closed__2; -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__30; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__30; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__32() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__32() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__31; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__31; 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___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__33() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__33() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__32; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__32; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__34() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__34() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l___private_Init_Lean_Elab_Util_1__evalSyntaxConstantUnsafe___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__4; +x_2 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__4; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__35() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__35() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__34; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__34; 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___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__36() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__36() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__35; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__35; x_3 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_3, 0, x_2); lean_ctor_set(x_3, 1, x_1); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__37() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__37() { _start: { lean_object* x_1; @@ -7882,19 +7442,19 @@ x_1 = lean_mk_string("=="); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__38() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__38() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__37; +x_2 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__37; 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* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { if (lean_obj_tag(x_2) == 0) @@ -7902,7 +7462,7 @@ if (lean_obj_tag(x_2) == 0) if (lean_obj_tag(x_3) == 0) { lean_object* x_6; lean_object* x_7; -x_6 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__3; +x_6 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__3; x_7 = l_Lean_Elab_Term_throwError___rarg(x_1, x_6, x_4, x_5); return x_7; } @@ -7931,7 +7491,7 @@ else lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_dec(x_9); lean_dec(x_8); -x_12 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_12 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_13 = l_unreachable_x21___rarg(x_12); x_14 = lean_apply_2(x_13, x_4, x_5); return x_14; @@ -7944,7 +7504,7 @@ if (lean_obj_tag(x_3) == 0) { lean_object* x_15; lean_object* x_16; lean_dec(x_2); -x_15 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__3; +x_15 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__3; x_16 = l_Lean_Elab_Term_throwError___rarg(x_1, x_15, x_4, x_5); return x_16; } @@ -7956,12 +7516,12 @@ lean_inc(x_17); x_18 = lean_ctor_get(x_2, 1); lean_inc(x_18); lean_inc(x_3); -x_19 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__1(x_3); +x_19 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__1(x_3); x_20 = l_List_zip___rarg___closed__1; x_21 = l_List_zipWith___main___rarg(x_20, x_19, x_3); -x_22 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2(x_21); +x_22 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2(x_21); x_23 = l_List_tail_x21___rarg(x_21); -x_24 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__3(x_22, x_23); +x_24 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__3(x_22, x_23); lean_dec(x_23); lean_dec(x_22); x_25 = lean_ctor_get(x_24, 0); @@ -7974,9 +7534,9 @@ if (lean_obj_tag(x_26) == 0) lean_object* x_27; lean_object* x_28; lean_object* x_29; x_27 = lean_box(0); lean_inc(x_21); -x_28 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__4(x_25, x_21, x_27); +x_28 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__4(x_25, x_21, x_27); lean_inc(x_4); -x_29 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5(x_28, x_4, x_5); +x_29 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5(x_28, x_4, x_5); if (lean_obj_tag(x_29) == 0) { lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; @@ -8038,7 +7598,7 @@ lean_ctor_set(x_49, 9, x_34); lean_ctor_set_uint8(x_49, sizeof(void*)*10, x_46); lean_ctor_set_uint8(x_49, sizeof(void*)*10 + 1, x_47); lean_ctor_set_uint8(x_49, sizeof(void*)*10 + 2, x_48); -x_50 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_32, x_30, x_49, x_31); +x_50 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_32, x_30, x_49, x_31); if (lean_obj_tag(x_50) == 0) { lean_object* x_51; @@ -8078,9 +7638,9 @@ if (x_58 == 0) lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; x_59 = lean_ctor_get(x_57, 0); x_60 = lean_box(0); -x_61 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_61 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_62 = l_Lean_addMacroScope(x_59, x_61, x_55); -x_63 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_63 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_64 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_64, 0, x_60); lean_ctor_set(x_64, 1, x_63); @@ -8091,16 +7651,16 @@ x_66 = lean_array_push(x_65, x_64); x_67 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_68 = lean_array_push(x_66, x_67); x_69 = lean_array_push(x_68, x_67); -x_70 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_70 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_71 = lean_array_push(x_69, x_70); x_72 = lean_array_push(x_71, x_17); x_73 = l_Lean_Parser_Term_letIdDecl___closed__2; x_74 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_74, 0, x_73); lean_ctor_set(x_74, 1, x_72); -x_75 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_75 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_76 = lean_array_push(x_75, x_74); -x_77 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_77 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_78 = lean_array_push(x_76, x_77); x_79 = lean_array_push(x_78, x_52); x_80 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -8119,9 +7679,9 @@ lean_inc(x_83); lean_inc(x_82); lean_dec(x_57); x_84 = lean_box(0); -x_85 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_85 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_86 = l_Lean_addMacroScope(x_82, x_85, x_55); -x_87 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_87 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_88 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_88, 0, x_84); lean_ctor_set(x_88, 1, x_87); @@ -8132,16 +7692,16 @@ x_90 = lean_array_push(x_89, x_88); x_91 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_92 = lean_array_push(x_90, x_91); x_93 = lean_array_push(x_92, x_91); -x_94 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_94 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_95 = lean_array_push(x_93, x_94); x_96 = lean_array_push(x_95, x_17); x_97 = l_Lean_Parser_Term_letIdDecl___closed__2; x_98 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_98, 0, x_97); lean_ctor_set(x_98, 1, x_96); -x_99 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_99 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_100 = lean_array_push(x_99, x_98); -x_101 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_101 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_102 = lean_array_push(x_100, x_101); x_103 = lean_array_push(x_102, x_52); x_104 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -8165,9 +7725,9 @@ lean_dec(x_50); x_109 = lean_ctor_get(x_51, 0); lean_inc(x_109); lean_dec(x_51); -x_110 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__6(x_25, x_21, x_27); +x_110 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__6(x_25, x_21, x_27); lean_dec(x_25); -x_111 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__7(x_110); +x_111 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__7(x_110); x_112 = !lean_is_exclusive(x_108); if (x_112 == 0) { @@ -8189,7 +7749,7 @@ lean_ctor_set(x_115, 9, x_113); lean_ctor_set_uint8(x_115, sizeof(void*)*10, x_46); lean_ctor_set_uint8(x_115, sizeof(void*)*10 + 1, x_47); lean_ctor_set_uint8(x_115, sizeof(void*)*10 + 2, x_48); -x_116 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_2, x_111, x_115, x_108); +x_116 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_2, x_111, x_115, x_108); if (lean_obj_tag(x_116) == 0) { lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_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; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; uint8_t x_157; @@ -8211,12 +7771,12 @@ x_124 = lean_ctor_get(x_122, 1); lean_inc(x_124); lean_dec(x_122); x_125 = lean_box(0); -x_126 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8; +x_126 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8; lean_inc(x_120); lean_inc(x_123); x_127 = l_Lean_addMacroScope(x_123, x_126, x_120); -x_128 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6; -x_129 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11; +x_128 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6; +x_129 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11; x_130 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_130, 0, x_125); lean_ctor_set(x_130, 1, x_128); @@ -8231,9 +7791,9 @@ x_136 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_136, 0, x_135); lean_ctor_set(x_136, 1, x_134); x_137 = lean_array_push(x_131, x_136); -x_138 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_138 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_139 = l_Lean_addMacroScope(x_123, x_138, x_120); -x_140 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_140 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_141 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_141, 0, x_125); lean_ctor_set(x_141, 1, x_140); @@ -8245,7 +7805,7 @@ x_144 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_144, 0, x_135); lean_ctor_set(x_144, 1, x_143); x_145 = lean_array_push(x_131, x_144); -x_146 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_109); +x_146 = l___private_Init_Lean_Syntax_7__quoteName___main(x_109); x_147 = lean_array_push(x_145, x_146); x_148 = l_Lean_nullKind___closed__2; x_149 = lean_alloc_ctor(1, 2, 0); @@ -8280,24 +7840,24 @@ lean_ctor_set(x_160, 3, x_27); x_161 = lean_array_push(x_131, x_160); x_162 = lean_array_push(x_161, x_133); x_163 = lean_array_push(x_162, x_133); -x_164 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_164 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_165 = lean_array_push(x_163, x_164); x_166 = lean_array_push(x_165, x_17); x_167 = l_Lean_Parser_Term_letIdDecl___closed__2; x_168 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_168, 0, x_167); lean_ctor_set(x_168, 1, x_166); -x_169 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_169 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_170 = lean_array_push(x_169, x_168); -x_171 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_171 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_172 = lean_array_push(x_170, x_171); x_173 = lean_array_push(x_131, x_152); -x_174 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15; +x_174 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15; x_175 = lean_array_push(x_173, x_174); -x_176 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18; +x_176 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18; x_177 = l_Lean_addMacroScope(x_158, x_176, x_154); -x_178 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17; -x_179 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20; +x_178 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17; +x_179 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20; x_180 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_180, 0, x_125); lean_ctor_set(x_180, 1, x_178); @@ -8313,12 +7873,12 @@ x_185 = l_Lean_Parser_Term_eq___elambda__1___closed__2; x_186 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_186, 0, x_185); lean_ctor_set(x_186, 1, x_184); -x_187 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14; +x_187 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14; x_188 = lean_array_push(x_187, x_186); -x_189 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22; +x_189 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22; x_190 = lean_array_push(x_188, x_189); x_191 = lean_array_push(x_190, x_107); -x_192 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24; +x_192 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24; x_193 = lean_array_push(x_191, x_192); x_194 = lean_array_push(x_193, x_117); x_195 = l_Lean_Parser_Term_if___elambda__1___closed__2; @@ -8352,24 +7912,24 @@ lean_ctor_set(x_203, 3, x_27); x_204 = lean_array_push(x_131, x_203); x_205 = lean_array_push(x_204, x_133); x_206 = lean_array_push(x_205, x_133); -x_207 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_207 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_208 = lean_array_push(x_206, x_207); x_209 = lean_array_push(x_208, x_17); x_210 = l_Lean_Parser_Term_letIdDecl___closed__2; x_211 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_211, 0, x_210); lean_ctor_set(x_211, 1, x_209); -x_212 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_212 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_213 = lean_array_push(x_212, x_211); -x_214 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_214 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_215 = lean_array_push(x_213, x_214); x_216 = lean_array_push(x_131, x_152); -x_217 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15; +x_217 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15; x_218 = lean_array_push(x_216, x_217); -x_219 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18; +x_219 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18; x_220 = l_Lean_addMacroScope(x_200, x_219, x_154); -x_221 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17; -x_222 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20; +x_221 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17; +x_222 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20; x_223 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_223, 0, x_125); lean_ctor_set(x_223, 1, x_221); @@ -8385,12 +7945,12 @@ x_228 = l_Lean_Parser_Term_eq___elambda__1___closed__2; x_229 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_229, 0, x_228); lean_ctor_set(x_229, 1, x_227); -x_230 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14; +x_230 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14; x_231 = lean_array_push(x_230, x_229); -x_232 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22; +x_232 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22; x_233 = lean_array_push(x_231, x_232); x_234 = lean_array_push(x_233, x_107); -x_235 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24; +x_235 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24; x_236 = lean_array_push(x_234, x_235); x_237 = lean_array_push(x_236, x_117); x_238 = l_Lean_Parser_Term_if___elambda__1___closed__2; @@ -8473,7 +8033,7 @@ lean_ctor_set(x_256, 9, x_253); lean_ctor_set_uint8(x_256, sizeof(void*)*10, x_46); lean_ctor_set_uint8(x_256, sizeof(void*)*10 + 1, x_47); lean_ctor_set_uint8(x_256, sizeof(void*)*10 + 2, x_48); -x_257 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_2, x_111, x_256, x_255); +x_257 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_2, x_111, x_256, x_255); if (lean_obj_tag(x_257) == 0) { lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; 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_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; 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_340; lean_object* x_341; lean_object* x_342; @@ -8495,12 +8055,12 @@ x_265 = lean_ctor_get(x_263, 1); lean_inc(x_265); lean_dec(x_263); x_266 = lean_box(0); -x_267 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8; +x_267 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8; lean_inc(x_261); lean_inc(x_264); x_268 = l_Lean_addMacroScope(x_264, x_267, x_261); -x_269 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6; -x_270 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11; +x_269 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6; +x_270 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11; x_271 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_271, 0, x_266); lean_ctor_set(x_271, 1, x_269); @@ -8515,9 +8075,9 @@ x_277 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_277, 0, x_276); lean_ctor_set(x_277, 1, x_275); x_278 = lean_array_push(x_272, x_277); -x_279 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_279 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_280 = l_Lean_addMacroScope(x_264, x_279, x_261); -x_281 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_281 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_282 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_282, 0, x_266); lean_ctor_set(x_282, 1, x_281); @@ -8529,7 +8089,7 @@ x_285 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_285, 0, x_276); lean_ctor_set(x_285, 1, x_284); x_286 = lean_array_push(x_272, x_285); -x_287 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_109); +x_287 = l___private_Init_Lean_Syntax_7__quoteName___main(x_109); x_288 = lean_array_push(x_286, x_287); x_289 = l_Lean_nullKind___closed__2; x_290 = lean_alloc_ctor(1, 2, 0); @@ -8571,24 +8131,24 @@ lean_ctor_set(x_302, 3, x_27); x_303 = lean_array_push(x_272, x_302); x_304 = lean_array_push(x_303, x_274); x_305 = lean_array_push(x_304, x_274); -x_306 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_306 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_307 = lean_array_push(x_305, x_306); x_308 = lean_array_push(x_307, x_17); x_309 = l_Lean_Parser_Term_letIdDecl___closed__2; x_310 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_310, 0, x_309); lean_ctor_set(x_310, 1, x_308); -x_311 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_311 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_312 = lean_array_push(x_311, x_310); -x_313 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_313 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_314 = lean_array_push(x_312, x_313); x_315 = lean_array_push(x_272, x_293); -x_316 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15; +x_316 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15; x_317 = lean_array_push(x_315, x_316); -x_318 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18; +x_318 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18; x_319 = l_Lean_addMacroScope(x_298, x_318, x_295); -x_320 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17; -x_321 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20; +x_320 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17; +x_321 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20; x_322 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_322, 0, x_266); lean_ctor_set(x_322, 1, x_320); @@ -8604,12 +8164,12 @@ x_327 = l_Lean_Parser_Term_eq___elambda__1___closed__2; x_328 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_328, 0, x_327); lean_ctor_set(x_328, 1, x_326); -x_329 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14; +x_329 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14; x_330 = lean_array_push(x_329, x_328); -x_331 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22; +x_331 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22; x_332 = lean_array_push(x_330, x_331); x_333 = lean_array_push(x_332, x_107); -x_334 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24; +x_334 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24; x_335 = lean_array_push(x_333, x_334); x_336 = lean_array_push(x_335, x_258); x_337 = l_Lean_Parser_Term_if___elambda__1___closed__2; @@ -8767,7 +8327,7 @@ lean_ctor_set(x_372, 9, x_356); lean_ctor_set_uint8(x_372, sizeof(void*)*10, x_369); lean_ctor_set_uint8(x_372, sizeof(void*)*10 + 1, x_370); lean_ctor_set_uint8(x_372, sizeof(void*)*10 + 2, x_371); -x_373 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_32, x_30, x_372, x_359); +x_373 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_32, x_30, x_372, x_359); if (lean_obj_tag(x_373) == 0) { lean_object* x_374; @@ -8814,9 +8374,9 @@ if (lean_is_exclusive(x_380)) { x_383 = lean_box(0); } x_384 = lean_box(0); -x_385 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_385 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_386 = l_Lean_addMacroScope(x_381, x_385, x_378); -x_387 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_387 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_388 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_388, 0, x_384); lean_ctor_set(x_388, 1, x_387); @@ -8827,16 +8387,16 @@ x_390 = lean_array_push(x_389, x_388); x_391 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_392 = lean_array_push(x_390, x_391); x_393 = lean_array_push(x_392, x_391); -x_394 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_394 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_395 = lean_array_push(x_393, x_394); x_396 = lean_array_push(x_395, x_17); x_397 = l_Lean_Parser_Term_letIdDecl___closed__2; x_398 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_398, 0, x_397); lean_ctor_set(x_398, 1, x_396); -x_399 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_399 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_400 = lean_array_push(x_399, x_398); -x_401 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_401 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_402 = lean_array_push(x_400, x_401); x_403 = lean_array_push(x_402, x_375); x_404 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -8863,9 +8423,9 @@ lean_dec(x_373); x_409 = lean_ctor_get(x_374, 0); lean_inc(x_409); lean_dec(x_374); -x_410 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__6(x_25, x_21, x_27); +x_410 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__6(x_25, x_21, x_27); lean_dec(x_25); -x_411 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__7(x_410); +x_411 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__7(x_410); x_412 = lean_ctor_get(x_408, 0); lean_inc(x_412); x_413 = lean_ctor_get(x_408, 1); @@ -8916,7 +8476,7 @@ lean_ctor_set(x_421, 9, x_417); lean_ctor_set_uint8(x_421, sizeof(void*)*10, x_369); lean_ctor_set_uint8(x_421, sizeof(void*)*10 + 1, x_370); lean_ctor_set_uint8(x_421, sizeof(void*)*10 + 2, x_371); -x_422 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_2, x_411, x_421, x_420); +x_422 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_2, x_411, x_421, x_420); if (lean_obj_tag(x_422) == 0) { lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; lean_object* x_504; lean_object* x_505; lean_object* x_506; lean_object* x_507; @@ -8938,12 +8498,12 @@ x_430 = lean_ctor_get(x_428, 1); lean_inc(x_430); lean_dec(x_428); x_431 = lean_box(0); -x_432 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8; +x_432 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8; lean_inc(x_426); lean_inc(x_429); x_433 = l_Lean_addMacroScope(x_429, x_432, x_426); -x_434 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6; -x_435 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11; +x_434 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6; +x_435 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11; x_436 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_436, 0, x_431); lean_ctor_set(x_436, 1, x_434); @@ -8958,9 +8518,9 @@ x_442 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_442, 0, x_441); lean_ctor_set(x_442, 1, x_440); x_443 = lean_array_push(x_437, x_442); -x_444 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_444 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_445 = l_Lean_addMacroScope(x_429, x_444, x_426); -x_446 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_446 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_447 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_447, 0, x_431); lean_ctor_set(x_447, 1, x_446); @@ -8972,7 +8532,7 @@ x_450 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_450, 0, x_441); lean_ctor_set(x_450, 1, x_449); x_451 = lean_array_push(x_437, x_450); -x_452 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_409); +x_452 = l___private_Init_Lean_Syntax_7__quoteName___main(x_409); x_453 = lean_array_push(x_451, x_452); x_454 = l_Lean_nullKind___closed__2; x_455 = lean_alloc_ctor(1, 2, 0); @@ -9014,24 +8574,24 @@ lean_ctor_set(x_467, 3, x_27); x_468 = lean_array_push(x_437, x_467); x_469 = lean_array_push(x_468, x_439); x_470 = lean_array_push(x_469, x_439); -x_471 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_471 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_472 = lean_array_push(x_470, x_471); x_473 = lean_array_push(x_472, x_17); x_474 = l_Lean_Parser_Term_letIdDecl___closed__2; x_475 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_475, 0, x_474); lean_ctor_set(x_475, 1, x_473); -x_476 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_476 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_477 = lean_array_push(x_476, x_475); -x_478 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_478 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_479 = lean_array_push(x_477, x_478); x_480 = lean_array_push(x_437, x_458); -x_481 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15; +x_481 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15; x_482 = lean_array_push(x_480, x_481); -x_483 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18; +x_483 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18; x_484 = l_Lean_addMacroScope(x_463, x_483, x_460); -x_485 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17; -x_486 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20; +x_485 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17; +x_486 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20; x_487 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_487, 0, x_431); lean_ctor_set(x_487, 1, x_485); @@ -9047,12 +8607,12 @@ x_492 = l_Lean_Parser_Term_eq___elambda__1___closed__2; x_493 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_493, 0, x_492); lean_ctor_set(x_493, 1, x_491); -x_494 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14; +x_494 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14; x_495 = lean_array_push(x_494, x_493); -x_496 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22; +x_496 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22; x_497 = lean_array_push(x_495, x_496); x_498 = lean_array_push(x_497, x_407); -x_499 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24; +x_499 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24; x_500 = lean_array_push(x_498, x_499); x_501 = lean_array_push(x_500, x_423); x_502 = l_Lean_Parser_Term_if___elambda__1___closed__2; @@ -9182,7 +8742,7 @@ x_521 = lean_array_get_size(x_520); lean_dec(x_520); lean_inc(x_521); x_522 = l_List_range(x_521); -x_523 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8(x_522, x_4, x_5); +x_523 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8(x_522, x_4, x_5); x_524 = lean_ctor_get(x_523, 0); lean_inc(x_524); x_525 = lean_ctor_get(x_523, 1); @@ -9190,9 +8750,9 @@ lean_inc(x_525); lean_dec(x_523); x_526 = lean_box(0); lean_inc(x_21); -x_527 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__9(x_25, x_21, x_526); +x_527 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__9(x_25, x_21, x_526); lean_inc(x_4); -x_528 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__10(x_524, x_527, x_4, x_525); +x_528 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__10(x_524, x_527, x_4, x_525); if (lean_obj_tag(x_528) == 0) { lean_object* x_529; lean_object* x_530; lean_object* x_531; uint8_t x_532; @@ -9254,7 +8814,7 @@ lean_ctor_set(x_548, 9, x_533); lean_ctor_set_uint8(x_548, sizeof(void*)*10, x_545); lean_ctor_set_uint8(x_548, sizeof(void*)*10 + 1, x_546); lean_ctor_set_uint8(x_548, sizeof(void*)*10 + 2, x_547); -x_549 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_531, x_529, x_548, x_530); +x_549 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_531, x_529, x_548, x_530); if (lean_obj_tag(x_549) == 0) { lean_object* x_550; @@ -9295,9 +8855,9 @@ if (x_557 == 0) lean_object* x_558; lean_object* x_559; lean_object* x_560; lean_object* x_561; lean_object* x_562; lean_object* x_563; lean_object* x_564; lean_object* x_565; lean_object* x_566; lean_object* x_567; lean_object* x_568; lean_object* x_569; lean_object* x_570; lean_object* x_571; lean_object* x_572; lean_object* x_573; lean_object* x_574; lean_object* x_575; lean_object* x_576; lean_object* x_577; lean_object* x_578; lean_object* x_579; lean_object* x_580; x_558 = lean_ctor_get(x_556, 0); x_559 = lean_box(0); -x_560 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_560 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_561 = l_Lean_addMacroScope(x_558, x_560, x_554); -x_562 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_562 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_563 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_563, 0, x_559); lean_ctor_set(x_563, 1, x_562); @@ -9308,16 +8868,16 @@ x_565 = lean_array_push(x_564, x_563); x_566 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_567 = lean_array_push(x_565, x_566); x_568 = lean_array_push(x_567, x_566); -x_569 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_569 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_570 = lean_array_push(x_568, x_569); x_571 = lean_array_push(x_570, x_17); x_572 = l_Lean_Parser_Term_letIdDecl___closed__2; x_573 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_573, 0, x_572); lean_ctor_set(x_573, 1, x_571); -x_574 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_574 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_575 = lean_array_push(x_574, x_573); -x_576 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_576 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_577 = lean_array_push(x_575, x_576); x_578 = lean_array_push(x_577, x_551); x_579 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -9336,9 +8896,9 @@ lean_inc(x_582); lean_inc(x_581); lean_dec(x_556); x_583 = lean_box(0); -x_584 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_584 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_585 = l_Lean_addMacroScope(x_581, x_584, x_554); -x_586 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_586 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_587 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_587, 0, x_583); lean_ctor_set(x_587, 1, x_586); @@ -9349,16 +8909,16 @@ x_589 = lean_array_push(x_588, x_587); x_590 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_591 = lean_array_push(x_589, x_590); x_592 = lean_array_push(x_591, x_590); -x_593 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_593 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_594 = lean_array_push(x_592, x_593); x_595 = lean_array_push(x_594, x_17); x_596 = l_Lean_Parser_Term_letIdDecl___closed__2; x_597 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_597, 0, x_596); lean_ctor_set(x_597, 1, x_595); -x_598 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_598 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_599 = lean_array_push(x_598, x_597); -x_600 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_600 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_601 = lean_array_push(x_599, x_600); x_602 = lean_array_push(x_601, x_551); x_603 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -9382,9 +8942,9 @@ lean_dec(x_549); x_608 = lean_ctor_get(x_550, 0); lean_inc(x_608); lean_dec(x_550); -x_609 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__11(x_25, x_21, x_526); +x_609 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__11(x_25, x_21, x_526); lean_dec(x_25); -x_610 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__7(x_609); +x_610 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__7(x_609); x_611 = !lean_is_exclusive(x_607); if (x_611 == 0) { @@ -9406,7 +8966,7 @@ lean_ctor_set(x_614, 9, x_612); lean_ctor_set_uint8(x_614, sizeof(void*)*10, x_545); lean_ctor_set_uint8(x_614, sizeof(void*)*10 + 1, x_546); lean_ctor_set_uint8(x_614, sizeof(void*)*10 + 2, x_547); -x_615 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_2, x_610, x_614, x_607); +x_615 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_2, x_610, x_614, x_607); if (lean_obj_tag(x_615) == 0) { lean_object* x_616; lean_object* x_617; lean_object* x_618; lean_object* x_619; lean_object* x_620; lean_object* x_621; lean_object* x_622; lean_object* x_623; lean_object* x_624; lean_object* x_625; lean_object* x_626; lean_object* x_627; lean_object* x_628; lean_object* x_629; lean_object* x_630; lean_object* x_631; lean_object* x_632; lean_object* x_633; lean_object* x_634; lean_object* x_635; lean_object* x_636; lean_object* x_637; lean_object* x_638; lean_object* x_639; lean_object* x_640; lean_object* x_641; lean_object* x_642; lean_object* x_643; lean_object* x_644; lean_object* x_645; lean_object* x_646; lean_object* x_647; lean_object* x_648; lean_object* x_649; lean_object* x_650; lean_object* x_651; lean_object* x_652; lean_object* x_653; lean_object* x_654; lean_object* x_655; lean_object* x_656; lean_object* x_657; lean_object* x_658; lean_object* x_659; lean_object* x_660; lean_object* x_661; lean_object* x_662; lean_object* x_663; lean_object* x_664; lean_object* x_665; lean_object* x_666; lean_object* x_667; lean_object* x_668; lean_object* x_669; lean_object* x_670; lean_object* x_671; lean_object* x_672; lean_object* x_673; lean_object* x_674; lean_object* x_675; lean_object* x_676; lean_object* x_677; lean_object* x_678; lean_object* x_679; lean_object* x_680; lean_object* x_681; lean_object* x_682; lean_object* x_683; lean_object* x_684; lean_object* x_685; lean_object* x_686; lean_object* x_687; lean_object* x_688; lean_object* x_689; lean_object* x_690; lean_object* x_691; lean_object* x_692; lean_object* x_693; lean_object* x_694; lean_object* x_695; lean_object* x_696; lean_object* x_697; lean_object* x_698; lean_object* x_699; lean_object* x_700; lean_object* x_701; lean_object* x_702; lean_object* x_703; lean_object* x_704; lean_object* x_705; lean_object* x_706; lean_object* x_707; lean_object* x_708; uint8_t x_709; @@ -9428,12 +8988,12 @@ x_623 = lean_ctor_get(x_621, 1); lean_inc(x_623); lean_dec(x_621); x_624 = lean_box(0); -x_625 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8; +x_625 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8; lean_inc(x_619); lean_inc(x_622); x_626 = l_Lean_addMacroScope(x_622, x_625, x_619); -x_627 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6; -x_628 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11; +x_627 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6; +x_628 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11; x_629 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_629, 0, x_624); lean_ctor_set(x_629, 1, x_627); @@ -9448,11 +9008,11 @@ x_635 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_635, 0, x_634); lean_ctor_set(x_635, 1, x_633); x_636 = lean_array_push(x_630, x_635); -x_637 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_637 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; lean_inc(x_619); lean_inc(x_622); x_638 = l_Lean_addMacroScope(x_622, x_637, x_619); -x_639 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_639 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_640 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_640, 0, x_624); lean_ctor_set(x_640, 1, x_639); @@ -9464,7 +9024,7 @@ x_643 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_643, 0, x_634); lean_ctor_set(x_643, 1, x_642); x_644 = lean_array_push(x_630, x_643); -x_645 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_608); +x_645 = l___private_Init_Lean_Syntax_7__quoteName___main(x_608); lean_inc(x_644); x_646 = lean_array_push(x_644, x_645); x_647 = l_Lean_nullKind___closed__2; @@ -9477,14 +9037,14 @@ x_651 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_651, 0, x_650); lean_ctor_set(x_651, 1, x_649); x_652 = lean_array_push(x_630, x_651); -x_653 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__26; +x_653 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__26; x_654 = lean_array_push(x_652, x_653); -x_655 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__31; +x_655 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__31; lean_inc(x_619); lean_inc(x_622); x_656 = l_Lean_addMacroScope(x_622, x_655, x_619); -x_657 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__29; -x_658 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__33; +x_657 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__29; +x_658 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__33; x_659 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_659, 0, x_624); lean_ctor_set(x_659, 1, x_657); @@ -9496,10 +9056,10 @@ x_662 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_662, 0, x_634); lean_ctor_set(x_662, 1, x_661); x_663 = lean_array_push(x_630, x_662); -x_664 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5; +x_664 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5; x_665 = l_Lean_addMacroScope(x_622, x_664, x_619); -x_666 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3; -x_667 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__36; +x_666 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3; +x_667 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__36; x_668 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_668, 0, x_624); lean_ctor_set(x_668, 1, x_666); @@ -9523,9 +9083,9 @@ x_677 = lean_array_push(x_676, x_632); x_678 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_678, 0, x_647); lean_ctor_set(x_678, 1, x_677); -x_679 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_679 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_680 = lean_array_push(x_679, x_678); -x_681 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_681 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_682 = lean_array_push(x_680, x_681); x_683 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_684 = lean_alloc_ctor(1, 2, 0); @@ -9540,14 +9100,14 @@ x_688 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_688, 0, x_650); lean_ctor_set(x_688, 1, x_687); x_689 = lean_array_push(x_630, x_688); -x_690 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__38; +x_690 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__38; x_691 = lean_array_push(x_689, x_690); x_692 = l_Nat_repr(x_521); x_693 = l_Lean_numLitKind; x_694 = l_Lean_mkStxLit(x_693, x_692, x_624); x_695 = l_Lean_mkOptionalNode___closed__2; x_696 = lean_array_push(x_695, x_694); -x_697 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_697 = l_Lean_Nat_HasQuote___closed__2; x_698 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_698, 0, x_697); lean_ctor_set(x_698, 1, x_696); @@ -9585,24 +9145,24 @@ lean_ctor_set(x_712, 3, x_526); x_713 = lean_array_push(x_630, x_712); x_714 = lean_array_push(x_713, x_632); x_715 = lean_array_push(x_714, x_632); -x_716 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_716 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_717 = lean_array_push(x_715, x_716); x_718 = lean_array_push(x_717, x_17); x_719 = l_Lean_Parser_Term_letIdDecl___closed__2; x_720 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_720, 0, x_719); lean_ctor_set(x_720, 1, x_718); -x_721 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_721 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_722 = lean_array_push(x_721, x_720); -x_723 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_723 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_724 = lean_array_push(x_722, x_723); x_725 = lean_array_push(x_630, x_704); -x_726 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15; +x_726 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15; x_727 = lean_array_push(x_725, x_726); -x_728 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18; +x_728 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18; x_729 = l_Lean_addMacroScope(x_710, x_728, x_706); -x_730 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17; -x_731 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20; +x_730 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17; +x_731 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20; x_732 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_732, 0, x_624); lean_ctor_set(x_732, 1, x_730); @@ -9618,12 +9178,12 @@ x_737 = l_Lean_Parser_Term_eq___elambda__1___closed__2; x_738 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_738, 0, x_737); lean_ctor_set(x_738, 1, x_736); -x_739 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14; +x_739 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14; x_740 = lean_array_push(x_739, x_738); -x_741 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22; +x_741 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22; x_742 = lean_array_push(x_740, x_741); x_743 = lean_array_push(x_742, x_606); -x_744 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24; +x_744 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24; x_745 = lean_array_push(x_743, x_744); x_746 = lean_array_push(x_745, x_616); x_747 = l_Lean_Parser_Term_if___elambda__1___closed__2; @@ -9657,24 +9217,24 @@ lean_ctor_set(x_755, 3, x_526); x_756 = lean_array_push(x_630, x_755); x_757 = lean_array_push(x_756, x_632); x_758 = lean_array_push(x_757, x_632); -x_759 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_759 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_760 = lean_array_push(x_758, x_759); x_761 = lean_array_push(x_760, x_17); x_762 = l_Lean_Parser_Term_letIdDecl___closed__2; x_763 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_763, 0, x_762); lean_ctor_set(x_763, 1, x_761); -x_764 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_764 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_765 = lean_array_push(x_764, x_763); -x_766 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_766 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_767 = lean_array_push(x_765, x_766); x_768 = lean_array_push(x_630, x_704); -x_769 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15; +x_769 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15; x_770 = lean_array_push(x_768, x_769); -x_771 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18; +x_771 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18; x_772 = l_Lean_addMacroScope(x_752, x_771, x_706); -x_773 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17; -x_774 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20; +x_773 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17; +x_774 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20; x_775 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_775, 0, x_624); lean_ctor_set(x_775, 1, x_773); @@ -9690,12 +9250,12 @@ x_780 = l_Lean_Parser_Term_eq___elambda__1___closed__2; x_781 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_781, 0, x_780); lean_ctor_set(x_781, 1, x_779); -x_782 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14; +x_782 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14; x_783 = lean_array_push(x_782, x_781); -x_784 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22; +x_784 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22; x_785 = lean_array_push(x_783, x_784); x_786 = lean_array_push(x_785, x_606); -x_787 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24; +x_787 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24; x_788 = lean_array_push(x_786, x_787); x_789 = lean_array_push(x_788, x_616); x_790 = l_Lean_Parser_Term_if___elambda__1___closed__2; @@ -9779,7 +9339,7 @@ lean_ctor_set(x_808, 9, x_805); lean_ctor_set_uint8(x_808, sizeof(void*)*10, x_545); lean_ctor_set_uint8(x_808, sizeof(void*)*10 + 1, x_546); lean_ctor_set_uint8(x_808, sizeof(void*)*10 + 2, x_547); -x_809 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_2, x_610, x_808, x_807); +x_809 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_2, x_610, x_808, x_807); if (lean_obj_tag(x_809) == 0) { lean_object* x_810; lean_object* x_811; lean_object* x_812; lean_object* x_813; lean_object* x_814; lean_object* x_815; lean_object* x_816; lean_object* x_817; lean_object* x_818; lean_object* x_819; lean_object* x_820; lean_object* x_821; lean_object* x_822; lean_object* x_823; lean_object* x_824; lean_object* x_825; lean_object* x_826; lean_object* x_827; lean_object* x_828; lean_object* x_829; lean_object* x_830; lean_object* x_831; lean_object* x_832; lean_object* x_833; lean_object* x_834; lean_object* x_835; lean_object* x_836; lean_object* x_837; lean_object* x_838; lean_object* x_839; lean_object* x_840; lean_object* x_841; lean_object* x_842; lean_object* x_843; lean_object* x_844; lean_object* x_845; lean_object* x_846; lean_object* x_847; lean_object* x_848; lean_object* x_849; lean_object* x_850; lean_object* x_851; lean_object* x_852; lean_object* x_853; lean_object* x_854; lean_object* x_855; lean_object* x_856; lean_object* x_857; lean_object* x_858; lean_object* x_859; lean_object* x_860; lean_object* x_861; lean_object* x_862; lean_object* x_863; lean_object* x_864; lean_object* x_865; lean_object* x_866; lean_object* x_867; lean_object* x_868; lean_object* x_869; lean_object* x_870; lean_object* x_871; lean_object* x_872; lean_object* x_873; lean_object* x_874; lean_object* x_875; lean_object* x_876; lean_object* x_877; lean_object* x_878; lean_object* x_879; lean_object* x_880; lean_object* x_881; lean_object* x_882; lean_object* x_883; lean_object* x_884; lean_object* x_885; lean_object* x_886; lean_object* x_887; lean_object* x_888; lean_object* x_889; lean_object* x_890; lean_object* x_891; lean_object* x_892; lean_object* x_893; lean_object* x_894; lean_object* x_895; lean_object* x_896; lean_object* x_897; lean_object* x_898; lean_object* x_899; lean_object* x_900; lean_object* x_901; lean_object* x_902; lean_object* x_903; lean_object* x_904; lean_object* x_905; lean_object* x_906; lean_object* x_907; lean_object* x_908; lean_object* x_909; lean_object* x_910; lean_object* x_911; lean_object* x_912; lean_object* x_913; lean_object* x_914; lean_object* x_915; lean_object* x_916; lean_object* x_917; lean_object* x_918; lean_object* x_919; lean_object* x_920; lean_object* x_921; lean_object* x_922; lean_object* x_923; lean_object* x_924; lean_object* x_925; lean_object* x_926; lean_object* x_927; lean_object* x_928; lean_object* x_929; lean_object* x_930; lean_object* x_931; lean_object* x_932; lean_object* x_933; lean_object* x_934; lean_object* x_935; lean_object* x_936; lean_object* x_937; lean_object* x_938; lean_object* x_939; lean_object* x_940; lean_object* x_941; lean_object* x_942; lean_object* x_943; lean_object* x_944; lean_object* x_945; lean_object* x_946; lean_object* x_947; @@ -9801,12 +9361,12 @@ x_817 = lean_ctor_get(x_815, 1); lean_inc(x_817); lean_dec(x_815); x_818 = lean_box(0); -x_819 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8; +x_819 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8; lean_inc(x_813); lean_inc(x_816); x_820 = l_Lean_addMacroScope(x_816, x_819, x_813); -x_821 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6; -x_822 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11; +x_821 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6; +x_822 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11; x_823 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_823, 0, x_818); lean_ctor_set(x_823, 1, x_821); @@ -9821,11 +9381,11 @@ x_829 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_829, 0, x_828); lean_ctor_set(x_829, 1, x_827); x_830 = lean_array_push(x_824, x_829); -x_831 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_831 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; lean_inc(x_813); lean_inc(x_816); x_832 = l_Lean_addMacroScope(x_816, x_831, x_813); -x_833 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_833 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_834 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_834, 0, x_818); lean_ctor_set(x_834, 1, x_833); @@ -9837,7 +9397,7 @@ x_837 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_837, 0, x_828); lean_ctor_set(x_837, 1, x_836); x_838 = lean_array_push(x_824, x_837); -x_839 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_608); +x_839 = l___private_Init_Lean_Syntax_7__quoteName___main(x_608); lean_inc(x_838); x_840 = lean_array_push(x_838, x_839); x_841 = l_Lean_nullKind___closed__2; @@ -9850,14 +9410,14 @@ x_845 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_845, 0, x_844); lean_ctor_set(x_845, 1, x_843); x_846 = lean_array_push(x_824, x_845); -x_847 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__26; +x_847 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__26; x_848 = lean_array_push(x_846, x_847); -x_849 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__31; +x_849 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__31; lean_inc(x_813); lean_inc(x_816); x_850 = l_Lean_addMacroScope(x_816, x_849, x_813); -x_851 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__29; -x_852 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__33; +x_851 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__29; +x_852 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__33; x_853 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_853, 0, x_818); lean_ctor_set(x_853, 1, x_851); @@ -9869,10 +9429,10 @@ x_856 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_856, 0, x_828); lean_ctor_set(x_856, 1, x_855); x_857 = lean_array_push(x_824, x_856); -x_858 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5; +x_858 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5; x_859 = l_Lean_addMacroScope(x_816, x_858, x_813); -x_860 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3; -x_861 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__36; +x_860 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3; +x_861 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__36; x_862 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_862, 0, x_818); lean_ctor_set(x_862, 1, x_860); @@ -9896,9 +9456,9 @@ x_871 = lean_array_push(x_870, x_826); x_872 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_872, 0, x_841); lean_ctor_set(x_872, 1, x_871); -x_873 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_873 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_874 = lean_array_push(x_873, x_872); -x_875 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_875 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_876 = lean_array_push(x_874, x_875); x_877 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_878 = lean_alloc_ctor(1, 2, 0); @@ -9913,14 +9473,14 @@ x_882 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_882, 0, x_844); lean_ctor_set(x_882, 1, x_881); x_883 = lean_array_push(x_824, x_882); -x_884 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__38; +x_884 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__38; x_885 = lean_array_push(x_883, x_884); x_886 = l_Nat_repr(x_521); x_887 = l_Lean_numLitKind; x_888 = l_Lean_mkStxLit(x_887, x_886, x_818); x_889 = l_Lean_mkOptionalNode___closed__2; x_890 = lean_array_push(x_889, x_888); -x_891 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_891 = l_Lean_Nat_HasQuote___closed__2; x_892 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_892, 0, x_891); lean_ctor_set(x_892, 1, x_890); @@ -9965,24 +9525,24 @@ lean_ctor_set(x_907, 3, x_526); x_908 = lean_array_push(x_824, x_907); x_909 = lean_array_push(x_908, x_826); x_910 = lean_array_push(x_909, x_826); -x_911 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_911 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_912 = lean_array_push(x_910, x_911); x_913 = lean_array_push(x_912, x_17); x_914 = l_Lean_Parser_Term_letIdDecl___closed__2; x_915 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_915, 0, x_914); lean_ctor_set(x_915, 1, x_913); -x_916 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_916 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_917 = lean_array_push(x_916, x_915); -x_918 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_918 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_919 = lean_array_push(x_917, x_918); x_920 = lean_array_push(x_824, x_898); -x_921 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15; +x_921 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15; x_922 = lean_array_push(x_920, x_921); -x_923 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18; +x_923 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18; x_924 = l_Lean_addMacroScope(x_903, x_923, x_900); -x_925 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17; -x_926 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20; +x_925 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17; +x_926 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20; x_927 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_927, 0, x_818); lean_ctor_set(x_927, 1, x_925); @@ -9998,12 +9558,12 @@ x_932 = l_Lean_Parser_Term_eq___elambda__1___closed__2; x_933 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_933, 0, x_932); lean_ctor_set(x_933, 1, x_931); -x_934 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14; +x_934 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14; x_935 = lean_array_push(x_934, x_933); -x_936 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22; +x_936 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22; x_937 = lean_array_push(x_935, x_936); x_938 = lean_array_push(x_937, x_606); -x_939 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24; +x_939 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24; x_940 = lean_array_push(x_938, x_939); x_941 = lean_array_push(x_940, x_810); x_942 = l_Lean_Parser_Term_if___elambda__1___closed__2; @@ -10163,7 +9723,7 @@ lean_ctor_set(x_977, 9, x_961); lean_ctor_set_uint8(x_977, sizeof(void*)*10, x_974); lean_ctor_set_uint8(x_977, sizeof(void*)*10 + 1, x_975); lean_ctor_set_uint8(x_977, sizeof(void*)*10 + 2, x_976); -x_978 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_531, x_529, x_977, x_964); +x_978 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_531, x_529, x_977, x_964); if (lean_obj_tag(x_978) == 0) { lean_object* x_979; @@ -10211,9 +9771,9 @@ if (lean_is_exclusive(x_985)) { x_988 = lean_box(0); } x_989 = lean_box(0); -x_990 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_990 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; x_991 = l_Lean_addMacroScope(x_986, x_990, x_983); -x_992 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_992 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_993 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_993, 0, x_989); lean_ctor_set(x_993, 1, x_992); @@ -10224,16 +9784,16 @@ x_995 = lean_array_push(x_994, x_993); x_996 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_997 = lean_array_push(x_995, x_996); x_998 = lean_array_push(x_997, x_996); -x_999 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_999 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_1000 = lean_array_push(x_998, x_999); x_1001 = lean_array_push(x_1000, x_17); x_1002 = l_Lean_Parser_Term_letIdDecl___closed__2; x_1003 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1003, 0, x_1002); lean_ctor_set(x_1003, 1, x_1001); -x_1004 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_1004 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_1005 = lean_array_push(x_1004, x_1003); -x_1006 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_1006 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_1007 = lean_array_push(x_1005, x_1006); x_1008 = lean_array_push(x_1007, x_980); x_1009 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -10260,9 +9820,9 @@ lean_dec(x_978); x_1014 = lean_ctor_get(x_979, 0); lean_inc(x_1014); lean_dec(x_979); -x_1015 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__11(x_25, x_21, x_526); +x_1015 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__11(x_25, x_21, x_526); lean_dec(x_25); -x_1016 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__7(x_1015); +x_1016 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__7(x_1015); x_1017 = lean_ctor_get(x_1013, 0); lean_inc(x_1017); x_1018 = lean_ctor_get(x_1013, 1); @@ -10313,7 +9873,7 @@ lean_ctor_set(x_1026, 9, x_1022); lean_ctor_set_uint8(x_1026, sizeof(void*)*10, x_974); lean_ctor_set_uint8(x_1026, sizeof(void*)*10 + 1, x_975); lean_ctor_set_uint8(x_1026, sizeof(void*)*10 + 2, x_976); -x_1027 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_2, x_1016, x_1026, x_1025); +x_1027 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_2, x_1016, x_1026, x_1025); if (lean_obj_tag(x_1027) == 0) { lean_object* x_1028; lean_object* x_1029; lean_object* x_1030; lean_object* x_1031; lean_object* x_1032; lean_object* x_1033; lean_object* x_1034; lean_object* x_1035; lean_object* x_1036; lean_object* x_1037; lean_object* x_1038; lean_object* x_1039; lean_object* x_1040; lean_object* x_1041; lean_object* x_1042; lean_object* x_1043; lean_object* x_1044; lean_object* x_1045; lean_object* x_1046; lean_object* x_1047; lean_object* x_1048; lean_object* x_1049; lean_object* x_1050; lean_object* x_1051; lean_object* x_1052; lean_object* x_1053; lean_object* x_1054; lean_object* x_1055; lean_object* x_1056; lean_object* x_1057; lean_object* x_1058; lean_object* x_1059; lean_object* x_1060; lean_object* x_1061; lean_object* x_1062; lean_object* x_1063; lean_object* x_1064; lean_object* x_1065; lean_object* x_1066; lean_object* x_1067; lean_object* x_1068; lean_object* x_1069; lean_object* x_1070; lean_object* x_1071; lean_object* x_1072; lean_object* x_1073; lean_object* x_1074; lean_object* x_1075; lean_object* x_1076; lean_object* x_1077; lean_object* x_1078; lean_object* x_1079; lean_object* x_1080; lean_object* x_1081; lean_object* x_1082; lean_object* x_1083; lean_object* x_1084; lean_object* x_1085; lean_object* x_1086; lean_object* x_1087; lean_object* x_1088; lean_object* x_1089; lean_object* x_1090; lean_object* x_1091; lean_object* x_1092; lean_object* x_1093; lean_object* x_1094; lean_object* x_1095; lean_object* x_1096; lean_object* x_1097; lean_object* x_1098; lean_object* x_1099; lean_object* x_1100; lean_object* x_1101; lean_object* x_1102; lean_object* x_1103; lean_object* x_1104; lean_object* x_1105; lean_object* x_1106; lean_object* x_1107; lean_object* x_1108; lean_object* x_1109; lean_object* x_1110; lean_object* x_1111; lean_object* x_1112; lean_object* x_1113; lean_object* x_1114; lean_object* x_1115; lean_object* x_1116; lean_object* x_1117; lean_object* x_1118; lean_object* x_1119; lean_object* x_1120; lean_object* x_1121; lean_object* x_1122; lean_object* x_1123; lean_object* x_1124; lean_object* x_1125; lean_object* x_1126; lean_object* x_1127; lean_object* x_1128; lean_object* x_1129; lean_object* x_1130; lean_object* x_1131; lean_object* x_1132; lean_object* x_1133; lean_object* x_1134; lean_object* x_1135; lean_object* x_1136; lean_object* x_1137; lean_object* x_1138; lean_object* x_1139; lean_object* x_1140; lean_object* x_1141; lean_object* x_1142; lean_object* x_1143; lean_object* x_1144; lean_object* x_1145; lean_object* x_1146; lean_object* x_1147; lean_object* x_1148; lean_object* x_1149; lean_object* x_1150; lean_object* x_1151; lean_object* x_1152; lean_object* x_1153; lean_object* x_1154; lean_object* x_1155; lean_object* x_1156; lean_object* x_1157; lean_object* x_1158; lean_object* x_1159; lean_object* x_1160; lean_object* x_1161; lean_object* x_1162; lean_object* x_1163; lean_object* x_1164; lean_object* x_1165; @@ -10335,12 +9895,12 @@ x_1035 = lean_ctor_get(x_1033, 1); lean_inc(x_1035); lean_dec(x_1033); x_1036 = lean_box(0); -x_1037 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8; +x_1037 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8; lean_inc(x_1031); lean_inc(x_1034); x_1038 = l_Lean_addMacroScope(x_1034, x_1037, x_1031); -x_1039 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6; -x_1040 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11; +x_1039 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6; +x_1040 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11; x_1041 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_1041, 0, x_1036); lean_ctor_set(x_1041, 1, x_1039); @@ -10355,11 +9915,11 @@ x_1047 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1047, 0, x_1046); lean_ctor_set(x_1047, 1, x_1045); x_1048 = lean_array_push(x_1042, x_1047); -x_1049 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8; +x_1049 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8; lean_inc(x_1031); lean_inc(x_1034); x_1050 = l_Lean_addMacroScope(x_1034, x_1049, x_1031); -x_1051 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7; +x_1051 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7; x_1052 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_1052, 0, x_1036); lean_ctor_set(x_1052, 1, x_1051); @@ -10371,7 +9931,7 @@ x_1055 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1055, 0, x_1046); lean_ctor_set(x_1055, 1, x_1054); x_1056 = lean_array_push(x_1042, x_1055); -x_1057 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_1014); +x_1057 = l___private_Init_Lean_Syntax_7__quoteName___main(x_1014); lean_inc(x_1056); x_1058 = lean_array_push(x_1056, x_1057); x_1059 = l_Lean_nullKind___closed__2; @@ -10384,14 +9944,14 @@ x_1063 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1063, 0, x_1062); lean_ctor_set(x_1063, 1, x_1061); x_1064 = lean_array_push(x_1042, x_1063); -x_1065 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__26; +x_1065 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__26; x_1066 = lean_array_push(x_1064, x_1065); -x_1067 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__31; +x_1067 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__31; lean_inc(x_1031); lean_inc(x_1034); x_1068 = l_Lean_addMacroScope(x_1034, x_1067, x_1031); -x_1069 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__29; -x_1070 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__33; +x_1069 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__29; +x_1070 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__33; x_1071 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_1071, 0, x_1036); lean_ctor_set(x_1071, 1, x_1069); @@ -10403,10 +9963,10 @@ x_1074 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1074, 0, x_1046); lean_ctor_set(x_1074, 1, x_1073); x_1075 = lean_array_push(x_1042, x_1074); -x_1076 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5; +x_1076 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5; x_1077 = l_Lean_addMacroScope(x_1034, x_1076, x_1031); -x_1078 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3; -x_1079 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__36; +x_1078 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3; +x_1079 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__36; x_1080 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_1080, 0, x_1036); lean_ctor_set(x_1080, 1, x_1078); @@ -10430,9 +9990,9 @@ x_1089 = lean_array_push(x_1088, x_1044); x_1090 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1090, 0, x_1059); lean_ctor_set(x_1090, 1, x_1089); -x_1091 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_1091 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_1092 = lean_array_push(x_1091, x_1090); -x_1093 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_1093 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_1094 = lean_array_push(x_1092, x_1093); x_1095 = l_Lean_Parser_Term_paren___elambda__1___closed__1; x_1096 = lean_alloc_ctor(1, 2, 0); @@ -10447,14 +10007,14 @@ x_1100 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1100, 0, x_1062); lean_ctor_set(x_1100, 1, x_1099); x_1101 = lean_array_push(x_1042, x_1100); -x_1102 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__38; +x_1102 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__38; x_1103 = lean_array_push(x_1101, x_1102); x_1104 = l_Nat_repr(x_521); x_1105 = l_Lean_numLitKind; x_1106 = l_Lean_mkStxLit(x_1105, x_1104, x_1036); x_1107 = l_Lean_mkOptionalNode___closed__2; x_1108 = lean_array_push(x_1107, x_1106); -x_1109 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_1109 = l_Lean_Nat_HasQuote___closed__2; x_1110 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1110, 0, x_1109); lean_ctor_set(x_1110, 1, x_1108); @@ -10499,24 +10059,24 @@ lean_ctor_set(x_1125, 3, x_526); x_1126 = lean_array_push(x_1042, x_1125); x_1127 = lean_array_push(x_1126, x_1044); x_1128 = lean_array_push(x_1127, x_1044); -x_1129 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_1129 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_1130 = lean_array_push(x_1128, x_1129); x_1131 = lean_array_push(x_1130, x_17); x_1132 = l_Lean_Parser_Term_letIdDecl___closed__2; x_1133 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1133, 0, x_1132); lean_ctor_set(x_1133, 1, x_1131); -x_1134 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_1134 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_1135 = lean_array_push(x_1134, x_1133); -x_1136 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_1136 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_1137 = lean_array_push(x_1135, x_1136); x_1138 = lean_array_push(x_1042, x_1116); -x_1139 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15; +x_1139 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15; x_1140 = lean_array_push(x_1138, x_1139); -x_1141 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18; +x_1141 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18; x_1142 = l_Lean_addMacroScope(x_1121, x_1141, x_1118); -x_1143 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17; -x_1144 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20; +x_1143 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17; +x_1144 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20; x_1145 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_1145, 0, x_1036); lean_ctor_set(x_1145, 1, x_1143); @@ -10532,12 +10092,12 @@ x_1150 = l_Lean_Parser_Term_eq___elambda__1___closed__2; x_1151 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1151, 0, x_1150); lean_ctor_set(x_1151, 1, x_1149); -x_1152 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14; +x_1152 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14; x_1153 = lean_array_push(x_1152, x_1151); -x_1154 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22; +x_1154 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22; x_1155 = lean_array_push(x_1153, x_1154); x_1156 = lean_array_push(x_1155, x_1012); -x_1157 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24; +x_1157 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24; x_1158 = lean_array_push(x_1156, x_1157); x_1159 = lean_array_push(x_1158, x_1028); x_1160 = l_Lean_Parser_Term_if___elambda__1___closed__2; @@ -10665,106 +10225,106 @@ return x_1177; } } } -lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___boxed(lean_object* x_1) { +lean_object* l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___boxed(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2(x_1); +x_2 = l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2(x_1); lean_dec(x_1); return x_2; } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__3___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__3___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__3(x_1, x_2); +x_3 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__3(x_1, x_2); lean_dec(x_2); lean_dec(x_1); return x_3; } } -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__4(x_1, x_2, x_3); +x_4 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__4(x_1, x_2, x_3); lean_dec(x_1); return x_4; } } -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__6(x_1, x_2, x_3); +x_4 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__6(x_1, x_2, x_3); lean_dec(x_1); return x_4; } } -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8(x_1, x_2, x_3); +x_4 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8(x_1, x_2, x_3); lean_dec(x_2); return x_4; } } -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__9___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__9___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__9(x_1, x_2, x_3); +x_4 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__9(x_1, x_2, x_3); lean_dec(x_1); return x_4; } } -lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__10___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__10___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_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__10(x_1, x_2, x_3, x_4); +x_5 = l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__10(x_1, x_2, x_3, x_4); lean_dec(x_1); return x_5; } } -lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__11___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__11___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__11(x_1, x_2, x_3); +x_4 = l_List_filterAux___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__11(x_1, x_2, x_3); lean_dec(x_1); return x_4; } } -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { lean_object* x_6; -x_6 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_2, x_3, x_4, x_5); +x_6 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_2, x_3, x_4, x_5); lean_dec(x_1); return x_6; } } -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { lean_object* x_6; -x_6 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_2, x_3, x_4, x_5); +x_6 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_2, x_3, x_4, x_5); return x_6; } } -lean_object* l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { lean_object* x_6; -x_6 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch(x_1, x_2, x_3, x_4, x_5); +x_6 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch(x_1, x_2, x_3, x_4, x_5); lean_dec(x_1); return x_6; } } -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main___spec__1(lean_object* x_1) { +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main___spec__1(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) @@ -10782,9 +10342,9 @@ if (x_3 == 0) lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; x_4 = lean_ctor_get(x_1, 0); x_5 = lean_ctor_get(x_1, 1); -x_6 = l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main(x_4); +x_6 = l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main(x_4); lean_dec(x_4); -x_7 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main___spec__1(x_5); +x_7 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main___spec__1(x_5); lean_ctor_set(x_1, 1, x_7); lean_ctor_set(x_1, 0, x_6); return x_1; @@ -10797,9 +10357,9 @@ x_9 = lean_ctor_get(x_1, 1); lean_inc(x_9); lean_inc(x_8); lean_dec(x_1); -x_10 = l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main(x_8); +x_10 = l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main(x_8); lean_dec(x_8); -x_11 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main___spec__1(x_9); +x_11 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main___spec__1(x_9); x_12 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_12, 0, x_10); lean_ctor_set(x_12, 1, x_11); @@ -10808,7 +10368,7 @@ return x_12; } } } -lean_object* l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main(lean_object* x_1) { +lean_object* l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 1) @@ -10820,7 +10380,7 @@ if (x_3 == 0) { lean_object* x_4; lean_object* x_5; lean_object* x_6; x_4 = l_Array_toList___rarg(x_2); -x_5 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main___spec__1(x_4); +x_5 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main___spec__1(x_4); x_6 = l_List_join___main___rarg(x_5); return x_6; } @@ -10856,7 +10416,7 @@ else { lean_object* x_14; lean_object* x_15; lean_object* x_16; x_14 = l_Array_toList___rarg(x_2); -x_15 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main___spec__1(x_14); +x_15 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main___spec__1(x_14); x_16 = l_List_join___main___rarg(x_15); return x_16; } @@ -10870,28 +10430,28 @@ return x_17; } } } -lean_object* l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main___boxed(lean_object* x_1) { +lean_object* l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main___boxed(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main(x_1); +x_2 = l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main(x_1); lean_dec(x_1); return x_2; } } -lean_object* l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux(lean_object* x_1) { +lean_object* l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main(x_1); +x_2 = l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main(x_1); return x_2; } } -lean_object* l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___boxed(lean_object* x_1) { +lean_object* l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___boxed(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux(x_1); +x_2 = l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux(x_1); lean_dec(x_1); return x_2; } @@ -10929,13 +10489,13 @@ return x_8; else { lean_object* x_9; -x_9 = l___private_Init_Lean_Elab_Quotation_10__getPatternVarsAux___main(x_1); +x_9 = l___private_Init_Lean_Elab_Quotation_7__getPatternVarsAux___main(x_1); lean_dec(x_1); return x_9; } } } -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___spec__1(lean_object* x_1) { +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___spec__1(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) @@ -10954,7 +10514,7 @@ lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; x_4 = lean_ctor_get(x_1, 0); x_5 = lean_ctor_get(x_1, 1); x_6 = l_Lean_Elab_Term_Quotation_getPatternVars(x_4); -x_7 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___spec__1(x_5); +x_7 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___spec__1(x_5); lean_ctor_set(x_1, 1, x_7); lean_ctor_set(x_1, 0, x_6); return x_1; @@ -10968,7 +10528,7 @@ lean_inc(x_9); lean_inc(x_8); lean_dec(x_1); x_10 = l_Lean_Elab_Term_Quotation_getPatternVars(x_8); -x_11 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___spec__1(x_9); +x_11 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___spec__1(x_9); x_12 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_12, 0, x_10); lean_ctor_set(x_12, 1, x_11); @@ -10977,7 +10537,7 @@ return x_12; } } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__1() { _start: { lean_object* x_1; @@ -10985,22 +10545,22 @@ x_1 = lean_mk_string("rhs"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__1; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__2; +x_3 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__2; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -11008,113 +10568,113 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__1; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__5() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__5() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_1 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_2 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__6() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__6() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__5; -x_2 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_1 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__5; +x_2 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__7() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Term_paren___elambda__1___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__6; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__6; 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___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__8() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__8() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_empty___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__7; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__7; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__9() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__9() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_nullKind___closed__2; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__8; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__8; 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___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__10() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__10() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_empty___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__3; +x_2 = l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__3; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_nullKind___closed__2; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__10; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__10; 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___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__12() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__12() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Elab_Term_expandCDot_x3f___closed__2; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__12; +x_1 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__12; x_2 = l_Lean_Elab_Term_expandCDot_x3f___closed__3; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__14() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__14() { _start: { lean_object* x_1; lean_object* x_2; @@ -11123,7 +10683,7 @@ x_2 = l_Lean_mkAtom(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__15() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__15() { _start: { lean_object* x_1; lean_object* x_2; @@ -11132,17 +10692,17 @@ x_2 = l_Lean_mkAtom(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__16() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__16() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_PersistentHashMap_mkCollisionNode___rarg___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__14; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__14; x_3 = lean_array_push(x_1, x_2); return x_3; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -11154,7 +10714,7 @@ lean_ctor_set(x_3, 1, x_2); return x_3; } } -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { if (lean_obj_tag(x_2) == 0) @@ -11180,7 +10740,7 @@ x_11 = lean_ctor_get(x_2, 1); x_12 = lean_ctor_get(x_9, 0); x_13 = lean_ctor_get(x_9, 1); lean_inc(x_12); -x_14 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___spec__1(x_12); +x_14 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___spec__1(x_12); x_15 = l_List_join___main___rarg(x_14); if (lean_obj_tag(x_15) == 0) { @@ -11198,10 +10758,10 @@ x_21 = lean_ctor_get(x_19, 1); lean_inc(x_21); lean_dec(x_19); x_22 = lean_box(0); -x_23 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4; +x_23 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4; x_24 = l_Lean_addMacroScope(x_20, x_23, x_17); x_25 = lean_box(0); -x_26 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3; +x_26 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3; x_27 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_27, 0, x_22); lean_ctor_set(x_27, 1, x_26); @@ -11216,7 +10776,7 @@ x_33 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_33, 0, x_32); lean_ctor_set(x_33, 1, x_31); x_34 = lean_array_push(x_28, x_33); -x_35 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__9; +x_35 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__9; x_36 = lean_array_push(x_34, x_35); x_37 = l_Lean_mkAppStx___closed__8; x_38 = lean_alloc_ctor(1, 2, 0); @@ -11267,7 +10827,7 @@ lean_ctor_set(x_55, 9, x_40); lean_ctor_set_uint8(x_55, sizeof(void*)*10, x_52); lean_ctor_set_uint8(x_55, sizeof(void*)*10 + 1, x_53); lean_ctor_set_uint8(x_55, sizeof(void*)*10 + 2, x_54); -x_56 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_11, x_2, x_55, x_21); +x_56 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_11, x_2, x_55, x_21); 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; lean_object* x_62; uint8_t x_63; @@ -11298,9 +10858,9 @@ lean_ctor_set(x_66, 3, x_25); x_67 = lean_array_push(x_28, x_66); x_68 = lean_array_push(x_67, x_30); x_69 = lean_array_push(x_68, x_30); -x_70 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_70 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_71 = lean_array_push(x_69, x_70); -x_72 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13; +x_72 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13; x_73 = lean_array_push(x_72, x_13); x_74 = l_Lean_Parser_Term_fun___elambda__1___closed__2; x_75 = lean_alloc_ctor(1, 2, 0); @@ -11311,9 +10871,9 @@ x_77 = l_Lean_Parser_Term_letIdDecl___closed__2; x_78 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_78, 0, x_77); lean_ctor_set(x_78, 1, x_76); -x_79 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_79 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_80 = lean_array_push(x_79, x_78); -x_81 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_81 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_82 = lean_array_push(x_80, x_81); x_83 = lean_array_push(x_82, x_57); x_84 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -11340,9 +10900,9 @@ lean_ctor_set(x_89, 3, x_25); x_90 = lean_array_push(x_28, x_89); x_91 = lean_array_push(x_90, x_30); x_92 = lean_array_push(x_91, x_30); -x_93 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_93 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_94 = lean_array_push(x_92, x_93); -x_95 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13; +x_95 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13; x_96 = lean_array_push(x_95, x_13); x_97 = l_Lean_Parser_Term_fun___elambda__1___closed__2; x_98 = lean_alloc_ctor(1, 2, 0); @@ -11353,9 +10913,9 @@ x_100 = l_Lean_Parser_Term_letIdDecl___closed__2; x_101 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_101, 0, x_100); lean_ctor_set(x_101, 1, x_99); -x_102 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_102 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_103 = lean_array_push(x_102, x_101); -x_104 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_104 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_105 = lean_array_push(x_103, x_104); x_106 = lean_array_push(x_105, x_57); x_107 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -11453,7 +11013,7 @@ lean_ctor_set(x_135, 9, x_119); lean_ctor_set_uint8(x_135, sizeof(void*)*10, x_132); lean_ctor_set_uint8(x_135, sizeof(void*)*10 + 1, x_133); lean_ctor_set_uint8(x_135, sizeof(void*)*10 + 2, x_134); -x_136 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_11, x_2, x_135, x_122); +x_136 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_11, x_2, x_135, x_122); if (lean_obj_tag(x_136) == 0) { lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; @@ -11491,9 +11051,9 @@ lean_ctor_set(x_147, 3, x_25); x_148 = lean_array_push(x_28, x_147); x_149 = lean_array_push(x_148, x_30); x_150 = lean_array_push(x_149, x_30); -x_151 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_151 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_152 = lean_array_push(x_150, x_151); -x_153 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13; +x_153 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13; x_154 = lean_array_push(x_153, x_13); x_155 = l_Lean_Parser_Term_fun___elambda__1___closed__2; x_156 = lean_alloc_ctor(1, 2, 0); @@ -11504,9 +11064,9 @@ x_158 = l_Lean_Parser_Term_letIdDecl___closed__2; x_159 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_159, 0, x_158); lean_ctor_set(x_159, 1, x_157); -x_160 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_160 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_161 = lean_array_push(x_160, x_159); -x_162 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_162 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_163 = lean_array_push(x_161, x_162); x_164 = lean_array_push(x_163, x_137); x_165 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -11571,9 +11131,9 @@ x_178 = l_Lean_nullKind___closed__2; x_179 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_179, 0, x_178); lean_ctor_set(x_179, 1, x_174); -x_180 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__16; +x_180 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__16; x_181 = lean_array_push(x_180, x_179); -x_182 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__15; +x_182 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__15; x_183 = lean_array_push(x_181, x_182); x_184 = lean_array_push(x_183, x_13); x_185 = l_Lean_Parser_Term_fun___elambda__1___closed__2; @@ -11593,10 +11153,10 @@ x_192 = lean_ctor_get(x_190, 1); lean_inc(x_192); lean_dec(x_190); x_193 = lean_box(0); -x_194 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4; +x_194 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4; x_195 = l_Lean_addMacroScope(x_191, x_194, x_188); x_196 = lean_box(0); -x_197 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3; +x_197 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3; x_198 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_198, 0, x_193); lean_ctor_set(x_198, 1, x_197); @@ -11604,7 +11164,7 @@ lean_ctor_set(x_198, 2, x_195); lean_ctor_set(x_198, 3, x_196); x_199 = l_Array_empty___closed__1; x_200 = lean_array_push(x_199, x_198); -x_201 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_201 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_202 = lean_array_push(x_200, x_201); x_203 = l_Lean_mkTermIdFromIdent___closed__2; x_204 = lean_alloc_ctor(1, 2, 0); @@ -11656,7 +11216,7 @@ lean_ctor_set(x_221, 9, x_206); lean_ctor_set_uint8(x_221, sizeof(void*)*10, x_218); lean_ctor_set_uint8(x_221, sizeof(void*)*10 + 1, x_219); lean_ctor_set_uint8(x_221, sizeof(void*)*10 + 2, x_220); -x_222 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_11, x_15, x_221, x_192); +x_222 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_11, x_15, x_221, x_192); if (lean_obj_tag(x_222) == 0) { lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; uint8_t x_229; @@ -11687,16 +11247,16 @@ lean_ctor_set(x_232, 3, x_196); x_233 = lean_array_push(x_199, x_232); x_234 = lean_array_push(x_233, x_201); x_235 = lean_array_push(x_234, x_201); -x_236 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_236 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_237 = lean_array_push(x_235, x_236); x_238 = lean_array_push(x_237, x_186); x_239 = l_Lean_Parser_Term_letIdDecl___closed__2; x_240 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_240, 0, x_239); lean_ctor_set(x_240, 1, x_238); -x_241 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_241 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_242 = lean_array_push(x_241, x_240); -x_243 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_243 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_244 = lean_array_push(x_242, x_243); x_245 = lean_array_push(x_244, x_223); x_246 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -11723,16 +11283,16 @@ lean_ctor_set(x_251, 3, x_196); x_252 = lean_array_push(x_199, x_251); x_253 = lean_array_push(x_252, x_201); x_254 = lean_array_push(x_253, x_201); -x_255 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_255 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_256 = lean_array_push(x_254, x_255); x_257 = lean_array_push(x_256, x_186); x_258 = l_Lean_Parser_Term_letIdDecl___closed__2; x_259 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_259, 0, x_258); lean_ctor_set(x_259, 1, x_257); -x_260 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_260 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_261 = lean_array_push(x_260, x_259); -x_262 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_262 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_263 = lean_array_push(x_261, x_262); x_264 = lean_array_push(x_263, x_223); x_265 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -11830,7 +11390,7 @@ lean_ctor_set(x_293, 9, x_277); lean_ctor_set_uint8(x_293, sizeof(void*)*10, x_290); lean_ctor_set_uint8(x_293, sizeof(void*)*10 + 1, x_291); lean_ctor_set_uint8(x_293, sizeof(void*)*10 + 2, x_292); -x_294 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_11, x_15, x_293, x_280); +x_294 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_11, x_15, x_293, x_280); if (lean_obj_tag(x_294) == 0) { lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; @@ -11868,16 +11428,16 @@ lean_ctor_set(x_305, 3, x_196); x_306 = lean_array_push(x_199, x_305); x_307 = lean_array_push(x_306, x_201); x_308 = lean_array_push(x_307, x_201); -x_309 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_309 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_310 = lean_array_push(x_308, x_309); x_311 = lean_array_push(x_310, x_186); x_312 = l_Lean_Parser_Term_letIdDecl___closed__2; x_313 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_313, 0, x_312); lean_ctor_set(x_313, 1, x_311); -x_314 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_314 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_315 = lean_array_push(x_314, x_313); -x_316 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_316 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_317 = lean_array_push(x_315, x_316); x_318 = lean_array_push(x_317, x_295); x_319 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -11929,9 +11489,9 @@ x_326 = l_Lean_nullKind___closed__2; x_327 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_327, 0, x_326); lean_ctor_set(x_327, 1, x_174); -x_328 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__16; +x_328 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__16; x_329 = lean_array_push(x_328, x_327); -x_330 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__15; +x_330 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__15; x_331 = lean_array_push(x_329, x_330); x_332 = lean_array_push(x_331, x_13); x_333 = l_Lean_Parser_Term_fun___elambda__1___closed__2; @@ -11951,10 +11511,10 @@ x_340 = lean_ctor_get(x_338, 1); lean_inc(x_340); lean_dec(x_338); x_341 = lean_box(0); -x_342 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4; +x_342 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4; x_343 = l_Lean_addMacroScope(x_339, x_342, x_336); x_344 = lean_box(0); -x_345 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3; +x_345 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3; x_346 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_346, 0, x_341); lean_ctor_set(x_346, 1, x_345); @@ -11962,7 +11522,7 @@ lean_ctor_set(x_346, 2, x_343); lean_ctor_set(x_346, 3, x_344); x_347 = l_Array_empty___closed__1; x_348 = lean_array_push(x_347, x_346); -x_349 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_349 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_350 = lean_array_push(x_348, x_349); x_351 = l_Lean_mkTermIdFromIdent___closed__2; x_352 = lean_alloc_ctor(1, 2, 0); @@ -12044,7 +11604,7 @@ lean_ctor_set(x_376, 9, x_359); lean_ctor_set_uint8(x_376, sizeof(void*)*10, x_373); lean_ctor_set_uint8(x_376, sizeof(void*)*10 + 1, x_374); lean_ctor_set_uint8(x_376, sizeof(void*)*10 + 2, x_375); -x_377 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_11, x_353, x_376, x_363); +x_377 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_11, x_353, x_376, x_363); if (lean_obj_tag(x_377) == 0) { lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; @@ -12082,16 +11642,16 @@ lean_ctor_set(x_388, 3, x_344); x_389 = lean_array_push(x_347, x_388); x_390 = lean_array_push(x_389, x_349); x_391 = lean_array_push(x_390, x_349); -x_392 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_392 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_393 = lean_array_push(x_391, x_392); x_394 = lean_array_push(x_393, x_334); x_395 = l_Lean_Parser_Term_letIdDecl___closed__2; x_396 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_396, 0, x_395); lean_ctor_set(x_396, 1, x_394); -x_397 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_397 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_398 = lean_array_push(x_397, x_396); -x_399 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_399 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_400 = lean_array_push(x_398, x_399); x_401 = lean_array_push(x_400, x_378); x_402 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -12146,7 +11706,7 @@ lean_inc(x_411); lean_inc(x_410); lean_dec(x_9); lean_inc(x_410); -x_412 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___spec__1(x_410); +x_412 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___spec__1(x_410); x_413 = l_List_join___main___rarg(x_412); if (lean_obj_tag(x_413) == 0) { @@ -12164,10 +11724,10 @@ x_419 = lean_ctor_get(x_417, 1); lean_inc(x_419); lean_dec(x_417); x_420 = lean_box(0); -x_421 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4; +x_421 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4; x_422 = l_Lean_addMacroScope(x_418, x_421, x_415); x_423 = lean_box(0); -x_424 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3; +x_424 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3; x_425 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_425, 0, x_420); lean_ctor_set(x_425, 1, x_424); @@ -12182,7 +11742,7 @@ x_431 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_431, 0, x_430); lean_ctor_set(x_431, 1, x_429); x_432 = lean_array_push(x_426, x_431); -x_433 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__9; +x_433 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__9; x_434 = lean_array_push(x_432, x_433); x_435 = l_Lean_mkAppStx___closed__8; x_436 = lean_alloc_ctor(1, 2, 0); @@ -12265,7 +11825,7 @@ lean_ctor_set(x_460, 9, x_443); lean_ctor_set_uint8(x_460, sizeof(void*)*10, x_457); lean_ctor_set_uint8(x_460, sizeof(void*)*10 + 1, x_458); lean_ctor_set_uint8(x_460, sizeof(void*)*10 + 2, x_459); -x_461 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_409, x_2, x_460, x_447); +x_461 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_409, x_2, x_460, x_447); if (lean_obj_tag(x_461) == 0) { lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; @@ -12303,9 +11863,9 @@ lean_ctor_set(x_472, 3, x_423); x_473 = lean_array_push(x_426, x_472); x_474 = lean_array_push(x_473, x_428); x_475 = lean_array_push(x_474, x_428); -x_476 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_476 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_477 = lean_array_push(x_475, x_476); -x_478 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13; +x_478 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13; x_479 = lean_array_push(x_478, x_411); x_480 = l_Lean_Parser_Term_fun___elambda__1___closed__2; x_481 = lean_alloc_ctor(1, 2, 0); @@ -12316,9 +11876,9 @@ x_483 = l_Lean_Parser_Term_letIdDecl___closed__2; x_484 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_484, 0, x_483); lean_ctor_set(x_484, 1, x_482); -x_485 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_485 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_486 = lean_array_push(x_485, x_484); -x_487 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_487 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_488 = lean_array_push(x_486, x_487); x_489 = lean_array_push(x_488, x_462); x_490 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -12382,9 +11942,9 @@ x_501 = l_Lean_nullKind___closed__2; x_502 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_502, 0, x_501); lean_ctor_set(x_502, 1, x_499); -x_503 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__16; +x_503 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__16; x_504 = lean_array_push(x_503, x_502); -x_505 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__15; +x_505 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__15; x_506 = lean_array_push(x_504, x_505); x_507 = lean_array_push(x_506, x_411); x_508 = l_Lean_Parser_Term_fun___elambda__1___closed__2; @@ -12404,10 +11964,10 @@ x_515 = lean_ctor_get(x_513, 1); lean_inc(x_515); lean_dec(x_513); x_516 = lean_box(0); -x_517 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4; +x_517 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4; x_518 = l_Lean_addMacroScope(x_514, x_517, x_511); x_519 = lean_box(0); -x_520 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3; +x_520 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3; x_521 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_521, 0, x_516); lean_ctor_set(x_521, 1, x_520); @@ -12415,7 +11975,7 @@ lean_ctor_set(x_521, 2, x_518); lean_ctor_set(x_521, 3, x_519); x_522 = l_Array_empty___closed__1; x_523 = lean_array_push(x_522, x_521); -x_524 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_524 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_525 = lean_array_push(x_523, x_524); x_526 = l_Lean_mkTermIdFromIdent___closed__2; x_527 = lean_alloc_ctor(1, 2, 0); @@ -12503,7 +12063,7 @@ lean_ctor_set(x_552, 9, x_535); lean_ctor_set_uint8(x_552, sizeof(void*)*10, x_549); lean_ctor_set_uint8(x_552, sizeof(void*)*10 + 1, x_550); lean_ctor_set_uint8(x_552, sizeof(void*)*10 + 2, x_551); -x_553 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_409, x_529, x_552, x_539); +x_553 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_409, x_529, x_552, x_539); if (lean_obj_tag(x_553) == 0) { lean_object* x_554; lean_object* x_555; lean_object* x_556; lean_object* x_557; lean_object* x_558; lean_object* x_559; lean_object* x_560; lean_object* x_561; lean_object* x_562; lean_object* x_563; lean_object* x_564; lean_object* x_565; lean_object* x_566; lean_object* x_567; lean_object* x_568; lean_object* x_569; lean_object* x_570; lean_object* x_571; lean_object* x_572; lean_object* x_573; lean_object* x_574; lean_object* x_575; lean_object* x_576; lean_object* x_577; lean_object* x_578; lean_object* x_579; lean_object* x_580; @@ -12541,16 +12101,16 @@ lean_ctor_set(x_564, 3, x_519); x_565 = lean_array_push(x_522, x_564); x_566 = lean_array_push(x_565, x_524); x_567 = lean_array_push(x_566, x_524); -x_568 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_568 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_569 = lean_array_push(x_567, x_568); x_570 = lean_array_push(x_569, x_509); x_571 = l_Lean_Parser_Term_letIdDecl___closed__2; x_572 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_572, 0, x_571); lean_ctor_set(x_572, 1, x_570); -x_573 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_573 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_574 = lean_array_push(x_573, x_572); -x_575 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_575 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_576 = lean_array_push(x_574, x_575); x_577 = lean_array_push(x_576, x_554); x_578 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -12616,7 +12176,7 @@ if (lean_is_exclusive(x_585)) { x_589 = lean_box(0); } lean_inc(x_587); -x_590 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___spec__1(x_587); +x_590 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___spec__1(x_587); x_591 = l_List_join___main___rarg(x_590); if (lean_obj_tag(x_591) == 0) { @@ -12634,10 +12194,10 @@ x_597 = lean_ctor_get(x_595, 1); lean_inc(x_597); lean_dec(x_595); x_598 = lean_box(0); -x_599 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4; +x_599 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4; x_600 = l_Lean_addMacroScope(x_596, x_599, x_593); x_601 = lean_box(0); -x_602 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3; +x_602 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3; x_603 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_603, 0, x_598); lean_ctor_set(x_603, 1, x_602); @@ -12652,7 +12212,7 @@ x_609 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_609, 0, x_608); lean_ctor_set(x_609, 1, x_607); x_610 = lean_array_push(x_604, x_609); -x_611 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__9; +x_611 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__9; x_612 = lean_array_push(x_610, x_611); x_613 = l_Lean_mkAppStx___closed__8; x_614 = lean_alloc_ctor(1, 2, 0); @@ -12740,7 +12300,7 @@ lean_ctor_set(x_639, 9, x_622); lean_ctor_set_uint8(x_639, sizeof(void*)*10, x_636); lean_ctor_set_uint8(x_639, sizeof(void*)*10 + 1, x_637); lean_ctor_set_uint8(x_639, sizeof(void*)*10 + 2, x_638); -x_640 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_586, x_616, x_639, x_626); +x_640 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_586, x_616, x_639, x_626); if (lean_obj_tag(x_640) == 0) { lean_object* x_641; lean_object* x_642; lean_object* x_643; lean_object* x_644; lean_object* x_645; lean_object* x_646; lean_object* x_647; lean_object* x_648; lean_object* x_649; lean_object* x_650; lean_object* x_651; lean_object* x_652; lean_object* x_653; lean_object* x_654; lean_object* x_655; lean_object* x_656; lean_object* x_657; lean_object* x_658; lean_object* x_659; lean_object* x_660; lean_object* x_661; lean_object* x_662; lean_object* x_663; lean_object* x_664; lean_object* x_665; lean_object* x_666; lean_object* x_667; lean_object* x_668; lean_object* x_669; lean_object* x_670; lean_object* x_671; @@ -12778,9 +12338,9 @@ lean_ctor_set(x_651, 3, x_601); x_652 = lean_array_push(x_604, x_651); x_653 = lean_array_push(x_652, x_606); x_654 = lean_array_push(x_653, x_606); -x_655 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_655 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_656 = lean_array_push(x_654, x_655); -x_657 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13; +x_657 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13; x_658 = lean_array_push(x_657, x_588); x_659 = l_Lean_Parser_Term_fun___elambda__1___closed__2; x_660 = lean_alloc_ctor(1, 2, 0); @@ -12791,9 +12351,9 @@ x_662 = l_Lean_Parser_Term_letIdDecl___closed__2; x_663 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_663, 0, x_662); lean_ctor_set(x_663, 1, x_661); -x_664 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_664 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_665 = lean_array_push(x_664, x_663); -x_666 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_666 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_667 = lean_array_push(x_665, x_666); x_668 = lean_array_push(x_667, x_641); x_669 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -12856,9 +12416,9 @@ x_680 = l_Lean_nullKind___closed__2; x_681 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_681, 0, x_680); lean_ctor_set(x_681, 1, x_678); -x_682 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__16; +x_682 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__16; x_683 = lean_array_push(x_682, x_681); -x_684 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__15; +x_684 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__15; x_685 = lean_array_push(x_683, x_684); x_686 = lean_array_push(x_685, x_588); x_687 = l_Lean_Parser_Term_fun___elambda__1___closed__2; @@ -12878,10 +12438,10 @@ x_694 = lean_ctor_get(x_692, 1); lean_inc(x_694); lean_dec(x_692); x_695 = lean_box(0); -x_696 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4; +x_696 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4; x_697 = l_Lean_addMacroScope(x_693, x_696, x_690); x_698 = lean_box(0); -x_699 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3; +x_699 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3; x_700 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_700, 0, x_695); lean_ctor_set(x_700, 1, x_699); @@ -12889,7 +12449,7 @@ lean_ctor_set(x_700, 2, x_697); lean_ctor_set(x_700, 3, x_698); x_701 = l_Array_empty___closed__1; x_702 = lean_array_push(x_701, x_700); -x_703 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_703 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_704 = lean_array_push(x_702, x_703); x_705 = l_Lean_mkTermIdFromIdent___closed__2; x_706 = lean_alloc_ctor(1, 2, 0); @@ -12981,7 +12541,7 @@ lean_ctor_set(x_731, 9, x_714); lean_ctor_set_uint8(x_731, sizeof(void*)*10, x_728); lean_ctor_set_uint8(x_731, sizeof(void*)*10 + 1, x_729); lean_ctor_set_uint8(x_731, sizeof(void*)*10 + 2, x_730); -x_732 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_586, x_708, x_731, x_718); +x_732 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_586, x_708, x_731, x_718); if (lean_obj_tag(x_732) == 0) { lean_object* x_733; lean_object* x_734; lean_object* x_735; lean_object* x_736; lean_object* x_737; lean_object* x_738; lean_object* x_739; lean_object* x_740; lean_object* x_741; lean_object* x_742; lean_object* x_743; lean_object* x_744; lean_object* x_745; lean_object* x_746; lean_object* x_747; lean_object* x_748; lean_object* x_749; lean_object* x_750; lean_object* x_751; lean_object* x_752; lean_object* x_753; lean_object* x_754; lean_object* x_755; lean_object* x_756; lean_object* x_757; lean_object* x_758; lean_object* x_759; @@ -13019,16 +12579,16 @@ lean_ctor_set(x_743, 3, x_698); x_744 = lean_array_push(x_701, x_743); x_745 = lean_array_push(x_744, x_703); x_746 = lean_array_push(x_745, x_703); -x_747 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_747 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_748 = lean_array_push(x_746, x_747); x_749 = lean_array_push(x_748, x_688); x_750 = l_Lean_Parser_Term_letIdDecl___closed__2; x_751 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_751, 0, x_750); lean_ctor_set(x_751, 1, x_749); -x_752 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_752 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_753 = lean_array_push(x_752, x_751); -x_754 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_754 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_755 = lean_array_push(x_753, x_754); x_756 = lean_array_push(x_755, x_733); x_757 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -13075,11 +12635,11 @@ return x_763; } } } -lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { lean_object* x_6; -x_6 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main(x_1, x_2, x_3, x_4, x_5); +x_6 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main(x_1, x_2, x_3, x_4, x_5); return x_6; } } @@ -13299,7 +12859,7 @@ else lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; x_36 = lean_unsigned_to_nat(1u); x_37 = l_Lean_Syntax_getArg(x_13, x_36); -x_38 = l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main(x_37); +x_38 = l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main(x_37); x_39 = l_Lean_Syntax_setArg(x_13, x_36, x_38); x_40 = l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__1; lean_inc(x_39); @@ -13401,7 +12961,7 @@ lean_ctor_set(x_20, 0, x_5); lean_ctor_set(x_20, 1, x_19); x_21 = l_Array_toList___rarg(x_17); lean_dec(x_17); -x_22 = l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main(x_1, x_20, x_21, x_2, x_18); +x_22 = l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main(x_1, x_20, x_21, x_2, x_18); lean_dec(x_1); return x_22; } @@ -13486,7 +13046,7 @@ x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); return x_5; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder___closed__1() { _start: { lean_object* x_1; lean_object* x_2; @@ -13495,15 +13055,15 @@ x_2 = l_Lean_mkMVar(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder() { _start: { lean_object* x_1; -x_1 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder___closed__1; return x_1; } } -lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__1(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; @@ -13528,7 +13088,7 @@ x_9 = lean_unsigned_to_nat(0u); x_10 = lean_array_fset(x_2, x_1, x_9); x_11 = x_8; lean_inc(x_3); -x_12 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_11, x_3, x_4); +x_12 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_11, x_3, x_4); if (lean_obj_tag(x_12) == 0) { lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; @@ -13575,7 +13135,7 @@ return x_23; } } } -lean_object* _init_l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1() { +lean_object* _init_l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1() { _start: { lean_object* x_1; @@ -13583,7 +13143,7 @@ x_1 = lean_mk_string("fieldNotation"); return x_1; } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13599,7 +13159,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13613,7 +13173,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13629,7 +13189,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13643,7 +13203,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13659,7 +13219,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13673,7 +13233,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13689,7 +13249,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13703,7 +13263,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13719,7 +13279,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13733,7 +13293,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__7(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__7(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13749,7 +13309,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13763,7 +13323,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__8(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__8(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13779,7 +13339,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13793,7 +13353,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__9(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__9(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13809,7 +13369,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13823,7 +13383,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__10(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__10(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13839,7 +13399,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13853,7 +13413,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__11(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__11(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13869,7 +13429,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13883,7 +13443,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__12(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__12(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13899,7 +13459,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13913,7 +13473,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__13(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__13(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13929,7 +13489,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13943,7 +13503,7 @@ goto _start; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__14(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__14(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { if (lean_obj_tag(x_3) == 0) @@ -13959,7 +13519,7 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_3, 1); lean_inc(x_5); lean_dec(x_3); -x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1; +x_6 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1; lean_inc(x_1); x_7 = lean_name_mk_string(x_1, x_6); x_8 = lean_box(0); @@ -13973,7 +13533,7 @@ goto _start; } } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__1() { _start: { lean_object* x_1; lean_object* x_2; @@ -13982,13 +13542,13 @@ x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Expr_eq_x3f___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__1; +x_3 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__1; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -13996,7 +13556,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { _start: { lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; @@ -14026,7 +13586,7 @@ lean_ctor_set(x_23, 1, x_22); x_24 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_24, 0, x_23); lean_ctor_set(x_24, 1, x_22); -x_25 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__2; +x_25 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__2; x_26 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_26, 0, x_17); lean_ctor_set(x_26, 1, x_25); @@ -14060,7 +13620,7 @@ lean_ctor_set(x_40, 1, x_6); return x_40; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__1() { _start: { lean_object* x_1; @@ -14068,22 +13628,22 @@ x_1 = lean_mk_string("HasBeq.beq"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__1; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__2; +x_3 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__2; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -14091,7 +13651,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__4() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__4() { _start: { lean_object* x_1; @@ -14099,7 +13659,7 @@ x_1 = lean_mk_string("HasBeq"); return x_1; } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__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___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__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; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; @@ -14116,7 +13676,7 @@ x_14 = lean_name_mk_string(x_12, x_13); x_15 = l_Lean_mkTermIdFromIdent___closed__1; x_16 = lean_name_mk_string(x_12, x_15); x_17 = lean_box(0); -x_18 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__4; +x_18 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__4; lean_inc(x_1); x_19 = lean_name_mk_string(x_1, x_18); x_20 = l_Lean_Parser_Term_beq___elambda__1___closed__1; @@ -14131,7 +13691,7 @@ lean_ctor_set(x_25, 1, x_24); x_26 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_26, 0, x_25); lean_ctor_set(x_26, 1, x_24); -x_27 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__3; +x_27 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__3; x_28 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_28, 0, x_17); lean_ctor_set(x_28, 1, x_27); @@ -14165,7 +13725,7 @@ lean_ctor_set(x_42, 1, x_6); return x_42; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__1() { _start: { lean_object* x_1; lean_object* x_2; @@ -14174,13 +13734,13 @@ x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_Term_and___elambda__1___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__1; +x_3 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__1; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -14188,7 +13748,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__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___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__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; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; @@ -14218,7 +13778,7 @@ lean_ctor_set(x_23, 1, x_22); x_24 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_24, 0, x_23); lean_ctor_set(x_24, 1, x_22); -x_25 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__2; +x_25 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__2; x_26 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_26, 0, x_17); lean_ctor_set(x_26, 1, x_25); @@ -14252,7 +13812,7 @@ lean_ctor_set(x_40, 1, x_6); return x_40; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1() { _start: { lean_object* x_1; @@ -14260,22 +13820,22 @@ x_1 = lean_mk_string("ite"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1; x_2 = lean_string_utf8_byte_size(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1; x_2 = lean_unsigned_to_nat(0u); -x_3 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__2; +x_3 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__2; x_4 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_4, 0, x_1); lean_ctor_set(x_4, 1, x_2); @@ -14283,7 +13843,7 @@ lean_ctor_set(x_4, 2, x_3); return x_4; } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4(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_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { _start: { lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; @@ -14300,7 +13860,7 @@ x_15 = lean_name_mk_string(x_13, x_14); x_16 = l_Lean_mkTermIdFromIdent___closed__1; x_17 = lean_name_mk_string(x_13, x_16); x_18 = lean_box(0); -x_19 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1; +x_19 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1; lean_inc(x_1); x_20 = lean_name_mk_string(x_1, x_19); x_21 = l_Lean_Unhygienic_MonadQuotation___closed__2; @@ -14313,7 +13873,7 @@ lean_ctor_set(x_24, 1, x_23); x_25 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_25, 0, x_24); lean_ctor_set(x_25, 1, x_23); -x_26 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__3; +x_26 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__3; x_27 = lean_alloc_ctor(3, 4, 0); lean_ctor_set(x_27, 0, x_18); lean_ctor_set(x_27, 1, x_26); @@ -14348,7 +13908,7 @@ lean_ctor_set(x_42, 1, x_7); return x_42; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__1() { _start: { lean_object* x_1; @@ -14356,27 +13916,27 @@ x_1 = lean_mk_string("stxQuot: unimplemented kind "); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__2() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__1; +x_1 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__1; x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__2; +x_1 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__2; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__4() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__4() { _start: { lean_object* x_1; @@ -14384,7 +13944,7 @@ x_1 = lean_mk_string("expr"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5() { _start: { lean_object* x_1; lean_object* x_2; @@ -14393,7 +13953,7 @@ x_2 = l_Lean_mkNatLit(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6() { _start: { lean_object* x_1; lean_object* x_2; @@ -14402,7 +13962,7 @@ x_2 = l_Lean_mkStrLit(x_1); return x_2; } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___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; @@ -14421,7 +13981,7 @@ lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_dec(x_4); x_16 = lean_ctor_get(x_5, 1); lean_inc(x_16); -x_17 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__4; +x_17 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__4; x_18 = lean_string_dec_eq(x_16, x_17); lean_dec(x_16); if (x_18 == 0) @@ -14529,7 +14089,7 @@ x_48 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_48, 0, x_47); x_49 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_49, 0, x_48); -x_50 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_50 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_51 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_51, 0, x_50); lean_ctor_set(x_51, 1, x_49); @@ -14555,7 +14115,7 @@ x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); x_58 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_58, 0, x_57); -x_59 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_59 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_60 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_60, 0, x_59); lean_ctor_set(x_60, 1, x_58); @@ -14613,12 +14173,12 @@ if (x_79 == 0) { lean_object* x_80; uint8_t x_81; lean_dec(x_4); -x_80 = l_Lean_Parser_Term_str___elambda__1___closed__1; +x_80 = l_Lean_String_HasQuote___closed__1; x_81 = lean_string_dec_eq(x_27, x_80); if (x_81 == 0) { lean_object* x_82; uint8_t x_83; -x_82 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_82 = l_Lean_Nat_HasQuote___closed__1; x_83 = lean_string_dec_eq(x_27, x_82); if (x_83 == 0) { @@ -14632,7 +14192,7 @@ x_86 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_86, 0, x_85); x_87 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_87, 0, x_86); -x_88 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_88 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_89 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_89, 0, x_88); lean_ctor_set(x_89, 1, x_87); @@ -14658,7 +14218,7 @@ lean_dec(x_92); if (lean_obj_tag(x_94) == 0) { lean_object* x_95; lean_object* x_96; -x_95 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5; +x_95 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5; x_96 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_96, 0, x_95); lean_ctor_set(x_96, 1, x_3); @@ -14695,7 +14255,7 @@ lean_dec(x_101); if (lean_obj_tag(x_102) == 0) { lean_object* x_103; lean_object* x_104; -x_103 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6; +x_103 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6; x_104 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_104, 0, x_103); lean_ctor_set(x_104, 1, x_3); @@ -14730,12 +14290,12 @@ x_110 = lean_array_get(x_108, x_4, x_109); x_111 = lean_unsigned_to_nat(2u); x_112 = lean_array_get(x_108, x_4, x_111); lean_dec(x_4); -x_113 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___boxed), 6, 3); +x_113 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___boxed), 6, 3); lean_closure_set(x_113, 0, x_26); lean_closure_set(x_113, 1, x_110); lean_closure_set(x_113, 2, x_112); x_114 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_115 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_115 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_115, 0, x_114); lean_closure_set(x_115, 1, x_113); x_116 = l_Lean_Unhygienic_run___rarg(x_115); @@ -14758,12 +14318,12 @@ x_120 = lean_array_get(x_118, x_4, x_119); x_121 = lean_unsigned_to_nat(2u); x_122 = lean_array_get(x_118, x_4, x_121); lean_dec(x_4); -x_123 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___boxed), 6, 3); +x_123 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___boxed), 6, 3); lean_closure_set(x_123, 0, x_26); lean_closure_set(x_123, 1, x_120); lean_closure_set(x_123, 2, x_122); x_124 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_125 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_125 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_125, 0, x_124); lean_closure_set(x_125, 1, x_123); x_126 = l_Lean_Unhygienic_run___rarg(x_125); @@ -14786,12 +14346,12 @@ x_130 = lean_array_get(x_128, x_4, x_129); x_131 = lean_unsigned_to_nat(2u); x_132 = lean_array_get(x_128, x_4, x_131); lean_dec(x_4); -x_133 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___boxed), 6, 3); +x_133 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___boxed), 6, 3); lean_closure_set(x_133, 0, x_26); lean_closure_set(x_133, 1, x_130); lean_closure_set(x_133, 2, x_132); x_134 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_135 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_135 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_135, 0, x_134); lean_closure_set(x_135, 1, x_133); x_136 = l_Lean_Unhygienic_run___rarg(x_135); @@ -14861,13 +14421,13 @@ x_158 = lean_array_get(x_154, x_4, x_157); x_159 = lean_unsigned_to_nat(6u); x_160 = lean_array_get(x_154, x_4, x_159); lean_dec(x_4); -x_161 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___boxed), 7, 4); +x_161 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___boxed), 7, 4); lean_closure_set(x_161, 0, x_26); lean_closure_set(x_161, 1, x_156); lean_closure_set(x_161, 2, x_158); lean_closure_set(x_161, 3, x_160); x_162 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_163 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_163 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_163, 0, x_162); lean_closure_set(x_163, 1, x_161); x_164 = l_Lean_Unhygienic_run___rarg(x_163); @@ -14888,7 +14448,7 @@ x_166 = l_Lean_Syntax_inhabited; x_167 = lean_unsigned_to_nat(0u); x_168 = lean_array_get(x_166, x_4, x_167); lean_inc(x_2); -x_169 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_168, x_2, x_3); +x_169 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_168, x_2, x_3); if (lean_obj_tag(x_169) == 0) { lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; @@ -14903,7 +14463,7 @@ lean_dec(x_4); x_174 = l_Lean_Syntax_getArgs(x_173); lean_dec(x_173); x_175 = x_174; -x_176 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__1), 4, 2); +x_176 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__1), 4, 2); lean_closure_set(x_176, 0, x_167); lean_closure_set(x_176, 1, x_175); x_177 = x_176; @@ -15028,7 +14588,7 @@ block_290: { lean_object* x_205; lean_inc(x_2); -x_205 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_201, x_2, x_3); +x_205 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_201, x_2, x_3); if (lean_obj_tag(x_205) == 0) { lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; uint8_t x_213; @@ -15043,7 +14603,7 @@ lean_inc(x_209); x_210 = lean_ctor_get(x_208, 1); lean_inc(x_210); lean_dec(x_208); -x_211 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_211 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; lean_inc_n(x_204, 2); x_212 = lean_local_ctx_mk_let_decl(x_209, x_204, x_204, x_211, x_206); x_213 = !lean_is_exclusive(x_2); @@ -15059,7 +14619,7 @@ x_216 = lean_ctor_get(x_214, 1); lean_dec(x_216); lean_inc(x_212); lean_ctor_set(x_214, 1, x_212); -x_217 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_203, x_2, x_210); +x_217 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_203, x_2, x_210); if (lean_obj_tag(x_217) == 0) { uint8_t x_218; @@ -15142,7 +14702,7 @@ lean_ctor_set(x_239, 2, x_236); lean_ctor_set(x_239, 3, x_237); lean_ctor_set(x_239, 4, x_238); lean_ctor_set(x_2, 0, x_239); -x_240 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_203, x_2, x_210); +x_240 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_203, x_2, x_210); if (lean_obj_tag(x_240) == 0) { lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; @@ -15272,7 +14832,7 @@ lean_ctor_set(x_272, 9, x_262); lean_ctor_set_uint8(x_272, sizeof(void*)*10, x_263); lean_ctor_set_uint8(x_272, sizeof(void*)*10 + 1, x_264); lean_ctor_set_uint8(x_272, sizeof(void*)*10 + 2, x_265); -x_273 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_203, x_272, x_210); +x_273 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_203, x_272, x_210); if (lean_obj_tag(x_273) == 0) { lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; @@ -15416,7 +14976,7 @@ lean_dec(x_314); x_316 = l_Lean_Syntax_getArg(x_315, x_294); lean_dec(x_315); lean_inc(x_2); -x_317 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_316, x_2, x_3); +x_317 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_316, x_2, x_3); if (lean_obj_tag(x_317) == 0) { lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; 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_332; 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_340; lean_object* x_341; uint8_t x_342; @@ -15473,7 +15033,7 @@ x_345 = lean_ctor_get(x_343, 1); lean_dec(x_345); lean_inc(x_324); lean_ctor_set(x_343, 1, x_324); -x_346 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_341, x_2, x_329); +x_346 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_341, x_2, x_329); if (lean_obj_tag(x_346) == 0) { uint8_t x_347; @@ -15556,7 +15116,7 @@ lean_ctor_set(x_368, 2, x_365); lean_ctor_set(x_368, 3, x_366); lean_ctor_set(x_368, 4, x_367); lean_ctor_set(x_2, 0, x_368); -x_369 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_341, x_2, x_329); +x_369 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_341, x_2, x_329); if (lean_obj_tag(x_369) == 0) { lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; lean_object* x_377; @@ -15686,7 +15246,7 @@ lean_ctor_set(x_401, 9, x_391); lean_ctor_set_uint8(x_401, sizeof(void*)*10, x_392); lean_ctor_set_uint8(x_401, sizeof(void*)*10 + 1, x_393); lean_ctor_set_uint8(x_401, sizeof(void*)*10 + 2, x_394); -x_402 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_341, x_401, x_329); +x_402 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_341, x_401, x_329); if (lean_obj_tag(x_402) == 0) { lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; lean_object* x_410; @@ -15785,7 +15345,7 @@ lean_inc(x_422); x_423 = lean_ctor_get(x_421, 1); lean_inc(x_423); lean_dec(x_421); -x_424 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_424 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_425 = 0; lean_inc_n(x_420, 2); x_426 = lean_local_ctx_mk_local_decl(x_422, x_420, x_420, x_424, x_425); @@ -15828,7 +15388,7 @@ x_447 = lean_ctor_get(x_445, 1); lean_dec(x_447); lean_inc(x_426); lean_ctor_set(x_445, 1, x_426); -x_448 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_443, x_2, x_431); +x_448 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_443, x_2, x_431); if (lean_obj_tag(x_448) == 0) { uint8_t x_449; @@ -15911,7 +15471,7 @@ lean_ctor_set(x_470, 2, x_467); lean_ctor_set(x_470, 3, x_468); lean_ctor_set(x_470, 4, x_469); lean_ctor_set(x_2, 0, x_470); -x_471 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_443, x_2, x_431); +x_471 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_443, x_2, x_431); if (lean_obj_tag(x_471) == 0) { lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; @@ -16041,7 +15601,7 @@ lean_ctor_set(x_503, 9, x_493); lean_ctor_set_uint8(x_503, sizeof(void*)*10, x_494); lean_ctor_set_uint8(x_503, sizeof(void*)*10 + 1, x_495); lean_ctor_set_uint8(x_503, sizeof(void*)*10 + 2, x_496); -x_504 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_443, x_503, x_431); +x_504 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_443, x_503, x_431); if (lean_obj_tag(x_504) == 0) { lean_object* x_505; lean_object* x_506; lean_object* x_507; lean_object* x_508; lean_object* x_509; lean_object* x_510; lean_object* x_511; lean_object* x_512; @@ -16112,7 +15672,7 @@ lean_inc(x_519); x_520 = lean_ctor_get(x_518, 1); lean_inc(x_520); lean_dec(x_518); -x_521 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_521 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_522 = 0; lean_inc_n(x_517, 2); x_523 = lean_local_ctx_mk_local_decl(x_519, x_517, x_517, x_521, x_522); @@ -16155,7 +15715,7 @@ x_544 = lean_ctor_get(x_542, 1); lean_dec(x_544); lean_inc(x_523); lean_ctor_set(x_542, 1, x_523); -x_545 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_540, x_2, x_528); +x_545 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_540, x_2, x_528); if (lean_obj_tag(x_545) == 0) { uint8_t x_546; @@ -16238,7 +15798,7 @@ lean_ctor_set(x_567, 2, x_564); lean_ctor_set(x_567, 3, x_565); lean_ctor_set(x_567, 4, x_566); lean_ctor_set(x_2, 0, x_567); -x_568 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_540, x_2, x_528); +x_568 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_540, x_2, x_528); if (lean_obj_tag(x_568) == 0) { lean_object* x_569; lean_object* x_570; lean_object* x_571; lean_object* x_572; lean_object* x_573; lean_object* x_574; lean_object* x_575; lean_object* x_576; @@ -16368,7 +15928,7 @@ lean_ctor_set(x_600, 9, x_590); lean_ctor_set_uint8(x_600, sizeof(void*)*10, x_591); lean_ctor_set_uint8(x_600, sizeof(void*)*10 + 1, x_592); lean_ctor_set_uint8(x_600, sizeof(void*)*10 + 2, x_593); -x_601 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_540, x_600, x_528); +x_601 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_540, x_600, x_528); if (lean_obj_tag(x_601) == 0) { lean_object* x_602; lean_object* x_603; lean_object* x_604; lean_object* x_605; lean_object* x_606; lean_object* x_607; lean_object* x_608; lean_object* x_609; @@ -16471,7 +16031,7 @@ lean_object* x_623; lean_object* x_624; lean_object* x_625; lean_object* x_626; x_623 = lean_ctor_get(x_621, 1); lean_inc(x_623); lean_dec(x_621); -x_624 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_624 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_625 = l_unreachable_x21___rarg(x_624); x_626 = lean_apply_2(x_625, x_2, x_623); return x_626; @@ -16498,7 +16058,7 @@ lean_dec(x_630); x_631 = lean_ctor_get(x_627, 1); lean_inc(x_631); lean_dec(x_627); -x_632 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2(x_26, x_628, x_631); +x_632 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2(x_26, x_628, x_631); lean_ctor_set(x_621, 0, x_632); return x_621; } @@ -16511,7 +16071,7 @@ lean_dec(x_621); x_634 = lean_ctor_get(x_627, 1); lean_inc(x_634); lean_dec(x_627); -x_635 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2(x_26, x_628, x_634); +x_635 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2(x_26, x_628, x_634); x_636 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_636, 0, x_635); lean_ctor_set(x_636, 1, x_633); @@ -16530,7 +16090,7 @@ lean_dec(x_638); x_639 = lean_ctor_get(x_627, 1); lean_inc(x_639); lean_dec(x_627); -x_640 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__3(x_26, x_628, x_639); +x_640 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__3(x_26, x_628, x_639); lean_ctor_set(x_621, 0, x_640); return x_621; } @@ -16543,7 +16103,7 @@ lean_dec(x_621); x_642 = lean_ctor_get(x_627, 1); lean_inc(x_642); lean_dec(x_627); -x_643 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__3(x_26, x_628, x_642); +x_643 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__3(x_26, x_628, x_642); x_644 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_644, 0, x_643); lean_ctor_set(x_644, 1, x_641); @@ -16562,7 +16122,7 @@ lean_dec(x_646); x_647 = lean_ctor_get(x_627, 1); lean_inc(x_647); lean_dec(x_627); -x_648 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__4(x_26, x_628, x_647); +x_648 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__4(x_26, x_628, x_647); lean_ctor_set(x_621, 0, x_648); return x_621; } @@ -16575,7 +16135,7 @@ lean_dec(x_621); x_650 = lean_ctor_get(x_627, 1); lean_inc(x_650); lean_dec(x_627); -x_651 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__4(x_26, x_628, x_650); +x_651 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__4(x_26, x_628, x_650); x_652 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_652, 0, x_651); lean_ctor_set(x_652, 1, x_649); @@ -16594,7 +16154,7 @@ lean_dec(x_654); x_655 = lean_ctor_get(x_627, 1); lean_inc(x_655); lean_dec(x_627); -x_656 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__5(x_26, x_628, x_655); +x_656 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__5(x_26, x_628, x_655); lean_ctor_set(x_621, 0, x_656); return x_621; } @@ -16607,7 +16167,7 @@ lean_dec(x_621); x_658 = lean_ctor_get(x_627, 1); lean_inc(x_658); lean_dec(x_627); -x_659 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__5(x_26, x_628, x_658); +x_659 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__5(x_26, x_628, x_658); x_660 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_660, 0, x_659); lean_ctor_set(x_660, 1, x_657); @@ -16630,7 +16190,7 @@ x_664 = lean_ctor_get(x_628, 0); lean_inc(x_664); lean_dec(x_628); x_665 = l_Lean_mkConst(x_664, x_620); -x_666 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__6(x_26, x_665, x_663); +x_666 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__6(x_26, x_665, x_663); lean_ctor_set(x_621, 0, x_666); return x_621; } @@ -16647,7 +16207,7 @@ x_669 = lean_ctor_get(x_628, 0); lean_inc(x_669); lean_dec(x_628); x_670 = l_Lean_mkConst(x_669, x_620); -x_671 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__6(x_26, x_670, x_668); +x_671 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__6(x_26, x_670, x_668); x_672 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_672, 0, x_671); lean_ctor_set(x_672, 1, x_667); @@ -16666,7 +16226,7 @@ lean_dec(x_674); x_675 = lean_ctor_get(x_627, 1); lean_inc(x_675); lean_dec(x_627); -x_676 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__7(x_26, x_628, x_675); +x_676 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__7(x_26, x_628, x_675); lean_ctor_set(x_621, 0, x_676); return x_621; } @@ -16679,7 +16239,7 @@ lean_dec(x_621); x_678 = lean_ctor_get(x_627, 1); lean_inc(x_678); lean_dec(x_627); -x_679 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__7(x_26, x_628, x_678); +x_679 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__7(x_26, x_628, x_678); x_680 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_680, 0, x_679); lean_ctor_set(x_680, 1, x_677); @@ -16698,7 +16258,7 @@ lean_dec(x_682); x_683 = lean_ctor_get(x_627, 1); lean_inc(x_683); lean_dec(x_627); -x_684 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__8(x_26, x_628, x_683); +x_684 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__8(x_26, x_628, x_683); lean_ctor_set(x_621, 0, x_684); return x_621; } @@ -16711,7 +16271,7 @@ lean_dec(x_621); x_686 = lean_ctor_get(x_627, 1); lean_inc(x_686); lean_dec(x_627); -x_687 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__8(x_26, x_628, x_686); +x_687 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__8(x_26, x_628, x_686); x_688 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_688, 0, x_687); lean_ctor_set(x_688, 1, x_685); @@ -16730,7 +16290,7 @@ lean_dec(x_690); x_691 = lean_ctor_get(x_627, 1); lean_inc(x_691); lean_dec(x_627); -x_692 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__9(x_26, x_628, x_691); +x_692 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__9(x_26, x_628, x_691); lean_ctor_set(x_621, 0, x_692); return x_621; } @@ -16743,7 +16303,7 @@ lean_dec(x_621); x_694 = lean_ctor_get(x_627, 1); lean_inc(x_694); lean_dec(x_627); -x_695 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__9(x_26, x_628, x_694); +x_695 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__9(x_26, x_628, x_694); x_696 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_696, 0, x_695); lean_ctor_set(x_696, 1, x_693); @@ -16762,7 +16322,7 @@ lean_dec(x_698); x_699 = lean_ctor_get(x_627, 1); lean_inc(x_699); lean_dec(x_627); -x_700 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__10(x_26, x_628, x_699); +x_700 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__10(x_26, x_628, x_699); lean_ctor_set(x_621, 0, x_700); return x_621; } @@ -16775,7 +16335,7 @@ lean_dec(x_621); x_702 = lean_ctor_get(x_627, 1); lean_inc(x_702); lean_dec(x_627); -x_703 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__10(x_26, x_628, x_702); +x_703 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__10(x_26, x_628, x_702); x_704 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_704, 0, x_703); lean_ctor_set(x_704, 1, x_701); @@ -16794,7 +16354,7 @@ lean_dec(x_706); x_707 = lean_ctor_get(x_627, 1); lean_inc(x_707); lean_dec(x_627); -x_708 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__11(x_26, x_628, x_707); +x_708 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__11(x_26, x_628, x_707); lean_ctor_set(x_621, 0, x_708); return x_621; } @@ -16807,7 +16367,7 @@ lean_dec(x_621); x_710 = lean_ctor_get(x_627, 1); lean_inc(x_710); lean_dec(x_627); -x_711 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__11(x_26, x_628, x_710); +x_711 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__11(x_26, x_628, x_710); x_712 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_712, 0, x_711); lean_ctor_set(x_712, 1, x_709); @@ -16826,7 +16386,7 @@ lean_dec(x_714); x_715 = lean_ctor_get(x_627, 1); lean_inc(x_715); lean_dec(x_627); -x_716 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__12(x_26, x_628, x_715); +x_716 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__12(x_26, x_628, x_715); lean_ctor_set(x_621, 0, x_716); return x_621; } @@ -16839,7 +16399,7 @@ lean_dec(x_621); x_718 = lean_ctor_get(x_627, 1); lean_inc(x_718); lean_dec(x_627); -x_719 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__12(x_26, x_628, x_718); +x_719 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__12(x_26, x_628, x_718); x_720 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_720, 0, x_719); lean_ctor_set(x_720, 1, x_717); @@ -16858,7 +16418,7 @@ lean_dec(x_722); x_723 = lean_ctor_get(x_627, 1); lean_inc(x_723); lean_dec(x_627); -x_724 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__13(x_26, x_628, x_723); +x_724 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__13(x_26, x_628, x_723); lean_ctor_set(x_621, 0, x_724); return x_621; } @@ -16871,7 +16431,7 @@ lean_dec(x_621); x_726 = lean_ctor_get(x_627, 1); lean_inc(x_726); lean_dec(x_627); -x_727 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__13(x_26, x_628, x_726); +x_727 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__13(x_26, x_628, x_726); x_728 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_728, 0, x_727); lean_ctor_set(x_728, 1, x_725); @@ -16890,7 +16450,7 @@ lean_dec(x_730); x_731 = lean_ctor_get(x_627, 1); lean_inc(x_731); lean_dec(x_627); -x_732 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__14(x_26, x_628, x_731); +x_732 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__14(x_26, x_628, x_731); lean_ctor_set(x_621, 0, x_732); return x_621; } @@ -16903,7 +16463,7 @@ lean_dec(x_621); x_734 = lean_ctor_get(x_627, 1); lean_inc(x_734); lean_dec(x_627); -x_735 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__14(x_26, x_628, x_734); +x_735 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__14(x_26, x_628, x_734); x_736 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_736, 0, x_735); lean_ctor_set(x_736, 1, x_733); @@ -16942,7 +16502,7 @@ else lean_object* x_741; lean_object* x_742; lean_object* x_743; lean_dec(x_617); lean_dec(x_1); -x_741 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_741 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_742 = l_unreachable_x21___rarg(x_741); x_743 = lean_apply_2(x_742, x_2, x_3); return x_743; @@ -16972,7 +16532,7 @@ x_749 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_749, 0, x_748); x_750 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_750, 0, x_749); -x_751 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_751 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_752 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_752, 0, x_751); lean_ctor_set(x_752, 1, x_750); @@ -17002,7 +16562,7 @@ x_759 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_759, 0, x_758); x_760 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_760, 0, x_759); -x_761 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_761 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_762 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_762, 0, x_761); lean_ctor_set(x_762, 1, x_760); @@ -17060,12 +16620,12 @@ if (x_781 == 0) { lean_object* x_782; uint8_t x_783; lean_dec(x_4); -x_782 = l_Lean_Parser_Term_str___elambda__1___closed__1; +x_782 = l_Lean_String_HasQuote___closed__1; x_783 = lean_string_dec_eq(x_27, x_782); if (x_783 == 0) { lean_object* x_784; uint8_t x_785; -x_784 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_784 = l_Lean_Nat_HasQuote___closed__1; x_785 = lean_string_dec_eq(x_27, x_784); if (x_785 == 0) { @@ -17083,7 +16643,7 @@ x_789 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_789, 0, x_788); x_790 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_790, 0, x_789); -x_791 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_791 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_792 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_792, 0, x_791); lean_ctor_set(x_792, 1, x_790); @@ -17108,7 +16668,7 @@ lean_dec(x_795); if (lean_obj_tag(x_797) == 0) { lean_object* x_798; lean_object* x_799; -x_798 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5; +x_798 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5; x_799 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_799, 0, x_798); lean_ctor_set(x_799, 1, x_3); @@ -17144,7 +16704,7 @@ lean_dec(x_804); if (lean_obj_tag(x_805) == 0) { lean_object* x_806; lean_object* x_807; -x_806 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6; +x_806 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6; x_807 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_807, 0, x_806); lean_ctor_set(x_807, 1, x_3); @@ -17178,12 +16738,12 @@ x_813 = lean_array_get(x_811, x_4, x_812); x_814 = lean_unsigned_to_nat(2u); x_815 = lean_array_get(x_811, x_4, x_814); lean_dec(x_4); -x_816 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___boxed), 6, 3); +x_816 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___boxed), 6, 3); lean_closure_set(x_816, 0, x_26); lean_closure_set(x_816, 1, x_813); lean_closure_set(x_816, 2, x_815); x_817 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_818 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_818 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_818, 0, x_817); lean_closure_set(x_818, 1, x_816); x_819 = l_Lean_Unhygienic_run___rarg(x_818); @@ -17205,12 +16765,12 @@ x_823 = lean_array_get(x_821, x_4, x_822); x_824 = lean_unsigned_to_nat(2u); x_825 = lean_array_get(x_821, x_4, x_824); lean_dec(x_4); -x_826 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___boxed), 6, 3); +x_826 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___boxed), 6, 3); lean_closure_set(x_826, 0, x_26); lean_closure_set(x_826, 1, x_823); lean_closure_set(x_826, 2, x_825); x_827 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_828 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_828 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_828, 0, x_827); lean_closure_set(x_828, 1, x_826); x_829 = l_Lean_Unhygienic_run___rarg(x_828); @@ -17232,12 +16792,12 @@ x_833 = lean_array_get(x_831, x_4, x_832); x_834 = lean_unsigned_to_nat(2u); x_835 = lean_array_get(x_831, x_4, x_834); lean_dec(x_4); -x_836 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___boxed), 6, 3); +x_836 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___boxed), 6, 3); lean_closure_set(x_836, 0, x_26); lean_closure_set(x_836, 1, x_833); lean_closure_set(x_836, 2, x_835); x_837 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_838 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_838 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_838, 0, x_837); lean_closure_set(x_838, 1, x_836); x_839 = l_Lean_Unhygienic_run___rarg(x_838); @@ -17305,13 +16865,13 @@ x_861 = lean_array_get(x_857, x_4, x_860); x_862 = lean_unsigned_to_nat(6u); x_863 = lean_array_get(x_857, x_4, x_862); lean_dec(x_4); -x_864 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___boxed), 7, 4); +x_864 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___boxed), 7, 4); lean_closure_set(x_864, 0, x_26); lean_closure_set(x_864, 1, x_859); lean_closure_set(x_864, 2, x_861); lean_closure_set(x_864, 3, x_863); x_865 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_866 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_866 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_866, 0, x_865); lean_closure_set(x_866, 1, x_864); x_867 = l_Lean_Unhygienic_run___rarg(x_866); @@ -17331,7 +16891,7 @@ x_869 = l_Lean_Syntax_inhabited; x_870 = lean_unsigned_to_nat(0u); x_871 = lean_array_get(x_869, x_4, x_870); lean_inc(x_2); -x_872 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_871, x_2, x_3); +x_872 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_871, x_2, x_3); if (lean_obj_tag(x_872) == 0) { lean_object* x_873; lean_object* x_874; lean_object* x_875; lean_object* x_876; lean_object* x_877; lean_object* x_878; lean_object* x_879; lean_object* x_880; lean_object* x_881; @@ -17346,7 +16906,7 @@ lean_dec(x_4); x_877 = l_Lean_Syntax_getArgs(x_876); lean_dec(x_876); x_878 = x_877; -x_879 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__1), 4, 2); +x_879 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__1), 4, 2); lean_closure_set(x_879, 0, x_870); lean_closure_set(x_879, 1, x_878); x_880 = x_879; @@ -17471,7 +17031,7 @@ block_952: { lean_object* x_906; lean_inc(x_2); -x_906 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_902, x_2, x_3); +x_906 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_902, x_2, x_3); if (lean_obj_tag(x_906) == 0) { lean_object* x_907; lean_object* x_908; lean_object* x_909; lean_object* x_910; lean_object* x_911; lean_object* x_912; lean_object* x_913; lean_object* x_914; lean_object* x_915; lean_object* x_916; lean_object* x_917; lean_object* x_918; lean_object* x_919; lean_object* x_920; lean_object* x_921; lean_object* x_922; lean_object* x_923; uint8_t x_924; uint8_t x_925; uint8_t x_926; lean_object* x_927; lean_object* x_928; lean_object* x_929; lean_object* x_930; lean_object* x_931; lean_object* x_932; lean_object* x_933; lean_object* x_934; lean_object* x_935; @@ -17486,7 +17046,7 @@ lean_inc(x_910); x_911 = lean_ctor_get(x_909, 1); lean_inc(x_911); lean_dec(x_909); -x_912 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_912 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; lean_inc_n(x_905, 2); x_913 = lean_local_ctx_mk_let_decl(x_910, x_905, x_905, x_912, x_907); x_914 = lean_ctor_get(x_2, 0); @@ -17576,7 +17136,7 @@ lean_ctor_set(x_934, 9, x_923); lean_ctor_set_uint8(x_934, sizeof(void*)*10, x_924); lean_ctor_set_uint8(x_934, sizeof(void*)*10 + 1, x_925); lean_ctor_set_uint8(x_934, sizeof(void*)*10 + 2, x_926); -x_935 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_904, x_934, x_911); +x_935 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_904, x_934, x_911); if (lean_obj_tag(x_935) == 0) { lean_object* x_936; lean_object* x_937; lean_object* x_938; lean_object* x_939; lean_object* x_940; lean_object* x_941; lean_object* x_942; lean_object* x_943; @@ -17720,7 +17280,7 @@ lean_dec(x_976); x_978 = l_Lean_Syntax_getArg(x_977, x_956); lean_dec(x_977); lean_inc(x_2); -x_979 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_978, x_2, x_3); +x_979 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_978, x_2, x_3); if (lean_obj_tag(x_979) == 0) { lean_object* x_980; lean_object* x_981; lean_object* x_982; lean_object* x_983; lean_object* x_984; uint8_t x_985; lean_object* x_986; lean_object* x_987; lean_object* x_988; lean_object* x_989; lean_object* x_990; lean_object* x_991; lean_object* x_992; lean_object* x_993; lean_object* x_994; lean_object* x_995; lean_object* x_996; lean_object* x_997; lean_object* x_998; lean_object* x_999; lean_object* x_1000; lean_object* x_1001; lean_object* x_1002; lean_object* x_1003; lean_object* x_1004; lean_object* x_1005; lean_object* x_1006; lean_object* x_1007; lean_object* x_1008; lean_object* x_1009; lean_object* x_1010; lean_object* x_1011; lean_object* x_1012; lean_object* x_1013; uint8_t x_1014; uint8_t x_1015; uint8_t x_1016; lean_object* x_1017; lean_object* x_1018; lean_object* x_1019; lean_object* x_1020; lean_object* x_1021; lean_object* x_1022; lean_object* x_1023; lean_object* x_1024; lean_object* x_1025; @@ -17851,7 +17411,7 @@ lean_ctor_set(x_1024, 9, x_1013); lean_ctor_set_uint8(x_1024, sizeof(void*)*10, x_1014); lean_ctor_set_uint8(x_1024, sizeof(void*)*10 + 1, x_1015); lean_ctor_set_uint8(x_1024, sizeof(void*)*10 + 2, x_1016); -x_1025 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1003, x_1024, x_991); +x_1025 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1003, x_1024, x_991); if (lean_obj_tag(x_1025) == 0) { lean_object* x_1026; lean_object* x_1027; lean_object* x_1028; lean_object* x_1029; lean_object* x_1030; lean_object* x_1031; lean_object* x_1032; lean_object* x_1033; @@ -17951,7 +17511,7 @@ lean_inc(x_1045); x_1046 = lean_ctor_get(x_1044, 1); lean_inc(x_1046); lean_dec(x_1044); -x_1047 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_1047 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_1048 = 0; lean_inc_n(x_1043, 2); x_1049 = lean_local_ctx_mk_local_decl(x_1045, x_1043, x_1043, x_1047, x_1048); @@ -18068,7 +17628,7 @@ lean_ctor_set(x_1087, 9, x_1076); lean_ctor_set_uint8(x_1087, sizeof(void*)*10, x_1077); lean_ctor_set_uint8(x_1087, sizeof(void*)*10 + 1, x_1078); lean_ctor_set_uint8(x_1087, sizeof(void*)*10 + 2, x_1079); -x_1088 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1066, x_1087, x_1054); +x_1088 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1066, x_1087, x_1054); if (lean_obj_tag(x_1088) == 0) { lean_object* x_1089; lean_object* x_1090; lean_object* x_1091; lean_object* x_1092; lean_object* x_1093; lean_object* x_1094; lean_object* x_1095; lean_object* x_1096; @@ -18138,7 +17698,7 @@ lean_inc(x_1103); x_1104 = lean_ctor_get(x_1102, 1); lean_inc(x_1104); lean_dec(x_1102); -x_1105 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_1105 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_1106 = 0; lean_inc_n(x_1101, 2); x_1107 = lean_local_ctx_mk_local_decl(x_1103, x_1101, x_1101, x_1105, x_1106); @@ -18255,7 +17815,7 @@ lean_ctor_set(x_1145, 9, x_1134); lean_ctor_set_uint8(x_1145, sizeof(void*)*10, x_1135); lean_ctor_set_uint8(x_1145, sizeof(void*)*10 + 1, x_1136); lean_ctor_set_uint8(x_1145, sizeof(void*)*10 + 2, x_1137); -x_1146 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1124, x_1145, x_1112); +x_1146 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1124, x_1145, x_1112); if (lean_obj_tag(x_1146) == 0) { lean_object* x_1147; lean_object* x_1148; lean_object* x_1149; lean_object* x_1150; lean_object* x_1151; lean_object* x_1152; lean_object* x_1153; lean_object* x_1154; @@ -18356,7 +17916,7 @@ lean_object* x_1168; lean_object* x_1169; lean_object* x_1170; lean_object* x_11 x_1168 = lean_ctor_get(x_1166, 1); lean_inc(x_1168); lean_dec(x_1166); -x_1169 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_1169 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_1170 = l_unreachable_x21___rarg(x_1169); x_1171 = lean_apply_2(x_1170, x_2, x_1168); return x_1171; @@ -18387,7 +17947,7 @@ if (lean_is_exclusive(x_1166)) { x_1176 = lean_ctor_get(x_1172, 1); lean_inc(x_1176); lean_dec(x_1172); -x_1177 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2(x_26, x_1173, x_1176); +x_1177 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2(x_26, x_1173, x_1176); if (lean_is_scalar(x_1175)) { x_1178 = lean_alloc_ctor(0, 2, 0); } else { @@ -18413,7 +17973,7 @@ if (lean_is_exclusive(x_1166)) { x_1181 = lean_ctor_get(x_1172, 1); lean_inc(x_1181); lean_dec(x_1172); -x_1182 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__3(x_26, x_1173, x_1181); +x_1182 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__3(x_26, x_1173, x_1181); if (lean_is_scalar(x_1180)) { x_1183 = lean_alloc_ctor(0, 2, 0); } else { @@ -18439,7 +17999,7 @@ if (lean_is_exclusive(x_1166)) { x_1186 = lean_ctor_get(x_1172, 1); lean_inc(x_1186); lean_dec(x_1172); -x_1187 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__4(x_26, x_1173, x_1186); +x_1187 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__4(x_26, x_1173, x_1186); if (lean_is_scalar(x_1185)) { x_1188 = lean_alloc_ctor(0, 2, 0); } else { @@ -18465,7 +18025,7 @@ if (lean_is_exclusive(x_1166)) { x_1191 = lean_ctor_get(x_1172, 1); lean_inc(x_1191); lean_dec(x_1172); -x_1192 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__5(x_26, x_1173, x_1191); +x_1192 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__5(x_26, x_1173, x_1191); if (lean_is_scalar(x_1190)) { x_1193 = lean_alloc_ctor(0, 2, 0); } else { @@ -18495,7 +18055,7 @@ x_1197 = lean_ctor_get(x_1173, 0); lean_inc(x_1197); lean_dec(x_1173); x_1198 = l_Lean_mkConst(x_1197, x_1165); -x_1199 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__6(x_26, x_1198, x_1196); +x_1199 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__6(x_26, x_1198, x_1196); if (lean_is_scalar(x_1195)) { x_1200 = lean_alloc_ctor(0, 2, 0); } else { @@ -18521,7 +18081,7 @@ if (lean_is_exclusive(x_1166)) { x_1203 = lean_ctor_get(x_1172, 1); lean_inc(x_1203); lean_dec(x_1172); -x_1204 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__7(x_26, x_1173, x_1203); +x_1204 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__7(x_26, x_1173, x_1203); if (lean_is_scalar(x_1202)) { x_1205 = lean_alloc_ctor(0, 2, 0); } else { @@ -18547,7 +18107,7 @@ if (lean_is_exclusive(x_1166)) { x_1208 = lean_ctor_get(x_1172, 1); lean_inc(x_1208); lean_dec(x_1172); -x_1209 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__8(x_26, x_1173, x_1208); +x_1209 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__8(x_26, x_1173, x_1208); if (lean_is_scalar(x_1207)) { x_1210 = lean_alloc_ctor(0, 2, 0); } else { @@ -18573,7 +18133,7 @@ if (lean_is_exclusive(x_1166)) { x_1213 = lean_ctor_get(x_1172, 1); lean_inc(x_1213); lean_dec(x_1172); -x_1214 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__9(x_26, x_1173, x_1213); +x_1214 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__9(x_26, x_1173, x_1213); if (lean_is_scalar(x_1212)) { x_1215 = lean_alloc_ctor(0, 2, 0); } else { @@ -18599,7 +18159,7 @@ if (lean_is_exclusive(x_1166)) { x_1218 = lean_ctor_get(x_1172, 1); lean_inc(x_1218); lean_dec(x_1172); -x_1219 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__10(x_26, x_1173, x_1218); +x_1219 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__10(x_26, x_1173, x_1218); if (lean_is_scalar(x_1217)) { x_1220 = lean_alloc_ctor(0, 2, 0); } else { @@ -18625,7 +18185,7 @@ if (lean_is_exclusive(x_1166)) { x_1223 = lean_ctor_get(x_1172, 1); lean_inc(x_1223); lean_dec(x_1172); -x_1224 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__11(x_26, x_1173, x_1223); +x_1224 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__11(x_26, x_1173, x_1223); if (lean_is_scalar(x_1222)) { x_1225 = lean_alloc_ctor(0, 2, 0); } else { @@ -18651,7 +18211,7 @@ if (lean_is_exclusive(x_1166)) { x_1228 = lean_ctor_get(x_1172, 1); lean_inc(x_1228); lean_dec(x_1172); -x_1229 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__12(x_26, x_1173, x_1228); +x_1229 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__12(x_26, x_1173, x_1228); if (lean_is_scalar(x_1227)) { x_1230 = lean_alloc_ctor(0, 2, 0); } else { @@ -18677,7 +18237,7 @@ if (lean_is_exclusive(x_1166)) { x_1233 = lean_ctor_get(x_1172, 1); lean_inc(x_1233); lean_dec(x_1172); -x_1234 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__13(x_26, x_1173, x_1233); +x_1234 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__13(x_26, x_1173, x_1233); if (lean_is_scalar(x_1232)) { x_1235 = lean_alloc_ctor(0, 2, 0); } else { @@ -18703,7 +18263,7 @@ if (lean_is_exclusive(x_1166)) { x_1238 = lean_ctor_get(x_1172, 1); lean_inc(x_1238); lean_dec(x_1172); -x_1239 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__14(x_26, x_1173, x_1238); +x_1239 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__14(x_26, x_1173, x_1238); if (lean_is_scalar(x_1237)) { x_1240 = lean_alloc_ctor(0, 2, 0); } else { @@ -18747,7 +18307,7 @@ else lean_object* x_1245; lean_object* x_1246; lean_object* x_1247; lean_dec(x_1162); lean_dec(x_1); -x_1245 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_1245 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_1246 = l_unreachable_x21___rarg(x_1245); x_1247 = lean_apply_2(x_1246, x_2, x_3); return x_1247; @@ -18817,7 +18377,7 @@ x_1260 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1260, 0, x_1259); x_1261 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_1261, 0, x_1260); -x_1262 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_1262 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_1263 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_1263, 0, x_1262); lean_ctor_set(x_1263, 1, x_1261); @@ -18855,7 +18415,7 @@ x_1271 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1271, 0, x_1270); x_1272 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_1272, 0, x_1271); -x_1273 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_1273 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_1274 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_1274, 0, x_1273); lean_ctor_set(x_1274, 1, x_1272); @@ -18913,12 +18473,12 @@ if (x_1293 == 0) { lean_object* x_1294; uint8_t x_1295; lean_dec(x_4); -x_1294 = l_Lean_Parser_Term_str___elambda__1___closed__1; +x_1294 = l_Lean_String_HasQuote___closed__1; x_1295 = lean_string_dec_eq(x_27, x_1294); if (x_1295 == 0) { lean_object* x_1296; uint8_t x_1297; -x_1296 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_1296 = l_Lean_Nat_HasQuote___closed__1; x_1297 = lean_string_dec_eq(x_27, x_1296); if (x_1297 == 0) { @@ -18944,7 +18504,7 @@ x_1302 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1302, 0, x_1301); x_1303 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_1303, 0, x_1302); -x_1304 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_1304 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_1305 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_1305, 0, x_1304); lean_ctor_set(x_1305, 1, x_1303); @@ -18969,7 +18529,7 @@ lean_dec(x_1308); if (lean_obj_tag(x_1310) == 0) { lean_object* x_1311; lean_object* x_1312; -x_1311 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5; +x_1311 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5; x_1312 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_1312, 0, x_1311); lean_ctor_set(x_1312, 1, x_3); @@ -19005,7 +18565,7 @@ lean_dec(x_1317); if (lean_obj_tag(x_1318) == 0) { lean_object* x_1319; lean_object* x_1320; -x_1319 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6; +x_1319 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6; x_1320 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_1320, 0, x_1319); lean_ctor_set(x_1320, 1, x_3); @@ -19039,12 +18599,12 @@ x_1326 = lean_array_get(x_1324, x_4, x_1325); x_1327 = lean_unsigned_to_nat(2u); x_1328 = lean_array_get(x_1324, x_4, x_1327); lean_dec(x_4); -x_1329 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___boxed), 6, 3); +x_1329 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___boxed), 6, 3); lean_closure_set(x_1329, 0, x_26); lean_closure_set(x_1329, 1, x_1326); lean_closure_set(x_1329, 2, x_1328); x_1330 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_1331 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_1331 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_1331, 0, x_1330); lean_closure_set(x_1331, 1, x_1329); x_1332 = l_Lean_Unhygienic_run___rarg(x_1331); @@ -19066,12 +18626,12 @@ x_1336 = lean_array_get(x_1334, x_4, x_1335); x_1337 = lean_unsigned_to_nat(2u); x_1338 = lean_array_get(x_1334, x_4, x_1337); lean_dec(x_4); -x_1339 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___boxed), 6, 3); +x_1339 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___boxed), 6, 3); lean_closure_set(x_1339, 0, x_26); lean_closure_set(x_1339, 1, x_1336); lean_closure_set(x_1339, 2, x_1338); x_1340 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_1341 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_1341 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_1341, 0, x_1340); lean_closure_set(x_1341, 1, x_1339); x_1342 = l_Lean_Unhygienic_run___rarg(x_1341); @@ -19093,12 +18653,12 @@ x_1346 = lean_array_get(x_1344, x_4, x_1345); x_1347 = lean_unsigned_to_nat(2u); x_1348 = lean_array_get(x_1344, x_4, x_1347); lean_dec(x_4); -x_1349 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___boxed), 6, 3); +x_1349 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___boxed), 6, 3); lean_closure_set(x_1349, 0, x_26); lean_closure_set(x_1349, 1, x_1346); lean_closure_set(x_1349, 2, x_1348); x_1350 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_1351 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_1351 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_1351, 0, x_1350); lean_closure_set(x_1351, 1, x_1349); x_1352 = l_Lean_Unhygienic_run___rarg(x_1351); @@ -19166,13 +18726,13 @@ x_1374 = lean_array_get(x_1370, x_4, x_1373); x_1375 = lean_unsigned_to_nat(6u); x_1376 = lean_array_get(x_1370, x_4, x_1375); lean_dec(x_4); -x_1377 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___boxed), 7, 4); +x_1377 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___boxed), 7, 4); lean_closure_set(x_1377, 0, x_26); lean_closure_set(x_1377, 1, x_1372); lean_closure_set(x_1377, 2, x_1374); lean_closure_set(x_1377, 3, x_1376); x_1378 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_1379 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_1379 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_1379, 0, x_1378); lean_closure_set(x_1379, 1, x_1377); x_1380 = l_Lean_Unhygienic_run___rarg(x_1379); @@ -19192,7 +18752,7 @@ x_1382 = l_Lean_Syntax_inhabited; x_1383 = lean_unsigned_to_nat(0u); x_1384 = lean_array_get(x_1382, x_4, x_1383); lean_inc(x_2); -x_1385 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1384, x_2, x_3); +x_1385 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1384, x_2, x_3); if (lean_obj_tag(x_1385) == 0) { 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; @@ -19207,7 +18767,7 @@ lean_dec(x_4); x_1390 = l_Lean_Syntax_getArgs(x_1389); lean_dec(x_1389); x_1391 = x_1390; -x_1392 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__1), 4, 2); +x_1392 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__1), 4, 2); lean_closure_set(x_1392, 0, x_1383); lean_closure_set(x_1392, 1, x_1391); x_1393 = x_1392; @@ -19332,7 +18892,7 @@ block_1465: { lean_object* x_1419; lean_inc(x_2); -x_1419 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1415, x_2, x_3); +x_1419 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1415, x_2, x_3); if (lean_obj_tag(x_1419) == 0) { 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; uint8_t x_1437; uint8_t x_1438; uint8_t 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; @@ -19347,7 +18907,7 @@ lean_inc(x_1423); x_1424 = lean_ctor_get(x_1422, 1); lean_inc(x_1424); lean_dec(x_1422); -x_1425 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_1425 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; lean_inc_n(x_1418, 2); x_1426 = lean_local_ctx_mk_let_decl(x_1423, x_1418, x_1418, x_1425, x_1420); x_1427 = lean_ctor_get(x_2, 0); @@ -19437,7 +18997,7 @@ lean_ctor_set(x_1447, 9, x_1436); lean_ctor_set_uint8(x_1447, sizeof(void*)*10, x_1437); lean_ctor_set_uint8(x_1447, sizeof(void*)*10 + 1, x_1438); lean_ctor_set_uint8(x_1447, sizeof(void*)*10 + 2, x_1439); -x_1448 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1417, x_1447, x_1424); +x_1448 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1417, x_1447, x_1424); if (lean_obj_tag(x_1448) == 0) { 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; @@ -19581,7 +19141,7 @@ lean_dec(x_1489); x_1491 = l_Lean_Syntax_getArg(x_1490, x_1469); lean_dec(x_1490); lean_inc(x_2); -x_1492 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1491, x_2, x_3); +x_1492 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1491, x_2, x_3); if (lean_obj_tag(x_1492) == 0) { lean_object* x_1493; lean_object* x_1494; lean_object* x_1495; lean_object* x_1496; lean_object* x_1497; uint8_t 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; uint8_t x_1527; uint8_t x_1528; uint8_t 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; @@ -19712,7 +19272,7 @@ lean_ctor_set(x_1537, 9, x_1526); lean_ctor_set_uint8(x_1537, sizeof(void*)*10, x_1527); lean_ctor_set_uint8(x_1537, sizeof(void*)*10 + 1, x_1528); lean_ctor_set_uint8(x_1537, sizeof(void*)*10 + 2, x_1529); -x_1538 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1516, x_1537, x_1504); +x_1538 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1516, x_1537, x_1504); if (lean_obj_tag(x_1538) == 0) { lean_object* x_1539; lean_object* x_1540; lean_object* x_1541; lean_object* x_1542; lean_object* x_1543; lean_object* x_1544; lean_object* x_1545; lean_object* x_1546; @@ -19812,7 +19372,7 @@ lean_inc(x_1558); x_1559 = lean_ctor_get(x_1557, 1); lean_inc(x_1559); lean_dec(x_1557); -x_1560 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_1560 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_1561 = 0; lean_inc_n(x_1556, 2); x_1562 = lean_local_ctx_mk_local_decl(x_1558, x_1556, x_1556, x_1560, x_1561); @@ -19929,7 +19489,7 @@ lean_ctor_set(x_1600, 9, x_1589); lean_ctor_set_uint8(x_1600, sizeof(void*)*10, x_1590); lean_ctor_set_uint8(x_1600, sizeof(void*)*10 + 1, x_1591); lean_ctor_set_uint8(x_1600, sizeof(void*)*10 + 2, x_1592); -x_1601 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1579, x_1600, x_1567); +x_1601 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1579, x_1600, x_1567); if (lean_obj_tag(x_1601) == 0) { 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; @@ -19999,7 +19559,7 @@ lean_inc(x_1616); x_1617 = lean_ctor_get(x_1615, 1); lean_inc(x_1617); lean_dec(x_1615); -x_1618 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_1618 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_1619 = 0; lean_inc_n(x_1614, 2); x_1620 = lean_local_ctx_mk_local_decl(x_1616, x_1614, x_1614, x_1618, x_1619); @@ -20116,7 +19676,7 @@ lean_ctor_set(x_1658, 9, x_1647); lean_ctor_set_uint8(x_1658, sizeof(void*)*10, x_1648); lean_ctor_set_uint8(x_1658, sizeof(void*)*10 + 1, x_1649); lean_ctor_set_uint8(x_1658, sizeof(void*)*10 + 2, x_1650); -x_1659 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1637, x_1658, x_1625); +x_1659 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1637, x_1658, x_1625); if (lean_obj_tag(x_1659) == 0) { lean_object* x_1660; lean_object* x_1661; lean_object* x_1662; lean_object* x_1663; lean_object* x_1664; lean_object* x_1665; lean_object* x_1666; lean_object* x_1667; @@ -20217,7 +19777,7 @@ lean_object* x_1681; lean_object* x_1682; lean_object* x_1683; lean_object* x_16 x_1681 = lean_ctor_get(x_1679, 1); lean_inc(x_1681); lean_dec(x_1679); -x_1682 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_1682 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_1683 = l_unreachable_x21___rarg(x_1682); x_1684 = lean_apply_2(x_1683, x_2, x_1681); return x_1684; @@ -20248,7 +19808,7 @@ if (lean_is_exclusive(x_1679)) { x_1689 = lean_ctor_get(x_1685, 1); lean_inc(x_1689); lean_dec(x_1685); -x_1690 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2(x_26, x_1686, x_1689); +x_1690 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2(x_26, x_1686, x_1689); if (lean_is_scalar(x_1688)) { x_1691 = lean_alloc_ctor(0, 2, 0); } else { @@ -20274,7 +19834,7 @@ if (lean_is_exclusive(x_1679)) { x_1694 = lean_ctor_get(x_1685, 1); lean_inc(x_1694); lean_dec(x_1685); -x_1695 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__3(x_26, x_1686, x_1694); +x_1695 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__3(x_26, x_1686, x_1694); if (lean_is_scalar(x_1693)) { x_1696 = lean_alloc_ctor(0, 2, 0); } else { @@ -20300,7 +19860,7 @@ if (lean_is_exclusive(x_1679)) { x_1699 = lean_ctor_get(x_1685, 1); lean_inc(x_1699); lean_dec(x_1685); -x_1700 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__4(x_26, x_1686, x_1699); +x_1700 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__4(x_26, x_1686, x_1699); if (lean_is_scalar(x_1698)) { x_1701 = lean_alloc_ctor(0, 2, 0); } else { @@ -20326,7 +19886,7 @@ if (lean_is_exclusive(x_1679)) { x_1704 = lean_ctor_get(x_1685, 1); lean_inc(x_1704); lean_dec(x_1685); -x_1705 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__5(x_26, x_1686, x_1704); +x_1705 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__5(x_26, x_1686, x_1704); if (lean_is_scalar(x_1703)) { x_1706 = lean_alloc_ctor(0, 2, 0); } else { @@ -20356,7 +19916,7 @@ x_1710 = lean_ctor_get(x_1686, 0); lean_inc(x_1710); lean_dec(x_1686); x_1711 = l_Lean_mkConst(x_1710, x_1678); -x_1712 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__6(x_26, x_1711, x_1709); +x_1712 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__6(x_26, x_1711, x_1709); if (lean_is_scalar(x_1708)) { x_1713 = lean_alloc_ctor(0, 2, 0); } else { @@ -20382,7 +19942,7 @@ if (lean_is_exclusive(x_1679)) { x_1716 = lean_ctor_get(x_1685, 1); lean_inc(x_1716); lean_dec(x_1685); -x_1717 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__7(x_26, x_1686, x_1716); +x_1717 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__7(x_26, x_1686, x_1716); if (lean_is_scalar(x_1715)) { x_1718 = lean_alloc_ctor(0, 2, 0); } else { @@ -20408,7 +19968,7 @@ if (lean_is_exclusive(x_1679)) { x_1721 = lean_ctor_get(x_1685, 1); lean_inc(x_1721); lean_dec(x_1685); -x_1722 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__8(x_26, x_1686, x_1721); +x_1722 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__8(x_26, x_1686, x_1721); if (lean_is_scalar(x_1720)) { x_1723 = lean_alloc_ctor(0, 2, 0); } else { @@ -20434,7 +19994,7 @@ if (lean_is_exclusive(x_1679)) { x_1726 = lean_ctor_get(x_1685, 1); lean_inc(x_1726); lean_dec(x_1685); -x_1727 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__9(x_26, x_1686, x_1726); +x_1727 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__9(x_26, x_1686, x_1726); if (lean_is_scalar(x_1725)) { x_1728 = lean_alloc_ctor(0, 2, 0); } else { @@ -20460,7 +20020,7 @@ if (lean_is_exclusive(x_1679)) { x_1731 = lean_ctor_get(x_1685, 1); lean_inc(x_1731); lean_dec(x_1685); -x_1732 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__10(x_26, x_1686, x_1731); +x_1732 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__10(x_26, x_1686, x_1731); if (lean_is_scalar(x_1730)) { x_1733 = lean_alloc_ctor(0, 2, 0); } else { @@ -20486,7 +20046,7 @@ if (lean_is_exclusive(x_1679)) { x_1736 = lean_ctor_get(x_1685, 1); lean_inc(x_1736); lean_dec(x_1685); -x_1737 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__11(x_26, x_1686, x_1736); +x_1737 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__11(x_26, x_1686, x_1736); if (lean_is_scalar(x_1735)) { x_1738 = lean_alloc_ctor(0, 2, 0); } else { @@ -20512,7 +20072,7 @@ if (lean_is_exclusive(x_1679)) { x_1741 = lean_ctor_get(x_1685, 1); lean_inc(x_1741); lean_dec(x_1685); -x_1742 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__12(x_26, x_1686, x_1741); +x_1742 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__12(x_26, x_1686, x_1741); if (lean_is_scalar(x_1740)) { x_1743 = lean_alloc_ctor(0, 2, 0); } else { @@ -20538,7 +20098,7 @@ if (lean_is_exclusive(x_1679)) { x_1746 = lean_ctor_get(x_1685, 1); lean_inc(x_1746); lean_dec(x_1685); -x_1747 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__13(x_26, x_1686, x_1746); +x_1747 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__13(x_26, x_1686, x_1746); if (lean_is_scalar(x_1745)) { x_1748 = lean_alloc_ctor(0, 2, 0); } else { @@ -20564,7 +20124,7 @@ if (lean_is_exclusive(x_1679)) { x_1751 = lean_ctor_get(x_1685, 1); lean_inc(x_1751); lean_dec(x_1685); -x_1752 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__14(x_26, x_1686, x_1751); +x_1752 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__14(x_26, x_1686, x_1751); if (lean_is_scalar(x_1750)) { x_1753 = lean_alloc_ctor(0, 2, 0); } else { @@ -20608,7 +20168,7 @@ else lean_object* x_1758; lean_object* x_1759; lean_object* x_1760; lean_dec(x_1675); lean_dec(x_1); -x_1758 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_1758 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_1759 = l_unreachable_x21___rarg(x_1758); x_1760 = lean_apply_2(x_1759, x_2, x_3); return x_1760; @@ -20697,7 +20257,7 @@ x_1777 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1777, 0, x_1776); x_1778 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_1778, 0, x_1777); -x_1779 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_1779 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_1780 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_1780, 0, x_1779); lean_ctor_set(x_1780, 1, x_1778); @@ -20742,7 +20302,7 @@ x_1789 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1789, 0, x_1788); x_1790 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_1790, 0, x_1789); -x_1791 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_1791 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_1792 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_1792, 0, x_1791); lean_ctor_set(x_1792, 1, x_1790); @@ -20800,12 +20360,12 @@ if (x_1811 == 0) { lean_object* x_1812; uint8_t x_1813; lean_dec(x_4); -x_1812 = l_Lean_Parser_Term_str___elambda__1___closed__1; +x_1812 = l_Lean_String_HasQuote___closed__1; x_1813 = lean_string_dec_eq(x_27, x_1812); if (x_1813 == 0) { lean_object* x_1814; uint8_t x_1815; -x_1814 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_1814 = l_Lean_Nat_HasQuote___closed__1; x_1815 = lean_string_dec_eq(x_27, x_1814); if (x_1815 == 0) { @@ -20838,7 +20398,7 @@ x_1821 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_1821, 0, x_1820); x_1822 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_1822, 0, x_1821); -x_1823 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_1823 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_1824 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_1824, 0, x_1823); lean_ctor_set(x_1824, 1, x_1822); @@ -20863,7 +20423,7 @@ lean_dec(x_1827); if (lean_obj_tag(x_1829) == 0) { lean_object* x_1830; lean_object* x_1831; -x_1830 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5; +x_1830 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5; x_1831 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_1831, 0, x_1830); lean_ctor_set(x_1831, 1, x_3); @@ -20899,7 +20459,7 @@ lean_dec(x_1836); if (lean_obj_tag(x_1837) == 0) { lean_object* x_1838; lean_object* x_1839; -x_1838 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6; +x_1838 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6; x_1839 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_1839, 0, x_1838); lean_ctor_set(x_1839, 1, x_3); @@ -20933,12 +20493,12 @@ x_1845 = lean_array_get(x_1843, x_4, x_1844); x_1846 = lean_unsigned_to_nat(2u); x_1847 = lean_array_get(x_1843, x_4, x_1846); lean_dec(x_4); -x_1848 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___boxed), 6, 3); +x_1848 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___boxed), 6, 3); lean_closure_set(x_1848, 0, x_26); lean_closure_set(x_1848, 1, x_1845); lean_closure_set(x_1848, 2, x_1847); x_1849 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_1850 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_1850 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_1850, 0, x_1849); lean_closure_set(x_1850, 1, x_1848); x_1851 = l_Lean_Unhygienic_run___rarg(x_1850); @@ -20960,12 +20520,12 @@ x_1855 = lean_array_get(x_1853, x_4, x_1854); x_1856 = lean_unsigned_to_nat(2u); x_1857 = lean_array_get(x_1853, x_4, x_1856); lean_dec(x_4); -x_1858 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___boxed), 6, 3); +x_1858 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___boxed), 6, 3); lean_closure_set(x_1858, 0, x_26); lean_closure_set(x_1858, 1, x_1855); lean_closure_set(x_1858, 2, x_1857); x_1859 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_1860 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_1860 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_1860, 0, x_1859); lean_closure_set(x_1860, 1, x_1858); x_1861 = l_Lean_Unhygienic_run___rarg(x_1860); @@ -20987,12 +20547,12 @@ x_1865 = lean_array_get(x_1863, x_4, x_1864); x_1866 = lean_unsigned_to_nat(2u); x_1867 = lean_array_get(x_1863, x_4, x_1866); lean_dec(x_4); -x_1868 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___boxed), 6, 3); +x_1868 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___boxed), 6, 3); lean_closure_set(x_1868, 0, x_26); lean_closure_set(x_1868, 1, x_1865); lean_closure_set(x_1868, 2, x_1867); x_1869 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_1870 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_1870 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_1870, 0, x_1869); lean_closure_set(x_1870, 1, x_1868); x_1871 = l_Lean_Unhygienic_run___rarg(x_1870); @@ -21060,13 +20620,13 @@ x_1893 = lean_array_get(x_1889, x_4, x_1892); x_1894 = lean_unsigned_to_nat(6u); x_1895 = lean_array_get(x_1889, x_4, x_1894); lean_dec(x_4); -x_1896 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___boxed), 7, 4); +x_1896 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___boxed), 7, 4); lean_closure_set(x_1896, 0, x_26); lean_closure_set(x_1896, 1, x_1891); lean_closure_set(x_1896, 2, x_1893); lean_closure_set(x_1896, 3, x_1895); x_1897 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_1898 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_1898 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_1898, 0, x_1897); lean_closure_set(x_1898, 1, x_1896); x_1899 = l_Lean_Unhygienic_run___rarg(x_1898); @@ -21086,7 +20646,7 @@ x_1901 = l_Lean_Syntax_inhabited; x_1902 = lean_unsigned_to_nat(0u); x_1903 = lean_array_get(x_1901, x_4, x_1902); lean_inc(x_2); -x_1904 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1903, x_2, x_3); +x_1904 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1903, x_2, x_3); if (lean_obj_tag(x_1904) == 0) { lean_object* x_1905; lean_object* x_1906; lean_object* x_1907; lean_object* x_1908; lean_object* x_1909; lean_object* x_1910; lean_object* x_1911; lean_object* x_1912; lean_object* x_1913; @@ -21101,7 +20661,7 @@ lean_dec(x_4); x_1909 = l_Lean_Syntax_getArgs(x_1908); lean_dec(x_1908); x_1910 = x_1909; -x_1911 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__1), 4, 2); +x_1911 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__1), 4, 2); lean_closure_set(x_1911, 0, x_1902); lean_closure_set(x_1911, 1, x_1910); x_1912 = x_1911; @@ -21226,7 +20786,7 @@ block_1984: { lean_object* x_1938; lean_inc(x_2); -x_1938 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1934, x_2, x_3); +x_1938 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1934, x_2, x_3); if (lean_obj_tag(x_1938) == 0) { lean_object* x_1939; lean_object* x_1940; lean_object* x_1941; lean_object* x_1942; lean_object* x_1943; lean_object* x_1944; lean_object* x_1945; lean_object* x_1946; lean_object* x_1947; lean_object* x_1948; lean_object* x_1949; lean_object* x_1950; lean_object* x_1951; lean_object* x_1952; lean_object* x_1953; lean_object* x_1954; lean_object* x_1955; uint8_t x_1956; uint8_t x_1957; uint8_t x_1958; lean_object* x_1959; lean_object* x_1960; lean_object* x_1961; lean_object* x_1962; lean_object* x_1963; lean_object* x_1964; lean_object* x_1965; lean_object* x_1966; lean_object* x_1967; @@ -21241,7 +20801,7 @@ lean_inc(x_1942); x_1943 = lean_ctor_get(x_1941, 1); lean_inc(x_1943); lean_dec(x_1941); -x_1944 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_1944 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; lean_inc_n(x_1937, 2); x_1945 = lean_local_ctx_mk_let_decl(x_1942, x_1937, x_1937, x_1944, x_1939); x_1946 = lean_ctor_get(x_2, 0); @@ -21331,7 +20891,7 @@ lean_ctor_set(x_1966, 9, x_1955); lean_ctor_set_uint8(x_1966, sizeof(void*)*10, x_1956); lean_ctor_set_uint8(x_1966, sizeof(void*)*10 + 1, x_1957); lean_ctor_set_uint8(x_1966, sizeof(void*)*10 + 2, x_1958); -x_1967 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1936, x_1966, x_1943); +x_1967 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1936, x_1966, x_1943); if (lean_obj_tag(x_1967) == 0) { lean_object* x_1968; lean_object* x_1969; lean_object* x_1970; lean_object* x_1971; lean_object* x_1972; lean_object* x_1973; lean_object* x_1974; lean_object* x_1975; @@ -21475,7 +21035,7 @@ lean_dec(x_2008); x_2010 = l_Lean_Syntax_getArg(x_2009, x_1988); lean_dec(x_2009); lean_inc(x_2); -x_2011 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2010, x_2, x_3); +x_2011 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2010, x_2, x_3); if (lean_obj_tag(x_2011) == 0) { lean_object* x_2012; lean_object* x_2013; lean_object* x_2014; lean_object* x_2015; lean_object* x_2016; uint8_t x_2017; lean_object* x_2018; lean_object* x_2019; lean_object* x_2020; lean_object* x_2021; lean_object* x_2022; lean_object* x_2023; lean_object* x_2024; lean_object* x_2025; lean_object* x_2026; lean_object* x_2027; lean_object* x_2028; lean_object* x_2029; lean_object* x_2030; lean_object* x_2031; lean_object* x_2032; lean_object* x_2033; lean_object* x_2034; lean_object* x_2035; lean_object* x_2036; lean_object* x_2037; lean_object* x_2038; lean_object* x_2039; lean_object* x_2040; lean_object* x_2041; lean_object* x_2042; lean_object* x_2043; lean_object* x_2044; lean_object* x_2045; uint8_t x_2046; uint8_t x_2047; uint8_t x_2048; lean_object* x_2049; lean_object* x_2050; lean_object* x_2051; lean_object* x_2052; lean_object* x_2053; lean_object* x_2054; lean_object* x_2055; lean_object* x_2056; lean_object* x_2057; @@ -21606,7 +21166,7 @@ lean_ctor_set(x_2056, 9, x_2045); lean_ctor_set_uint8(x_2056, sizeof(void*)*10, x_2046); lean_ctor_set_uint8(x_2056, sizeof(void*)*10 + 1, x_2047); lean_ctor_set_uint8(x_2056, sizeof(void*)*10 + 2, x_2048); -x_2057 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2035, x_2056, x_2023); +x_2057 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2035, x_2056, x_2023); if (lean_obj_tag(x_2057) == 0) { lean_object* x_2058; lean_object* x_2059; lean_object* x_2060; lean_object* x_2061; lean_object* x_2062; lean_object* x_2063; lean_object* x_2064; lean_object* x_2065; @@ -21706,7 +21266,7 @@ lean_inc(x_2077); x_2078 = lean_ctor_get(x_2076, 1); lean_inc(x_2078); lean_dec(x_2076); -x_2079 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_2079 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_2080 = 0; lean_inc_n(x_2075, 2); x_2081 = lean_local_ctx_mk_local_decl(x_2077, x_2075, x_2075, x_2079, x_2080); @@ -21823,7 +21383,7 @@ lean_ctor_set(x_2119, 9, x_2108); lean_ctor_set_uint8(x_2119, sizeof(void*)*10, x_2109); lean_ctor_set_uint8(x_2119, sizeof(void*)*10 + 1, x_2110); lean_ctor_set_uint8(x_2119, sizeof(void*)*10 + 2, x_2111); -x_2120 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2098, x_2119, x_2086); +x_2120 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2098, x_2119, x_2086); if (lean_obj_tag(x_2120) == 0) { lean_object* x_2121; lean_object* x_2122; lean_object* x_2123; lean_object* x_2124; lean_object* x_2125; lean_object* x_2126; lean_object* x_2127; lean_object* x_2128; @@ -21893,7 +21453,7 @@ lean_inc(x_2135); x_2136 = lean_ctor_get(x_2134, 1); lean_inc(x_2136); lean_dec(x_2134); -x_2137 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_2137 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_2138 = 0; lean_inc_n(x_2133, 2); x_2139 = lean_local_ctx_mk_local_decl(x_2135, x_2133, x_2133, x_2137, x_2138); @@ -22010,7 +21570,7 @@ lean_ctor_set(x_2177, 9, x_2166); lean_ctor_set_uint8(x_2177, sizeof(void*)*10, x_2167); lean_ctor_set_uint8(x_2177, sizeof(void*)*10 + 1, x_2168); lean_ctor_set_uint8(x_2177, sizeof(void*)*10 + 2, x_2169); -x_2178 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2156, x_2177, x_2144); +x_2178 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2156, x_2177, x_2144); if (lean_obj_tag(x_2178) == 0) { lean_object* x_2179; lean_object* x_2180; lean_object* x_2181; lean_object* x_2182; lean_object* x_2183; lean_object* x_2184; lean_object* x_2185; lean_object* x_2186; @@ -22111,7 +21671,7 @@ lean_object* x_2200; lean_object* x_2201; lean_object* x_2202; lean_object* x_22 x_2200 = lean_ctor_get(x_2198, 1); lean_inc(x_2200); lean_dec(x_2198); -x_2201 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_2201 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_2202 = l_unreachable_x21___rarg(x_2201); x_2203 = lean_apply_2(x_2202, x_2, x_2200); return x_2203; @@ -22142,7 +21702,7 @@ if (lean_is_exclusive(x_2198)) { x_2208 = lean_ctor_get(x_2204, 1); lean_inc(x_2208); lean_dec(x_2204); -x_2209 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2(x_26, x_2205, x_2208); +x_2209 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2(x_26, x_2205, x_2208); if (lean_is_scalar(x_2207)) { x_2210 = lean_alloc_ctor(0, 2, 0); } else { @@ -22168,7 +21728,7 @@ if (lean_is_exclusive(x_2198)) { x_2213 = lean_ctor_get(x_2204, 1); lean_inc(x_2213); lean_dec(x_2204); -x_2214 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__3(x_26, x_2205, x_2213); +x_2214 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__3(x_26, x_2205, x_2213); if (lean_is_scalar(x_2212)) { x_2215 = lean_alloc_ctor(0, 2, 0); } else { @@ -22194,7 +21754,7 @@ if (lean_is_exclusive(x_2198)) { x_2218 = lean_ctor_get(x_2204, 1); lean_inc(x_2218); lean_dec(x_2204); -x_2219 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__4(x_26, x_2205, x_2218); +x_2219 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__4(x_26, x_2205, x_2218); if (lean_is_scalar(x_2217)) { x_2220 = lean_alloc_ctor(0, 2, 0); } else { @@ -22220,7 +21780,7 @@ if (lean_is_exclusive(x_2198)) { x_2223 = lean_ctor_get(x_2204, 1); lean_inc(x_2223); lean_dec(x_2204); -x_2224 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__5(x_26, x_2205, x_2223); +x_2224 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__5(x_26, x_2205, x_2223); if (lean_is_scalar(x_2222)) { x_2225 = lean_alloc_ctor(0, 2, 0); } else { @@ -22250,7 +21810,7 @@ x_2229 = lean_ctor_get(x_2205, 0); lean_inc(x_2229); lean_dec(x_2205); x_2230 = l_Lean_mkConst(x_2229, x_2197); -x_2231 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__6(x_26, x_2230, x_2228); +x_2231 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__6(x_26, x_2230, x_2228); if (lean_is_scalar(x_2227)) { x_2232 = lean_alloc_ctor(0, 2, 0); } else { @@ -22276,7 +21836,7 @@ if (lean_is_exclusive(x_2198)) { x_2235 = lean_ctor_get(x_2204, 1); lean_inc(x_2235); lean_dec(x_2204); -x_2236 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__7(x_26, x_2205, x_2235); +x_2236 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__7(x_26, x_2205, x_2235); if (lean_is_scalar(x_2234)) { x_2237 = lean_alloc_ctor(0, 2, 0); } else { @@ -22302,7 +21862,7 @@ if (lean_is_exclusive(x_2198)) { x_2240 = lean_ctor_get(x_2204, 1); lean_inc(x_2240); lean_dec(x_2204); -x_2241 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__8(x_26, x_2205, x_2240); +x_2241 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__8(x_26, x_2205, x_2240); if (lean_is_scalar(x_2239)) { x_2242 = lean_alloc_ctor(0, 2, 0); } else { @@ -22328,7 +21888,7 @@ if (lean_is_exclusive(x_2198)) { x_2245 = lean_ctor_get(x_2204, 1); lean_inc(x_2245); lean_dec(x_2204); -x_2246 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__9(x_26, x_2205, x_2245); +x_2246 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__9(x_26, x_2205, x_2245); if (lean_is_scalar(x_2244)) { x_2247 = lean_alloc_ctor(0, 2, 0); } else { @@ -22354,7 +21914,7 @@ if (lean_is_exclusive(x_2198)) { x_2250 = lean_ctor_get(x_2204, 1); lean_inc(x_2250); lean_dec(x_2204); -x_2251 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__10(x_26, x_2205, x_2250); +x_2251 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__10(x_26, x_2205, x_2250); if (lean_is_scalar(x_2249)) { x_2252 = lean_alloc_ctor(0, 2, 0); } else { @@ -22380,7 +21940,7 @@ if (lean_is_exclusive(x_2198)) { x_2255 = lean_ctor_get(x_2204, 1); lean_inc(x_2255); lean_dec(x_2204); -x_2256 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__11(x_26, x_2205, x_2255); +x_2256 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__11(x_26, x_2205, x_2255); if (lean_is_scalar(x_2254)) { x_2257 = lean_alloc_ctor(0, 2, 0); } else { @@ -22406,7 +21966,7 @@ if (lean_is_exclusive(x_2198)) { x_2260 = lean_ctor_get(x_2204, 1); lean_inc(x_2260); lean_dec(x_2204); -x_2261 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__12(x_26, x_2205, x_2260); +x_2261 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__12(x_26, x_2205, x_2260); if (lean_is_scalar(x_2259)) { x_2262 = lean_alloc_ctor(0, 2, 0); } else { @@ -22432,7 +21992,7 @@ if (lean_is_exclusive(x_2198)) { x_2265 = lean_ctor_get(x_2204, 1); lean_inc(x_2265); lean_dec(x_2204); -x_2266 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__13(x_26, x_2205, x_2265); +x_2266 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__13(x_26, x_2205, x_2265); if (lean_is_scalar(x_2264)) { x_2267 = lean_alloc_ctor(0, 2, 0); } else { @@ -22458,7 +22018,7 @@ if (lean_is_exclusive(x_2198)) { x_2270 = lean_ctor_get(x_2204, 1); lean_inc(x_2270); lean_dec(x_2204); -x_2271 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__14(x_26, x_2205, x_2270); +x_2271 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__14(x_26, x_2205, x_2270); if (lean_is_scalar(x_2269)) { x_2272 = lean_alloc_ctor(0, 2, 0); } else { @@ -22502,7 +22062,7 @@ else lean_object* x_2277; lean_object* x_2278; lean_object* x_2279; lean_dec(x_2194); lean_dec(x_1); -x_2277 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_2277 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_2278 = l_unreachable_x21___rarg(x_2277); x_2279 = lean_apply_2(x_2278, x_2, x_3); return x_2279; @@ -22610,7 +22170,7 @@ x_2301 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2301, 0, x_2300); x_2302 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2302, 0, x_2301); -x_2303 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_2303 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_2304 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_2304, 0, x_2303); lean_ctor_set(x_2304, 1, x_2302); @@ -22662,7 +22222,7 @@ x_2314 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2314, 0, x_2313); x_2315 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2315, 0, x_2314); -x_2316 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_2316 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_2317 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_2317, 0, x_2316); lean_ctor_set(x_2317, 1, x_2315); @@ -22720,12 +22280,12 @@ if (x_2336 == 0) { lean_object* x_2337; uint8_t x_2338; lean_dec(x_4); -x_2337 = l_Lean_Parser_Term_str___elambda__1___closed__1; +x_2337 = l_Lean_String_HasQuote___closed__1; x_2338 = lean_string_dec_eq(x_27, x_2337); if (x_2338 == 0) { lean_object* x_2339; uint8_t x_2340; -x_2339 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_2339 = l_Lean_Nat_HasQuote___closed__1; x_2340 = lean_string_dec_eq(x_27, x_2339); if (x_2340 == 0) { @@ -22764,7 +22324,7 @@ x_2347 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2347, 0, x_2346); x_2348 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2348, 0, x_2347); -x_2349 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_2349 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_2350 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_2350, 0, x_2349); lean_ctor_set(x_2350, 1, x_2348); @@ -22789,7 +22349,7 @@ lean_dec(x_2353); if (lean_obj_tag(x_2355) == 0) { lean_object* x_2356; lean_object* x_2357; -x_2356 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5; +x_2356 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5; x_2357 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_2357, 0, x_2356); lean_ctor_set(x_2357, 1, x_3); @@ -22825,7 +22385,7 @@ lean_dec(x_2362); if (lean_obj_tag(x_2363) == 0) { lean_object* x_2364; lean_object* x_2365; -x_2364 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6; +x_2364 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6; x_2365 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_2365, 0, x_2364); lean_ctor_set(x_2365, 1, x_3); @@ -22859,12 +22419,12 @@ x_2371 = lean_array_get(x_2369, x_4, x_2370); x_2372 = lean_unsigned_to_nat(2u); x_2373 = lean_array_get(x_2369, x_4, x_2372); lean_dec(x_4); -x_2374 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___boxed), 6, 3); +x_2374 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___boxed), 6, 3); lean_closure_set(x_2374, 0, x_26); lean_closure_set(x_2374, 1, x_2371); lean_closure_set(x_2374, 2, x_2373); x_2375 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_2376 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_2376 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_2376, 0, x_2375); lean_closure_set(x_2376, 1, x_2374); x_2377 = l_Lean_Unhygienic_run___rarg(x_2376); @@ -22886,12 +22446,12 @@ x_2381 = lean_array_get(x_2379, x_4, x_2380); x_2382 = lean_unsigned_to_nat(2u); x_2383 = lean_array_get(x_2379, x_4, x_2382); lean_dec(x_4); -x_2384 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___boxed), 6, 3); +x_2384 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___boxed), 6, 3); lean_closure_set(x_2384, 0, x_26); lean_closure_set(x_2384, 1, x_2381); lean_closure_set(x_2384, 2, x_2383); x_2385 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_2386 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_2386 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_2386, 0, x_2385); lean_closure_set(x_2386, 1, x_2384); x_2387 = l_Lean_Unhygienic_run___rarg(x_2386); @@ -22913,12 +22473,12 @@ x_2391 = lean_array_get(x_2389, x_4, x_2390); x_2392 = lean_unsigned_to_nat(2u); x_2393 = lean_array_get(x_2389, x_4, x_2392); lean_dec(x_4); -x_2394 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___boxed), 6, 3); +x_2394 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___boxed), 6, 3); lean_closure_set(x_2394, 0, x_26); lean_closure_set(x_2394, 1, x_2391); lean_closure_set(x_2394, 2, x_2393); x_2395 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_2396 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_2396 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_2396, 0, x_2395); lean_closure_set(x_2396, 1, x_2394); x_2397 = l_Lean_Unhygienic_run___rarg(x_2396); @@ -22986,13 +22546,13 @@ x_2419 = lean_array_get(x_2415, x_4, x_2418); x_2420 = lean_unsigned_to_nat(6u); x_2421 = lean_array_get(x_2415, x_4, x_2420); lean_dec(x_4); -x_2422 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___boxed), 7, 4); +x_2422 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___boxed), 7, 4); lean_closure_set(x_2422, 0, x_26); lean_closure_set(x_2422, 1, x_2417); lean_closure_set(x_2422, 2, x_2419); lean_closure_set(x_2422, 3, x_2421); x_2423 = l_Lean_Unhygienic_MonadQuotation___closed__4; -x_2424 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___spec__1___rarg), 4, 2); +x_2424 = lean_alloc_closure((void*)(l_ReaderT_bind___at___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___spec__1___rarg), 4, 2); lean_closure_set(x_2424, 0, x_2423); lean_closure_set(x_2424, 1, x_2422); x_2425 = l_Lean_Unhygienic_run___rarg(x_2424); @@ -23012,7 +22572,7 @@ x_2427 = l_Lean_Syntax_inhabited; x_2428 = lean_unsigned_to_nat(0u); x_2429 = lean_array_get(x_2427, x_4, x_2428); lean_inc(x_2); -x_2430 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2429, x_2, x_3); +x_2430 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2429, x_2, x_3); if (lean_obj_tag(x_2430) == 0) { lean_object* x_2431; lean_object* x_2432; lean_object* x_2433; lean_object* x_2434; lean_object* x_2435; lean_object* x_2436; lean_object* x_2437; lean_object* x_2438; lean_object* x_2439; @@ -23027,7 +22587,7 @@ lean_dec(x_4); x_2435 = l_Lean_Syntax_getArgs(x_2434); lean_dec(x_2434); x_2436 = x_2435; -x_2437 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__1), 4, 2); +x_2437 = lean_alloc_closure((void*)(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__1), 4, 2); lean_closure_set(x_2437, 0, x_2428); lean_closure_set(x_2437, 1, x_2436); x_2438 = x_2437; @@ -23152,7 +22712,7 @@ block_2510: { lean_object* x_2464; lean_inc(x_2); -x_2464 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2460, x_2, x_3); +x_2464 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2460, x_2, x_3); if (lean_obj_tag(x_2464) == 0) { lean_object* x_2465; lean_object* x_2466; lean_object* x_2467; lean_object* x_2468; lean_object* x_2469; lean_object* x_2470; lean_object* x_2471; lean_object* x_2472; lean_object* x_2473; lean_object* x_2474; lean_object* x_2475; lean_object* x_2476; lean_object* x_2477; lean_object* x_2478; lean_object* x_2479; lean_object* x_2480; lean_object* x_2481; uint8_t x_2482; uint8_t x_2483; uint8_t x_2484; lean_object* x_2485; lean_object* x_2486; lean_object* x_2487; lean_object* x_2488; lean_object* x_2489; lean_object* x_2490; lean_object* x_2491; lean_object* x_2492; lean_object* x_2493; @@ -23167,7 +22727,7 @@ lean_inc(x_2468); x_2469 = lean_ctor_get(x_2467, 1); lean_inc(x_2469); lean_dec(x_2467); -x_2470 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_2470 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; lean_inc_n(x_2463, 2); x_2471 = lean_local_ctx_mk_let_decl(x_2468, x_2463, x_2463, x_2470, x_2465); x_2472 = lean_ctor_get(x_2, 0); @@ -23257,7 +22817,7 @@ lean_ctor_set(x_2492, 9, x_2481); lean_ctor_set_uint8(x_2492, sizeof(void*)*10, x_2482); lean_ctor_set_uint8(x_2492, sizeof(void*)*10 + 1, x_2483); lean_ctor_set_uint8(x_2492, sizeof(void*)*10 + 2, x_2484); -x_2493 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2462, x_2492, x_2469); +x_2493 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2462, x_2492, x_2469); if (lean_obj_tag(x_2493) == 0) { lean_object* x_2494; lean_object* x_2495; lean_object* x_2496; lean_object* x_2497; lean_object* x_2498; lean_object* x_2499; lean_object* x_2500; lean_object* x_2501; @@ -23401,7 +22961,7 @@ lean_dec(x_2534); x_2536 = l_Lean_Syntax_getArg(x_2535, x_2514); lean_dec(x_2535); lean_inc(x_2); -x_2537 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2536, x_2, x_3); +x_2537 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2536, x_2, x_3); if (lean_obj_tag(x_2537) == 0) { lean_object* x_2538; lean_object* x_2539; lean_object* x_2540; lean_object* x_2541; lean_object* x_2542; uint8_t x_2543; lean_object* x_2544; lean_object* x_2545; lean_object* x_2546; lean_object* x_2547; lean_object* x_2548; lean_object* x_2549; lean_object* x_2550; lean_object* x_2551; lean_object* x_2552; lean_object* x_2553; lean_object* x_2554; lean_object* x_2555; lean_object* x_2556; lean_object* x_2557; lean_object* x_2558; lean_object* x_2559; lean_object* x_2560; lean_object* x_2561; lean_object* x_2562; lean_object* x_2563; lean_object* x_2564; lean_object* x_2565; lean_object* x_2566; lean_object* x_2567; lean_object* x_2568; lean_object* x_2569; lean_object* x_2570; lean_object* x_2571; uint8_t x_2572; uint8_t x_2573; uint8_t x_2574; lean_object* x_2575; lean_object* x_2576; lean_object* x_2577; lean_object* x_2578; lean_object* x_2579; lean_object* x_2580; lean_object* x_2581; lean_object* x_2582; lean_object* x_2583; @@ -23532,7 +23092,7 @@ lean_ctor_set(x_2582, 9, x_2571); lean_ctor_set_uint8(x_2582, sizeof(void*)*10, x_2572); lean_ctor_set_uint8(x_2582, sizeof(void*)*10 + 1, x_2573); lean_ctor_set_uint8(x_2582, sizeof(void*)*10 + 2, x_2574); -x_2583 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2561, x_2582, x_2549); +x_2583 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2561, x_2582, x_2549); if (lean_obj_tag(x_2583) == 0) { lean_object* x_2584; lean_object* x_2585; lean_object* x_2586; lean_object* x_2587; lean_object* x_2588; lean_object* x_2589; lean_object* x_2590; lean_object* x_2591; @@ -23632,7 +23192,7 @@ lean_inc(x_2603); x_2604 = lean_ctor_get(x_2602, 1); lean_inc(x_2604); lean_dec(x_2602); -x_2605 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_2605 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_2606 = 0; lean_inc_n(x_2601, 2); x_2607 = lean_local_ctx_mk_local_decl(x_2603, x_2601, x_2601, x_2605, x_2606); @@ -23749,7 +23309,7 @@ lean_ctor_set(x_2645, 9, x_2634); lean_ctor_set_uint8(x_2645, sizeof(void*)*10, x_2635); lean_ctor_set_uint8(x_2645, sizeof(void*)*10 + 1, x_2636); lean_ctor_set_uint8(x_2645, sizeof(void*)*10 + 2, x_2637); -x_2646 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2624, x_2645, x_2612); +x_2646 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2624, x_2645, x_2612); if (lean_obj_tag(x_2646) == 0) { lean_object* x_2647; lean_object* x_2648; lean_object* x_2649; lean_object* x_2650; lean_object* x_2651; lean_object* x_2652; lean_object* x_2653; lean_object* x_2654; @@ -23819,7 +23379,7 @@ lean_inc(x_2661); x_2662 = lean_ctor_get(x_2660, 1); lean_inc(x_2662); lean_dec(x_2660); -x_2663 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_2663 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_2664 = 0; lean_inc_n(x_2659, 2); x_2665 = lean_local_ctx_mk_local_decl(x_2661, x_2659, x_2659, x_2663, x_2664); @@ -23936,7 +23496,7 @@ lean_ctor_set(x_2703, 9, x_2692); lean_ctor_set_uint8(x_2703, sizeof(void*)*10, x_2693); lean_ctor_set_uint8(x_2703, sizeof(void*)*10 + 1, x_2694); lean_ctor_set_uint8(x_2703, sizeof(void*)*10 + 2, x_2695); -x_2704 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_2682, x_2703, x_2670); +x_2704 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_2682, x_2703, x_2670); if (lean_obj_tag(x_2704) == 0) { lean_object* x_2705; lean_object* x_2706; lean_object* x_2707; lean_object* x_2708; lean_object* x_2709; lean_object* x_2710; lean_object* x_2711; lean_object* x_2712; @@ -24037,7 +23597,7 @@ lean_object* x_2726; lean_object* x_2727; lean_object* x_2728; lean_object* x_27 x_2726 = lean_ctor_get(x_2724, 1); lean_inc(x_2726); lean_dec(x_2724); -x_2727 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_2727 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_2728 = l_unreachable_x21___rarg(x_2727); x_2729 = lean_apply_2(x_2728, x_2, x_2726); return x_2729; @@ -24068,7 +23628,7 @@ if (lean_is_exclusive(x_2724)) { x_2734 = lean_ctor_get(x_2730, 1); lean_inc(x_2734); lean_dec(x_2730); -x_2735 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2(x_26, x_2731, x_2734); +x_2735 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2(x_26, x_2731, x_2734); if (lean_is_scalar(x_2733)) { x_2736 = lean_alloc_ctor(0, 2, 0); } else { @@ -24094,7 +23654,7 @@ if (lean_is_exclusive(x_2724)) { x_2739 = lean_ctor_get(x_2730, 1); lean_inc(x_2739); lean_dec(x_2730); -x_2740 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__3(x_26, x_2731, x_2739); +x_2740 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__3(x_26, x_2731, x_2739); if (lean_is_scalar(x_2738)) { x_2741 = lean_alloc_ctor(0, 2, 0); } else { @@ -24120,7 +23680,7 @@ if (lean_is_exclusive(x_2724)) { x_2744 = lean_ctor_get(x_2730, 1); lean_inc(x_2744); lean_dec(x_2730); -x_2745 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__4(x_26, x_2731, x_2744); +x_2745 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__4(x_26, x_2731, x_2744); if (lean_is_scalar(x_2743)) { x_2746 = lean_alloc_ctor(0, 2, 0); } else { @@ -24146,7 +23706,7 @@ if (lean_is_exclusive(x_2724)) { x_2749 = lean_ctor_get(x_2730, 1); lean_inc(x_2749); lean_dec(x_2730); -x_2750 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__5(x_26, x_2731, x_2749); +x_2750 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__5(x_26, x_2731, x_2749); if (lean_is_scalar(x_2748)) { x_2751 = lean_alloc_ctor(0, 2, 0); } else { @@ -24176,7 +23736,7 @@ x_2755 = lean_ctor_get(x_2731, 0); lean_inc(x_2755); lean_dec(x_2731); x_2756 = l_Lean_mkConst(x_2755, x_2723); -x_2757 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__6(x_26, x_2756, x_2754); +x_2757 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__6(x_26, x_2756, x_2754); if (lean_is_scalar(x_2753)) { x_2758 = lean_alloc_ctor(0, 2, 0); } else { @@ -24202,7 +23762,7 @@ if (lean_is_exclusive(x_2724)) { x_2761 = lean_ctor_get(x_2730, 1); lean_inc(x_2761); lean_dec(x_2730); -x_2762 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__7(x_26, x_2731, x_2761); +x_2762 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__7(x_26, x_2731, x_2761); if (lean_is_scalar(x_2760)) { x_2763 = lean_alloc_ctor(0, 2, 0); } else { @@ -24228,7 +23788,7 @@ if (lean_is_exclusive(x_2724)) { x_2766 = lean_ctor_get(x_2730, 1); lean_inc(x_2766); lean_dec(x_2730); -x_2767 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__8(x_26, x_2731, x_2766); +x_2767 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__8(x_26, x_2731, x_2766); if (lean_is_scalar(x_2765)) { x_2768 = lean_alloc_ctor(0, 2, 0); } else { @@ -24254,7 +23814,7 @@ if (lean_is_exclusive(x_2724)) { x_2771 = lean_ctor_get(x_2730, 1); lean_inc(x_2771); lean_dec(x_2730); -x_2772 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__9(x_26, x_2731, x_2771); +x_2772 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__9(x_26, x_2731, x_2771); if (lean_is_scalar(x_2770)) { x_2773 = lean_alloc_ctor(0, 2, 0); } else { @@ -24280,7 +23840,7 @@ if (lean_is_exclusive(x_2724)) { x_2776 = lean_ctor_get(x_2730, 1); lean_inc(x_2776); lean_dec(x_2730); -x_2777 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__10(x_26, x_2731, x_2776); +x_2777 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__10(x_26, x_2731, x_2776); if (lean_is_scalar(x_2775)) { x_2778 = lean_alloc_ctor(0, 2, 0); } else { @@ -24306,7 +23866,7 @@ if (lean_is_exclusive(x_2724)) { x_2781 = lean_ctor_get(x_2730, 1); lean_inc(x_2781); lean_dec(x_2730); -x_2782 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__11(x_26, x_2731, x_2781); +x_2782 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__11(x_26, x_2731, x_2781); if (lean_is_scalar(x_2780)) { x_2783 = lean_alloc_ctor(0, 2, 0); } else { @@ -24332,7 +23892,7 @@ if (lean_is_exclusive(x_2724)) { x_2786 = lean_ctor_get(x_2730, 1); lean_inc(x_2786); lean_dec(x_2730); -x_2787 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__12(x_26, x_2731, x_2786); +x_2787 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__12(x_26, x_2731, x_2786); if (lean_is_scalar(x_2785)) { x_2788 = lean_alloc_ctor(0, 2, 0); } else { @@ -24358,7 +23918,7 @@ if (lean_is_exclusive(x_2724)) { x_2791 = lean_ctor_get(x_2730, 1); lean_inc(x_2791); lean_dec(x_2730); -x_2792 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__13(x_26, x_2731, x_2791); +x_2792 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__13(x_26, x_2731, x_2791); if (lean_is_scalar(x_2790)) { x_2793 = lean_alloc_ctor(0, 2, 0); } else { @@ -24384,7 +23944,7 @@ if (lean_is_exclusive(x_2724)) { x_2796 = lean_ctor_get(x_2730, 1); lean_inc(x_2796); lean_dec(x_2730); -x_2797 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__14(x_26, x_2731, x_2796); +x_2797 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__14(x_26, x_2731, x_2796); if (lean_is_scalar(x_2795)) { x_2798 = lean_alloc_ctor(0, 2, 0); } else { @@ -24428,7 +23988,7 @@ else lean_object* x_2803; lean_object* x_2804; lean_object* x_2805; lean_dec(x_2720); lean_dec(x_1); -x_2803 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_2803 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_2804 = l_unreachable_x21___rarg(x_2803); x_2805 = lean_apply_2(x_2804, x_2, x_3); return x_2805; @@ -24504,7 +24064,7 @@ x_9 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_9, 0, x_8); x_10 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_10, 0, x_9); -x_11 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3; +x_11 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3; x_12 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_12, 0, x_11); lean_ctor_set(x_12, 1, x_10); @@ -24514,47 +24074,47 @@ return x_13; } } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { _start: { lean_object* x_7; -x_7 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); +x_7 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); lean_dec(x_5); return x_7; } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__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___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__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___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6); +x_7 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6); lean_dec(x_5); return x_7; } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__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___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__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___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6); +x_7 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6); lean_dec(x_5); return x_7; } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { _start: { lean_object* x_8; -x_8 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +x_8 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7); lean_dec(x_6); return x_8; } } -lean_object* l___private_Init_Lean_Elab_Quotation_13__toPreterm(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l___private_Init_Lean_Elab_Quotation_10__toPreterm(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; -x_4 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main(x_1, x_2, x_3); +x_4 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main(x_1, x_2, x_3); return x_4; } } @@ -24618,7 +24178,7 @@ return x_21; } } } -lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___spec__1(lean_object* x_1, lean_object* x_2) { +lean_object* l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___spec__1(lean_object* x_1, lean_object* x_2) { _start: { if (lean_obj_tag(x_2) == 0) @@ -24633,7 +24193,7 @@ lean_inc(x_3); x_4 = lean_ctor_get(x_2, 1); lean_inc(x_4); lean_dec(x_2); -x_5 = l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder; +x_5 = l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder; x_6 = 0; lean_inc(x_3); x_7 = lean_local_ctx_mk_local_decl(x_1, x_3, x_3, x_5, x_6); @@ -24643,7 +24203,7 @@ goto _start; } } } -lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___spec__2(lean_object* x_1, lean_object* x_2) { +lean_object* l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___spec__2(lean_object* x_1, lean_object* x_2) { _start: { if (lean_obj_tag(x_2) == 0) @@ -24666,7 +24226,7 @@ lean_inc(x_1); x_7 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_7, 0, x_5); lean_ctor_set(x_7, 1, x_1); -x_8 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___spec__2(x_1, x_6); +x_8 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___spec__2(x_1, x_6); lean_ctor_set(x_2, 1, x_8); lean_ctor_set(x_2, 0, x_7); return x_2; @@ -24683,7 +24243,7 @@ lean_inc(x_1); x_11 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_11, 0, x_9); lean_ctor_set(x_11, 1, x_1); -x_12 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___spec__2(x_1, x_10); +x_12 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___spec__2(x_1, x_10); x_13 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_13, 0, x_11); lean_ctor_set(x_13, 1, x_12); @@ -24692,7 +24252,7 @@ return x_13; } } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__1() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__1() { _start: { lean_object* x_1; lean_object* x_2; @@ -24701,7 +24261,7 @@ x_2 = lean_mk_empty_local_ctx(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__2() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__2() { _start: { lean_object* x_1; lean_object* x_2; @@ -24710,7 +24270,7 @@ x_2 = l_Lean_FileMap_ofString(x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__3() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__3() { _start: { lean_object* x_1; @@ -24718,7 +24278,7 @@ x_1 = lean_mk_string("foo"); return x_1; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__4() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__4() { _start: { lean_object* x_1; lean_object* x_2; @@ -24728,7 +24288,7 @@ lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__5() { +lean_object* _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__5() { _start: { lean_object* x_1; lean_object* x_2; @@ -24738,7 +24298,7 @@ lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; @@ -24749,8 +24309,8 @@ lean_inc(x_4); x_5 = lean_ctor_get(x_1, 2); lean_inc(x_5); lean_dec(x_1); -x_6 = l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__1; -x_7 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___spec__1(x_6, x_4); +x_6 = l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__1; +x_7 = l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___spec__1(x_6, x_4); x_8 = l_Lean_Meta_run___rarg___closed__1; x_9 = l_Array_empty___closed__1; x_10 = lean_unsigned_to_nat(0u); @@ -24765,9 +24325,9 @@ lean_inc(x_3); x_13 = lean_get_namespace(x_3); x_14 = lean_box(0); x_15 = lean_box(0); -x_16 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___spec__2(x_15, x_5); -x_17 = l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__3; -x_18 = l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__2; +x_16 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___spec__2(x_15, x_5); +x_17 = l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__3; +x_18 = l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__2; x_19 = l_Lean_firstFrontendMacroScope; x_20 = 1; x_21 = lean_alloc_ctor(0, 10, 3); @@ -24842,24 +24402,24 @@ return x_38; else { lean_object* x_39; -x_39 = l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__4; +x_39 = l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__4; return x_39; } } else { lean_object* x_40; -x_40 = l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__5; +x_40 = l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__5; return x_40; } } } } -lean_object* l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM(lean_object* x_1) { +lean_object* l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg), 2, 0); +x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg), 2, 0); return x_2; } } @@ -24867,7 +24427,7 @@ lean_object* _init_l_Lean_Elab_Term_Quotation_oldExpandStxQuot___closed__1() { _start: { lean_object* x_1; -x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main), 3, 0); +x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main), 3, 0); return x_1; } } @@ -24881,7 +24441,7 @@ x_4 = l_Lean_Elab_Term_Quotation_oldExpandStxQuot___closed__1; x_5 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Elab_Term_monadLog___spec__2___rarg), 4, 2); lean_closure_set(x_5, 0, x_3); lean_closure_set(x_5, 1, x_4); -x_6 = l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg(x_1, x_5); +x_6 = l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg(x_1, x_5); return x_6; } } @@ -24935,12 +24495,12 @@ lean_object* lean_get_antiquot_vars(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 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___spec__1(x_2); +x_3 = l_List_map___main___at___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___spec__1(x_2); x_4 = l_List_join___main___rarg(x_3); x_5 = l_List_map___main___at_Lean_Elab_Term_Quotation_oldGetPatternVars___spec__1(x_4); x_6 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lean_Elab_Term_Quotation_HeadInfo_Inhabited___spec__1___rarg___boxed), 3, 1); lean_closure_set(x_6, 0, x_5); -x_7 = l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg(x_1, x_6); +x_7 = l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg(x_1, x_6); return x_7; } } @@ -24962,7 +24522,7 @@ if (x_3 == 0) lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; x_4 = lean_ctor_get(x_1, 0); x_5 = lean_ctor_get(x_1, 1); -x_6 = l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main(x_4); +x_6 = l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main(x_4); x_7 = l_List_map___main___at_Lean_Elab_Term_Quotation_oldExpandMatchSyntax___spec__1(x_5); lean_ctor_set(x_1, 1, x_7); lean_ctor_set(x_1, 0, x_6); @@ -24976,7 +24536,7 @@ x_9 = lean_ctor_get(x_1, 1); lean_inc(x_9); lean_inc(x_8); lean_dec(x_1); -x_10 = l___private_Init_Lean_Elab_Quotation_4__elimAntiquotChoices___main(x_8); +x_10 = l___private_Init_Lean_Elab_Quotation_1__elimAntiquotChoices___main(x_8); x_11 = l_List_map___main___at_Lean_Elab_Term_Quotation_oldExpandMatchSyntax___spec__1(x_9); x_12 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_12, 0, x_10); @@ -25063,7 +24623,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__4; +x_2 = l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__4; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } @@ -25084,7 +24644,7 @@ x_10 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_10, 0, x_8); lean_ctor_set(x_10, 1, x_4); x_11 = lean_box(0); -x_12 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___boxed), 5, 3); +x_12 = lean_alloc_closure((void*)(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___boxed), 5, 3); lean_closure_set(x_12, 0, x_11); lean_closure_set(x_12, 1, x_10); lean_closure_set(x_12, 2, x_9); @@ -25092,7 +24652,7 @@ x_13 = l_Lean_Elab_Term_Quotation_oldExpandStxQuot___closed__1; x_14 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Elab_Term_monadLog___spec__2___rarg), 4, 2); lean_closure_set(x_14, 0, x_12); lean_closure_set(x_14, 1, x_13); -x_15 = l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg(x_1, x_14); +x_15 = l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg(x_1, x_14); return x_15; } } @@ -25117,158 +24677,138 @@ lean_dec_ref(res); res = initialize_Init_Lean_Parser(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); -l_Lean_Syntax_HasQuote = _init_l_Lean_Syntax_HasQuote(); -lean_mark_persistent(l_Lean_Syntax_HasQuote); -l_Lean_Substring_HasQuote___closed__1 = _init_l_Lean_Substring_HasQuote___closed__1(); -lean_mark_persistent(l_Lean_Substring_HasQuote___closed__1); -l_Lean_Substring_HasQuote___closed__2 = _init_l_Lean_Substring_HasQuote___closed__2(); -lean_mark_persistent(l_Lean_Substring_HasQuote___closed__2); -l_Lean_Name_hasQuote___closed__1 = _init_l_Lean_Name_hasQuote___closed__1(); -lean_mark_persistent(l_Lean_Name_hasQuote___closed__1); -l_Lean_Name_hasQuote = _init_l_Lean_Name_hasQuote(); -lean_mark_persistent(l_Lean_Name_hasQuote); -l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteList___main___rarg___closed__1); -l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__1); -l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__2); -l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__3); -l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__4); -l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__5); -l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6); l_Lean_Elab_Term_Quotation_antiquotKind_x3f___closed__1 = _init_l_Lean_Elab_Term_Quotation_antiquotKind_x3f___closed__1(); lean_mark_persistent(l_Lean_Elab_Term_Quotation_antiquotKind_x3f___closed__1); -l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__1 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__1(); -lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__1); -l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__2 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__2(); -lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__2); -l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__3 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__3(); -lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__3); -l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__4 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__4(); -lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__4); -l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__5 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__5(); -lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__5); -l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__6 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__6(); -lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__6); -l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__7 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__7(); -lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___spec__1___closed__7); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__2); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__3); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__4); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__5(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__5); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__6); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__7 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__7(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__7); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__8 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__8(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__8); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__9 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__9(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__9); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__10 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__10(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__10); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__11); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__12); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__13); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__14 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__14(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__14); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__15 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__15(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__15); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__16); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__17 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__17(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__17); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__18 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__18(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__18); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__19 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__19(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__19); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__20 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__20(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__20); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__21 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__21(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__21); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__22); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__23); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__24 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__24(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__24); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__25 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__25(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__25); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__26); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__27 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__27(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__27); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__28); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__29); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__30 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__30(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__30); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__31); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__32 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__32(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__32); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__33 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__33(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__33); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__34 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__34(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__34); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__35 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__35(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__35); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__36 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__36(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__36); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__37 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__37(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__37); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__38 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__38(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__38); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__39 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__39(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__39); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__41); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__42 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__42(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__42); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__43 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__43(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__43); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__44 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__44(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__44); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__45 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__45(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__45); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__46 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__46(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__46); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__47 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__47(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__47); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__48 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__48(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__48); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__49 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__49(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__49); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__50); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__51); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__52 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__52(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__52); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__53 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__53(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__53); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__54); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__55); -l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56 = _init_l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56); +l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__1 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__1(); +lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__1); +l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__2 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__2(); +lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__2); +l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__3 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__3(); +lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__3); +l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__4 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__4(); +lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__4); +l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__5 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__5(); +lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__5); +l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__6 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__6(); +lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__6); +l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__7 = _init_l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__7(); +lean_mark_persistent(l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__7); +l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3___closed__1 = _init_l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Syntax_8__quoteList___main___at___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___spec__3___closed__1); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__2); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__3); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__4); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__5); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__6); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__7 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__7(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__7); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__8 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__8(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__8); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__9 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__9(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__9); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__10 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__10(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__10); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__11); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__12); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__13); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__14 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__14(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__14); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__15 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__15(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__15); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__16); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__17 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__17(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__17); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__18 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__18(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__18); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__19 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__19(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__19); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__20 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__20(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__20); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__21 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__21(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__21); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__22); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__23); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__24 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__24(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__24); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__25 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__25(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__25); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__26); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__27 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__27(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__27); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__28); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__29); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__30 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__30(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__30); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__31); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__32 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__32(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__32); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__33 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__33(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__33); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__34 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__34(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__34); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__35 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__35(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__35); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__36 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__36(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__36); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__37 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__37(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__37); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__38 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__38(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__38); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__39 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__39(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__39); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__40 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__40(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__40); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__42 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__42(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__42); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__43 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__43(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__43); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__44 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__44(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__44); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__46 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__46(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__46); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__47 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__47(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__47); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__48 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__48(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__48); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__49 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__49(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__49); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__50 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__50(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__50); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__51); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__52); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__53 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__53(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__53); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__54 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__54(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__54); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__55); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__56); +l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57 = _init_l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57); l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__1 = _init_l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__1(); lean_mark_persistent(l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__1); l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__2 = _init_l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__2(); @@ -25350,206 +24890,206 @@ l_Lean_Elab_Term_Quotation_HeadInfo_Inhabited___closed__2 = _init_l_Lean_Elab_Te lean_mark_persistent(l_Lean_Elab_Term_Quotation_HeadInfo_Inhabited___closed__2); l_Lean_Elab_Term_Quotation_HeadInfo_Inhabited = _init_l_Lean_Elab_Term_Quotation_HeadInfo_Inhabited(); lean_mark_persistent(l_Lean_Elab_Term_Quotation_HeadInfo_Inhabited); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__1); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__3); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__5(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__5); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__6(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__6); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__7); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__8); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__9 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__9(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__9); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10); -l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__1 = _init_l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__1(); -lean_mark_persistent(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__1); -l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__2 = _init_l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__2(); -lean_mark_persistent(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_7__getHeadInfo___spec__2___closed__2); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__1); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__2); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__1___closed__3); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__1); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__2); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__3); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__4); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__2___closed__5); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__1); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__2); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___lambda__3___closed__3); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__1); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__2); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__3); -l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___closed__4); -l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__1); -l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__2); -l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___lambda__1___closed__3); -l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__1); -l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__2); -l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__explodeHeadPat___closed__3); -l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__1 = _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__1(); -lean_mark_persistent(l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__1); -l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__2 = _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__2(); -lean_mark_persistent(l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__2); -l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__3 = _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__3(); -lean_mark_persistent(l_List_head_x21___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__2___closed__3); -l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5___closed__1 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5___closed__1(); -lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__5___closed__1); -l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__1 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__1(); -lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__1); -l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__2 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__2(); -lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__2); -l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__3 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__3(); -lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__3); -l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__4 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__4(); -lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__4); -l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__5 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__5(); -lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__5); -l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__6 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__6(); -lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__6); -l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__7 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__7(); -lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__7); -l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__8 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__8(); -lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___spec__8___closed__8); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__1); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__2); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__3); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__4); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__5(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__5); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__6); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__7 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__7(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__7); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__8); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__9 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__9(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__9); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__10 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__10(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__10); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__11); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__12 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__12(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__12); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__13 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__13(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__13); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__14); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__15); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__16 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__16(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__16); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__17); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__18); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__19 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__19(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__19); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__20); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__21 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__21(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__21); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__22); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__23 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__23(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__23); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__24); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__25 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__25(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__25); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__26 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__26(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__26); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__27 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__27(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__27); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__28 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__28(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__28); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__29 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__29(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__29); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__30 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__30(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__30); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__31 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__31(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__31); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__32 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__32(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__32); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__33 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__33(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__33); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__34 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__34(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__34); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__35 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__35(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__35); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__36 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__36(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__36); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__37 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__37(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__37); -l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__38 = _init_l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__38(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__compileStxMatch___main___closed__38); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__1); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__2); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__3); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__4); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__5(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__5); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__6(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__6); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__7 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__7(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__7); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__8 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__8(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__8); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__9 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__9(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__9); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__10 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__10(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__10); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__12 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__12(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__12); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__13); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__14 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__14(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__14); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__15 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__15(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__15); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__16 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__16(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__16); -l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17 = _init_l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__1); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__3); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__5); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__6(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__6); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__7); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__8); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__9 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__9(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__9); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10); +l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__1 = _init_l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__1(); +lean_mark_persistent(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__1); +l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__2 = _init_l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__2(); +lean_mark_persistent(l_Array_umapMAux___main___at___private_Init_Lean_Elab_Quotation_4__getHeadInfo___spec__2___closed__2); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__1); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__2); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__1___closed__3); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__1); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__2); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__3); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__4); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__2___closed__5); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__1); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__2); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___lambda__3___closed__3); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__1); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__2); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__3); +l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___closed__4); +l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__1); +l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__2); +l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___lambda__1___closed__3); +l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__1); +l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__2); +l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_5__explodeHeadPat___closed__3); +l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__1 = _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__1(); +lean_mark_persistent(l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__1); +l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__2 = _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__2(); +lean_mark_persistent(l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__2); +l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__3 = _init_l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__3(); +lean_mark_persistent(l_List_head_x21___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__2___closed__3); +l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5___closed__1 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5___closed__1(); +lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__5___closed__1); +l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__1 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__1(); +lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__1); +l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__2 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__2(); +lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__2); +l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__3 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__3(); +lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__3); +l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__4 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__4(); +lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__4); +l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__5 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__5(); +lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__5); +l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__6 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__6(); +lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__6); +l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__7 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__7(); +lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__7); +l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__8 = _init_l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__8(); +lean_mark_persistent(l_List_mapM___main___at___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___spec__8___closed__8); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__1); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__2); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__3); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__4); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__5); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__6); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__7 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__7(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__7); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__8); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__9 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__9(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__9); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__10 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__10(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__10); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__11); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__12 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__12(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__12); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__13 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__13(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__13); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__14); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__15); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__16 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__16(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__16); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__17); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__18); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__19 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__19(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__19); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__20); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__21 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__21(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__21); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__22); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__23 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__23(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__23); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__24); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__25 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__25(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__25); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__26 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__26(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__26); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__27 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__27(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__27); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__28 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__28(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__28); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__29 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__29(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__29); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__30 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__30(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__30); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__31 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__31(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__31); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__32 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__32(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__32); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__33 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__33(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__33); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__34 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__34(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__34); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__35 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__35(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__35); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__36 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__36(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__36); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__37 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__37(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__37); +l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__38 = _init_l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__38(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_6__compileStxMatch___main___closed__38); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__1); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__2); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__3); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__4); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__5); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__6(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__6); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__7 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__7(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__7); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__8 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__8(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__8); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__9 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__9(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__9); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__10 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__10(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__10); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__12 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__12(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__12); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__13); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__14 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__14(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__14); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__15 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__15(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__15); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__16 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__16(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__16); +l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17 = _init_l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17); l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__1 = _init_l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__1(); lean_mark_persistent(l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__1); l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__2 = _init_l_Array_umapMAux___main___at_Lean_Elab_Term_Quotation_match__syntax_expand___spec__1___closed__2(); @@ -25571,58 +25111,58 @@ lean_mark_persistent(l___regBuiltin_Lean_Elab_Term_Quotation_elabMatchSyntax___c res = l___regBuiltin_Lean_Elab_Term_Quotation_elabMatchSyntax(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); -l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder___closed__1); -l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder = _init_l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_12__exprPlaceholder); -l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1 = _init_l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1(); -lean_mark_persistent(l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_13__toPreterm___main___spec__2___closed__1); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__1); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__1___closed__2); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__1); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__2); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__3); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__2___closed__4); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__1); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__3___closed__2); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__1); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__2); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___lambda__4___closed__3); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__1); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__2); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__3); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__4); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__5); -l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_13__toPreterm___main___closed__6); +l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder___closed__1); +l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder = _init_l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_9__exprPlaceholder); +l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1 = _init_l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1(); +lean_mark_persistent(l_List_foldl___main___at___private_Init_Lean_Elab_Quotation_10__toPreterm___main___spec__2___closed__1); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__1); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__1___closed__2); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__1); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__2); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__3); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__2___closed__4); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__1); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__3___closed__2); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__1); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__2); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___lambda__4___closed__3); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__1); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__2); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__3); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__4); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__5); +l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6 = _init_l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_10__toPreterm___main___closed__6); l_Lean_Elab_Term_Quotation_oldParseExpr___closed__1 = _init_l_Lean_Elab_Term_Quotation_oldParseExpr___closed__1(); lean_mark_persistent(l_Lean_Elab_Term_Quotation_oldParseExpr___closed__1); -l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__1(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__1); -l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__2(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__2); -l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__3(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__3); -l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__4(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__4); -l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__5(); -lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_14__oldRunTermElabM___rarg___closed__5); +l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__1 = _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__1); +l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__2 = _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__2); +l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__3 = _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__3); +l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__4 = _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__4); +l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__5 = _init_l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Elab_Quotation_11__oldRunTermElabM___rarg___closed__5); l_Lean_Elab_Term_Quotation_oldExpandStxQuot___closed__1 = _init_l_Lean_Elab_Term_Quotation_oldExpandStxQuot___closed__1(); lean_mark_persistent(l_Lean_Elab_Term_Quotation_oldExpandStxQuot___closed__1); l_Lean_Elab_Term_Quotation_oldExpandMatchSyntax___closed__1 = _init_l_Lean_Elab_Term_Quotation_oldExpandMatchSyntax___closed__1(); diff --git a/stage0/stdlib/Init/Lean/Elab/StructInst.c b/stage0/stdlib/Init/Lean/Elab/StructInst.c index f904afc499..7612c4d5d6 100644 --- a/stage0/stdlib/Init/Lean/Elab/StructInst.c +++ b/stage0/stdlib/Init/Lean/Elab/StructInst.c @@ -26,6 +26,7 @@ lean_object* l_List_forM___main___at_Lean_Elab_Term_StructInst_DefaultFields_ste lean_object* l___private_Init_Lean_Elab_StructInst_17__groupFields___lambda__3___closed__2; lean_object* l_List_map___main___at___private_Init_Lean_Elab_StructInst_10__expandParentFields___spec__1(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_StructInst_Source_hasFormat(lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; extern lean_object* l_Lean_fieldIdxKind; lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_StructInst_19__expandStruct___main___spec__8(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_mvarId_x21(lean_object*); @@ -104,7 +105,6 @@ lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructIns extern lean_object* l_Lean_Parser_Term_structInst___elambda__1___closed__6; lean_object* l___private_Init_Lean_Elab_StructInst_10__expandParentFields(lean_object*, lean_object*, lean_object*); lean_object* l_List_append___rarg(lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; lean_object* l_mkHashMap___at___private_Init_Lean_Elab_StructInst_12__mkFieldMap___spec__9(lean_object*); lean_object* l_List_map___main___at___private_Init_Lean_Elab_StructInst_5__getStructName___spec__2(lean_object*); lean_object* l_List_foldlM___main___at___private_Init_Lean_Elab_StructInst_12__mkFieldMap___spec__10___closed__3; @@ -124,7 +124,6 @@ lean_object* l_Lean_Elab_Term_StructInst_Struct_ref(lean_object*); lean_object* l_Lean_Elab_Term_getMVarDecl(lean_object*, lean_object*, lean_object*); lean_object* lean_expr_instantiate1(lean_object*, lean_object*); lean_object* lean_array_push(lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; lean_object* lean_array_get_size(lean_object*); lean_object* l_List_find_x3f___main___rarg(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_StructInst_Struct_setFields(lean_object*, lean_object*); @@ -257,6 +256,7 @@ lean_object* l___private_Init_Lean_Elab_StructInst_4__elabModifyOp___closed__3; lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Elab_Term_mkConst___closed__4; lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_propagateLoop___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; lean_object* l_HashMapImp_find_x3f___at___private_Init_Lean_Elab_StructInst_12__mkFieldMap___spec__1(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_StructInst_Field_inhabited(lean_object*); lean_object* lean_instantiate_type_lparams(lean_object*, lean_object*); @@ -267,7 +267,6 @@ lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_StructInst_Field_toSynt lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_propagateLoop___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_getFieldName___boxed(lean_object*); lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_getHierarchyDepth(lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; size_t l_Lean_Name_hash(lean_object*); lean_object* l_Nat_repr(lean_object*); lean_object* l_Lean_Elab_Term_StructInst_markDefaultMissing___closed__1; @@ -276,6 +275,7 @@ lean_object* l___private_Init_Lean_Elab_StructInst_14__getFieldIdx___closed__2; lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_reduceProjOf_x3f(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__3; lean_object* l_Lean_Elab_Term_logTrace(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; lean_object* l_Array_iterateMAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getId(lean_object*); lean_object* l_Lean_Syntax_prettyPrint(lean_object*); @@ -293,7 +293,6 @@ lean_object* l___private_Init_Lean_Elab_StructInst_5__getStructName(lean_object* lean_object* l_Function_comp___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_getCurrMacroScope(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefaultAux___main___closed__1; -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; lean_object* l___private_Init_Lean_Elab_StructInst_4__elabModifyOp___closed__14; lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefaultAux___main___closed__2; lean_object* l_Lean_Elab_Term_StructInst_Struct_hasFormat___closed__1; @@ -327,6 +326,7 @@ lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_StructInst_9__expa uint8_t l_Lean_Elab_Term_StructInst_Field_isSimple___rarg(lean_object*); lean_object* l_Lean_Elab_Term_StructInst_Struct_fields(lean_object*); lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_reduce___main___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; uint8_t l_Lean_Expr_isAppOfArity___main(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_StructInst_4__elabModifyOp___closed__6; uint8_t l_Lean_Expr_Data_binderInfo(uint64_t); @@ -429,7 +429,6 @@ lean_object* l___private_Init_Lean_Elab_StructInst_17__groupFields___at___privat extern lean_object* l_Lean_getBuiltinSearchPath___closed__2; lean_object* l___private_Init_Lean_Elab_StructInst_20__mkCtorHeaderAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_isRoundDone(lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; lean_object* l_Lean_Meta_lambdaTelescope___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_isExprMVarAssigned(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_StructInst_Struct_modifyFieldsM___at_Lean_Elab_Term_StructInst_Struct_modifyFields___spec__1(lean_object*, lean_object*); @@ -455,7 +454,6 @@ lean_object* l___private_Init_Lean_Elab_StructInst_4__elabModifyOp___closed__16; lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_StructInst_19__expandStruct___main___spec__11(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_propagateLoop(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_PUnit_Inhabited; -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; extern lean_object* l_Lean_mkOptionalNode___closed__1; lean_object* l_Lean_Elab_Term_StructInst_isDefaultMissing_x3f(lean_object*); lean_object* l_Lean_Elab_Term_StructInst_elabStructInst___closed__3; @@ -484,6 +482,7 @@ lean_object* l_Lean_Elab_Term_StructInst_Struct_hasFormat; lean_object* l_Lean_Elab_Term_mkFreshLevelMVar(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_MessageData_arrayExpr_toMessageData___main___closed__2; lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_collectStructNames___main(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; lean_object* l_List_map___main___at_Lean_Elab_Term_StructInst_formatStruct___main___spec__1___closed__1; lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_StructInst_19__expandStruct___main___spec__4(lean_object*, lean_object*); lean_object* l_List_foldlM___main___at___private_Init_Lean_Elab_StructInst_24__elabStruct___main___spec__1___closed__3; @@ -536,6 +535,7 @@ lean_object* l_Lean_Elab_Term_StructInst_formatStruct___main___closed__2; lean_object* l_List_mapM___main___at___private_Init_Lean_Elab_StructInst_10__expandParentFields___spec__2___closed__2; lean_object* l_Array_foldlStepMAux___main___at___private_Init_Lean_Elab_StructInst_3__isModifyOp_x3f___spec__1___closed__4; lean_object* l_Lean_mkConst(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; lean_object* l_Lean_Elab_Term_StructInst_FieldVal_toSyntax(lean_object*); lean_object* l_Lean_findField_x3f___main(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefaultAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -1077,16 +1077,16 @@ x_49 = lean_array_push(x_48, x_47); x_50 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_51 = lean_array_push(x_49, x_50); x_52 = lean_array_push(x_51, x_50); -x_53 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_53 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_54 = lean_array_push(x_52, x_53); x_55 = lean_array_push(x_54, x_32); x_56 = l_Lean_Parser_Term_letIdDecl___closed__2; x_57 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_57, 0, x_56); lean_ctor_set(x_57, 1, x_55); -x_58 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_58 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_59 = lean_array_push(x_58, x_57); -x_60 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_60 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_61 = lean_array_push(x_59, x_60); x_62 = lean_array_push(x_61, x_35); x_63 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -1121,16 +1121,16 @@ x_74 = lean_array_push(x_73, x_72); x_75 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_76 = lean_array_push(x_74, x_75); x_77 = lean_array_push(x_76, x_75); -x_78 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_78 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_79 = lean_array_push(x_77, x_78); x_80 = lean_array_push(x_79, x_32); x_81 = l_Lean_Parser_Term_letIdDecl___closed__2; x_82 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_82, 0, x_81); lean_ctor_set(x_82, 1, x_80); -x_83 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_83 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_84 = lean_array_push(x_83, x_82); -x_85 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_85 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_86 = lean_array_push(x_84, x_85); x_87 = lean_array_push(x_86, x_35); x_88 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -1191,16 +1191,16 @@ x_109 = lean_array_push(x_108, x_107); x_110 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_111 = lean_array_push(x_109, x_110); x_112 = lean_array_push(x_111, x_110); -x_113 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_113 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_114 = lean_array_push(x_112, x_113); x_115 = lean_array_push(x_114, x_91); x_116 = l_Lean_Parser_Term_letIdDecl___closed__2; x_117 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_117, 0, x_116); lean_ctor_set(x_117, 1, x_115); -x_118 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_118 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_119 = lean_array_push(x_118, x_117); -x_120 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_120 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_121 = lean_array_push(x_119, x_120); x_122 = lean_array_push(x_121, x_94); x_123 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -1275,16 +1275,16 @@ x_147 = lean_array_push(x_146, x_145); x_148 = l___private_Init_Lean_Elab_Term_5__expandCDot___main___closed__4; x_149 = lean_array_push(x_147, x_148); x_150 = lean_array_push(x_149, x_148); -x_151 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_151 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_152 = lean_array_push(x_150, x_151); x_153 = lean_array_push(x_152, x_128); x_154 = l_Lean_Parser_Term_letIdDecl___closed__2; x_155 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_155, 0, x_154); lean_ctor_set(x_155, 1, x_153); -x_156 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__2; +x_156 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__2; x_157 = lean_array_push(x_156, x_155); -x_158 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__10; +x_158 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__10; x_159 = lean_array_push(x_157, x_158); x_160 = lean_array_push(x_159, x_132); x_161 = l_Lean_Parser_Term_let___elambda__1___closed__2; @@ -1875,7 +1875,7 @@ lean_dec(x_10); x_31 = lean_ctor_get(x_29, 1); lean_inc(x_31); lean_dec(x_29); -x_32 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_32 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_33 = l_unreachable_x21___rarg(x_32); lean_inc(x_5); x_34 = lean_apply_2(x_33, x_5, x_31); @@ -3020,12 +3020,12 @@ lean_ctor_set(x_78, 0, x_16); lean_ctor_set(x_78, 1, x_77); lean_ctor_set(x_78, 2, x_76); lean_ctor_set(x_78, 3, x_19); -x_79 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_79 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_80 = lean_array_push(x_79, x_78); -x_81 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_81 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_82 = lean_array_push(x_80, x_81); x_83 = lean_array_push(x_82, x_43); -x_84 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_84 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_85 = lean_array_push(x_83, x_84); x_86 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2; x_87 = lean_alloc_ctor(1, 2, 0); @@ -3209,12 +3209,12 @@ lean_ctor_set(x_232, 0, x_216); lean_ctor_set(x_232, 1, x_231); lean_ctor_set(x_232, 2, x_230); lean_ctor_set(x_232, 3, x_221); -x_233 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__40; +x_233 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__41; x_234 = lean_array_push(x_233, x_232); -x_235 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_235 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_236 = lean_array_push(x_234, x_235); x_237 = lean_array_push(x_236, x_205); -x_238 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_238 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_239 = lean_array_push(x_237, x_238); x_240 = l_Lean_Parser_Term_namedArgument___elambda__1___closed__2; x_241 = lean_alloc_ctor(1, 2, 0); @@ -12747,7 +12747,7 @@ lean_dec(x_1); x_8 = lean_ctor_get(x_2, 1); lean_inc(x_8); lean_dec(x_2); -x_9 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_9 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_10 = l_unreachable_x21___rarg(x_9); lean_inc(x_3); x_11 = lean_apply_2(x_10, x_3, x_4); @@ -12954,7 +12954,7 @@ lean_dec(x_1); x_58 = lean_ctor_get(x_2, 1); lean_inc(x_58); lean_dec(x_2); -x_59 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_59 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_60 = l_unreachable_x21___rarg(x_59); lean_inc(x_3); x_61 = lean_apply_2(x_60, x_3, x_4); @@ -13162,7 +13162,7 @@ lean_dec(x_1); x_109 = lean_ctor_get(x_2, 1); lean_inc(x_109); lean_dec(x_2); -x_110 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__1; +x_110 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__1; x_111 = l_unreachable_x21___rarg(x_110); lean_inc(x_3); x_112 = lean_apply_2(x_111, x_3, x_4); @@ -25388,6 +25388,7 @@ x_45 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_45, 0, x_44); x_46 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_46, 0, x_45); +lean_inc(x_4); x_47 = l_Lean_Elab_Term_logTrace(x_22, x_1, x_46, x_4, x_21); lean_dec(x_1); x_48 = lean_ctor_get(x_47, 1); diff --git a/stage0/stdlib/Init/Lean/Elab/Syntax.c b/stage0/stdlib/Init/Lean/Elab/Syntax.c index 83c6725b0c..5e175707f0 100644 --- a/stage0/stdlib/Init/Lean/Elab/Syntax.c +++ b/stage0/stdlib/Init/Lean/Elab/Syntax.c @@ -34,6 +34,7 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__12; lean_object* l_Lean_Name_eraseMacroScopes(lean_object*); lean_object* l_Lean_Syntax_isNatLitAux(lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_expandNotation___closed__2; +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(lean_object*); 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*); @@ -51,6 +52,7 @@ lean_object* l___private_Init_Lean_Elab_Syntax_1__expandOptPrecedence(lean_objec lean_object* l_Lean_Elab_Command_elabSyntax___closed__36; lean_object* l_Lean_Elab_Command_expandMacroArgIntoSyntaxItem(lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Command_elabReserve___closed__1; +extern lean_object* l_Lean_Nat_HasQuote___closed__2; lean_object* l_unreachable_x21___rarg(lean_object*); lean_object* l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__4; extern lean_object* l_Lean_nullKind; @@ -59,6 +61,7 @@ lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__ lean_object* l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__8; extern lean_object* l_Lean_identKind___closed__1; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__92; +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main(lean_object*); lean_object* l_Array_eraseIdx___rarg(lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__14; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__28; @@ -70,6 +73,7 @@ lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__30; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__36; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__5; uint8_t lean_name_eq(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6; extern lean_object* l_Lean_Parser_Syntax_many1___elambda__1___closed__2; lean_object* l_Lean_Elab_Command_Macro_mkFreshKind(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__104; @@ -96,9 +100,7 @@ uint8_t l_Lean_checkTraceOption(lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_elabSyntax___closed__24; lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Syntax_7__antiquote___main___spec__2___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__8; -extern lean_object* l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; extern lean_object* l_Lean_Parser_Command_declaration___elambda__1___closed__2; -extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__1; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__19; lean_object* l_Lean_Elab_Command_strLitPrecToPattern___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_mkIdentFrom(lean_object*, lean_object*); @@ -114,7 +116,6 @@ lean_object* l_Lean_Elab_Term_checkLeftRec___closed__8; lean_object* lean_array_get_size(lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__51; extern lean_object* l_Lean_charLitKind___closed__1; -extern lean_object* l_Lean_Parser_Term_num___elambda__1___closed__1; lean_object* l___private_Init_Lean_Elab_Syntax_4__withNotFirst(lean_object*); lean_object* l_Lean_Elab_Command_strLitPrecToPattern(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Syntax_8__regTraceClasses(lean_object*); @@ -142,12 +143,10 @@ lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__36; lean_object* l_Lean_Elab_Command_elabSyntax___closed__32; extern lean_object* l_Lean_Parser_Command_mixfix___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_getMainModule___rarg(lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__29; lean_object* l___private_Init_Lean_Elab_Syntax_7__antiquote___boxed(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__43; lean_object* l___regBuiltin_Lean_Elab_Command_elabReserve(lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_1__quoteName___main(lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__120; extern lean_object* l_Lean_mkAppStx___closed__8; lean_object* l_Lean_Elab_Command_elabMixfix___boxed(lean_object*, lean_object*); @@ -163,7 +162,6 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__28; lean_object* l___private_Init_Lean_Elab_Syntax_2__mkParserSeq(lean_object*, lean_object*, lean_object*); 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_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(lean_object*); 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*); @@ -196,6 +194,7 @@ lean_object* l_Lean_Elab_Command_elabMixfix___rarg(lean_object*); 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_umapMAux___main___at_Lean_Elab_Command_expandNotation___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Nat_HasQuote___closed__1; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__61; lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Elab_Term_elabArrayLit___closed__11; @@ -212,6 +211,7 @@ lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__3; lean_object* l_Lean_Syntax_isStrLit_x3f(lean_object*); lean_object* l_Lean_Elab_Command_elabSyntax___closed__6; lean_object* l_Lean_Elab_Command_expandMacroArgIntoPattern___boxed(lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__4; lean_object* l_Lean_Name_append___main(lean_object*, lean_object*); lean_object* l_Lean_Elab_Command_expandNotationItemIntoPattern(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__14; @@ -226,6 +226,7 @@ extern lean_object* l_Lean_Parser_Command_def___elambda__1___closed__2; lean_object* l_Lean_Macro_addMacroScope(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Command_declValSimple___elambda__1___closed__2; lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_String_HasQuote___closed__1; extern lean_object* l___private_Init_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__5; lean_object* l_Lean_Elab_Command_elabSyntax___closed__25; extern lean_object* l_Lean_numLitKind___closed__1; @@ -247,10 +248,10 @@ lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__56; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__66; lean_object* l_Nat_repr(lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11; extern lean_object* l_Lean_Parser_Command_attrInstance___elambda__1___closed__2; extern lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__3; lean_object* l_Lean_Elab_Command_elabMacroRules(lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__55; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__37; lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux___closed__4; @@ -265,6 +266,7 @@ lean_object* lean_name_mk_string(lean_object*, lean_object*); extern lean_object* l_Lean_choiceKind; lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__7; lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux___closed__1; +extern lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; lean_object* l_Lean_Elab_Term_throwError___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__33; extern lean_object* l_Lean_Elab_Term_mkExplicitBinder___closed__5; @@ -276,7 +278,6 @@ lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux___closed__2; lean_object* l_Lean_Elab_Command_expandNotation___closed__3; lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Syntax_2__mkParserSeq___spec__1___closed__1; lean_object* l_Lean_Elab_Term_getCurrMacroScope(lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; lean_object* l_Lean_Elab_Term_checkLeftRec___closed__2; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__91; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__78; @@ -339,9 +340,9 @@ lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_checkLeftRec___closed__5; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__5; extern lean_object* l_Lean_Parser_Command_notation___elambda__1___closed__2; +extern lean_object* l_Lean_String_HasQuote___closed__2; lean_object* l_Lean_Elab_Term_checkLeftRec___closed__6; extern lean_object* l_Lean_nullKind___closed__2; -extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__1; extern lean_object* l_Lean_Parser_Syntax_lookahead___elambda__1___closed__1; extern lean_object* l_Lean_Elab_Term_elabArrayLit___closed__10; extern lean_object* l_Lean_Parser_Syntax_sepBy1___elambda__1___closed__2; @@ -358,7 +359,6 @@ 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; lean_object* l_Lean_Elab_Command_elabSyntax___closed__9; -extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__2; extern lean_object* l_Bool_HasRepr___closed__1; extern lean_object* l_Lean_Syntax_inhabited; lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux___closed__5; @@ -408,6 +408,7 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__111; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__97; lean_object* l_Array_umapMAux___main___at_Lean_Elab_Command_expandMacro___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Elab_Syntax_5__withoutLeftRec(lean_object*); +extern lean_object* l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__64; lean_object* l___private_Init_Lean_Elab_Syntax_1__expandOptPrecedence___boxed(lean_object*); lean_object* l_Lean_Elab_Command_elabSyntax___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -510,7 +511,6 @@ lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__21; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__38; extern lean_object* l_Lean_Parser_Command_macro___elambda__1___closed__2; lean_object* l_Lean_Elab_Command_elabSyntax___closed__12; -extern lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__4; 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; @@ -528,13 +528,13 @@ extern lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__3; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__23; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__2; lean_object* l___private_Init_Lean_Elab_Syntax_4__withNotFirst___rarg(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); -extern lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6; lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__44; extern lean_object* l_Lean_Parser_Command_syntax___elambda__1___closed__1; lean_object* l___private_Init_Lean_Elab_Command_7__mkTermState(lean_object*); lean_object* l_Lean_Elab_Command_expandNotationItemIntoSyntaxItem(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_toParserDescrAux___main___closed__35; extern lean_object* l_Lean_Parser_mkAntiquot___closed__2; +extern lean_object* l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; extern lean_object* l_Lean_Elab_Command_liftTermElabM___rarg___closed__1; extern lean_object* l_Lean_Parser_Term_orelse___elambda__1___closed__1; lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__12; @@ -1303,13 +1303,13 @@ lean_dec(x_2); return x_7; } } -lean_object* l___private_Init_Lean_Elab_Quotation_3__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(lean_object* x_1) { +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(lean_object* x_1) { _start: { if (lean_obj_tag(x_1) == 0) { lean_object* x_2; -x_2 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__4; +x_2 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__4; return x_2; } else @@ -1324,12 +1324,12 @@ x_6 = l_Lean_numLitKind; x_7 = l_Lean_mkStxLit(x_6, x_4, x_5); x_8 = l_Lean_mkOptionalNode___closed__2; x_9 = lean_array_push(x_8, x_7); -x_10 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_10 = l_Lean_Nat_HasQuote___closed__2; x_11 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_11, 0, x_10); lean_ctor_set(x_11, 1, x_9); x_12 = lean_array_push(x_8, x_11); -x_13 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___rarg___closed__6; +x_13 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6; x_14 = l_Lean_mkCAppStx(x_13, x_12); return x_14; } @@ -6304,7 +6304,7 @@ x_1478 = lean_array_push(x_1472, x_1477); x_1479 = l_Lean_mkStxStrLit(x_1353, x_1466); x_1480 = l_Lean_mkOptionalNode___closed__2; x_1481 = lean_array_push(x_1480, x_1479); -x_1482 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_1482 = l_Lean_String_HasQuote___closed__2; x_1483 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1483, 0, x_1482); lean_ctor_set(x_1483, 1, x_1481); @@ -6372,7 +6372,7 @@ x_1515 = lean_array_push(x_1509, x_1514); x_1516 = l_Lean_mkStxStrLit(x_1353, x_1503); x_1517 = l_Lean_mkOptionalNode___closed__2; x_1518 = lean_array_push(x_1517, x_1516); -x_1519 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_1519 = l_Lean_String_HasQuote___closed__2; x_1520 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1520, 0, x_1519); lean_ctor_set(x_1520, 1, x_1518); @@ -6466,12 +6466,12 @@ x_1376 = lean_array_push(x_1370, x_1375); x_1377 = l_Lean_mkStxStrLit(x_1353, x_1364); x_1378 = l_Lean_mkOptionalNode___closed__2; x_1379 = lean_array_push(x_1378, x_1377); -x_1380 = l_Lean_Parser_Term_str___elambda__1___closed__2; +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___private_Init_Lean_Elab_Quotation_3__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(x_1356); +x_1383 = l___private_Init_Lean_Syntax_9__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(x_1356); x_1384 = lean_array_push(x_1382, x_1383); x_1385 = l_Lean_nullKind___closed__2; x_1386 = lean_alloc_ctor(1, 2, 0); @@ -6516,12 +6516,12 @@ x_1404 = lean_array_push(x_1398, x_1403); x_1405 = l_Lean_mkStxStrLit(x_1353, x_1392); x_1406 = l_Lean_mkOptionalNode___closed__2; x_1407 = lean_array_push(x_1406, x_1405); -x_1408 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_1408 = l_Lean_String_HasQuote___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_1398, x_1409); -x_1411 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(x_1356); +x_1411 = l___private_Init_Lean_Syntax_9__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(x_1356); x_1412 = lean_array_push(x_1410, x_1411); x_1413 = l_Lean_nullKind___closed__2; x_1414 = lean_alloc_ctor(1, 2, 0); @@ -6582,12 +6582,12 @@ x_1437 = lean_array_push(x_1431, x_1436); x_1438 = l_Lean_mkStxStrLit(x_1353, x_1425); x_1439 = l_Lean_mkOptionalNode___closed__2; x_1440 = lean_array_push(x_1439, x_1438); -x_1441 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_1441 = l_Lean_String_HasQuote___closed__2; x_1442 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1442, 0, x_1441); lean_ctor_set(x_1442, 1, x_1440); x_1443 = lean_array_push(x_1431, x_1442); -x_1444 = l___private_Init_Lean_Elab_Quotation_3__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(x_1356); +x_1444 = l___private_Init_Lean_Syntax_9__quoteOption___at_Lean_Elab_Term_toParserDescrAux___main___spec__1(x_1356); x_1445 = lean_array_push(x_1443, x_1444); x_1446 = l_Lean_nullKind___closed__2; x_1447 = lean_alloc_ctor(1, 2, 0); @@ -6802,14 +6802,14 @@ x_1576 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1576, 0, x_1575); lean_ctor_set(x_1576, 1, x_1574); x_1577 = lean_array_push(x_1571, x_1576); -x_1578 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_1546); +x_1578 = l___private_Init_Lean_Syntax_7__quoteName___main(x_1546); x_1579 = lean_array_push(x_1571, x_1578); x_1580 = l_Nat_repr(x_1558); x_1581 = l_Lean_numLitKind; x_1582 = l_Lean_mkStxLit(x_1581, x_1580, x_1565); x_1583 = l_Lean_mkOptionalNode___closed__2; x_1584 = lean_array_push(x_1583, x_1582); -x_1585 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_1585 = l_Lean_Nat_HasQuote___closed__2; x_1586 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1586, 0, x_1585); lean_ctor_set(x_1586, 1, x_1584); @@ -6860,14 +6860,14 @@ x_1607 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_1607, 0, x_1606); lean_ctor_set(x_1607, 1, x_1605); x_1608 = lean_array_push(x_1602, x_1607); -x_1609 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_1546); +x_1609 = l___private_Init_Lean_Syntax_7__quoteName___main(x_1546); x_1610 = lean_array_push(x_1602, x_1609); x_1611 = l_Nat_repr(x_1558); x_1612 = l_Lean_numLitKind; x_1613 = l_Lean_mkStxLit(x_1612, x_1611, x_1596); x_1614 = l_Lean_mkOptionalNode___closed__2; x_1615 = lean_array_push(x_1614, x_1613); -x_1616 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_1616 = l_Lean_Nat_HasQuote___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); @@ -7899,7 +7899,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_empty___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_7__getHeadInfo___elambda__3___closed__4; +x_2 = l___private_Init_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__4; x_3 = lean_array_push(x_1, x_2); return x_3; } @@ -8831,7 +8831,7 @@ x_94 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_94, 0, x_75); lean_ctor_set(x_94, 1, x_93); x_95 = lean_array_push(x_31, x_94); -x_96 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_14); +x_96 = l___private_Init_Lean_Syntax_7__quoteName___main(x_14); x_97 = lean_array_push(x_31, x_96); x_98 = lean_array_push(x_97, x_23); x_99 = lean_alloc_ctor(1, 2, 0); @@ -9157,7 +9157,7 @@ x_222 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_222, 0, x_203); lean_ctor_set(x_222, 1, x_221); x_223 = lean_array_push(x_159, x_222); -x_224 = l___private_Init_Lean_Elab_Quotation_1__quoteName___main(x_14); +x_224 = l___private_Init_Lean_Syntax_7__quoteName___main(x_14); x_225 = lean_array_push(x_159, x_224); x_226 = lean_array_push(x_225, x_151); x_227 = lean_alloc_ctor(1, 2, 0); @@ -9791,7 +9791,7 @@ x_36 = lean_ctor_get(x_34, 0); lean_dec(x_36); x_37 = l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__8; x_38 = lean_array_push(x_37, x_31); -x_39 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_39 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_40 = lean_array_push(x_38, x_39); x_41 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; x_42 = lean_alloc_ctor(1, 2, 0); @@ -9810,7 +9810,7 @@ lean_inc(x_45); lean_dec(x_34); x_46 = l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__8; x_47 = lean_array_push(x_46, x_31); -x_48 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_48 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_49 = lean_array_push(x_47, x_48); x_50 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; x_51 = lean_alloc_ctor(1, 2, 0); @@ -10058,7 +10058,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Array_empty___closed__1; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__11; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__11; x_3 = lean_array_push(x_1, x_2); return x_3; } @@ -11206,7 +11206,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Elab_Command_elabNoKindMacroRulesAux___closed__2; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_3 = lean_array_push(x_1, x_2); return x_3; } @@ -11216,7 +11216,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Elab_Command_elabNoKindMacroRulesAux___closed__3; -x_2 = l___private_Init_Lean_Elab_Quotation_11__letBindRhss___main___closed__17; +x_2 = l___private_Init_Lean_Elab_Quotation_8__letBindRhss___main___closed__17; x_3 = lean_array_push(x_1, x_2); return x_3; } @@ -13218,7 +13218,7 @@ lean_ctor_set(x_53, 1, x_51); x_54 = lean_array_push(x_45, x_53); x_55 = l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__8; x_56 = lean_array_push(x_55, x_35); -x_57 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_57 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_58 = lean_array_push(x_56, x_57); x_59 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; x_60 = lean_alloc_ctor(1, 2, 0); @@ -13299,7 +13299,7 @@ lean_ctor_set(x_100, 1, x_98); x_101 = lean_array_push(x_92, x_100); x_102 = l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__8; x_103 = lean_array_push(x_102, x_82); -x_104 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_104 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_105 = lean_array_push(x_103, x_104); x_106 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; x_107 = lean_alloc_ctor(1, 2, 0); @@ -13496,12 +13496,12 @@ x_19 = lean_string_dec_eq(x_17, x_18); if (x_19 == 0) { lean_object* x_20; uint8_t x_21; -x_20 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_20 = l_Lean_Nat_HasQuote___closed__1; x_21 = lean_string_dec_eq(x_17, x_20); if (x_21 == 0) { lean_object* x_22; uint8_t x_23; -x_22 = l_Lean_Parser_Term_str___elambda__1___closed__1; +x_22 = l_Lean_String_HasQuote___closed__1; x_23 = lean_string_dec_eq(x_17, x_22); if (x_23 == 0) { @@ -14132,7 +14132,7 @@ lean_ctor_set(x_62, 1, x_60); x_63 = lean_array_push(x_54, x_62); x_64 = l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__8; x_65 = lean_array_push(x_64, x_39); -x_66 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_66 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_67 = lean_array_push(x_65, x_66); x_68 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; x_69 = lean_alloc_ctor(1, 2, 0); @@ -14205,7 +14205,7 @@ lean_ctor_set(x_108, 1, x_106); x_109 = lean_array_push(x_100, x_108); x_110 = l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__8; x_111 = lean_array_push(x_110, x_39); -x_112 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_112 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_113 = lean_array_push(x_111, x_112); x_114 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; x_115 = lean_alloc_ctor(1, 2, 0); @@ -14294,7 +14294,7 @@ lean_ctor_set(x_159, 1, x_157); x_160 = lean_array_push(x_151, x_159); x_161 = l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__8; x_162 = lean_array_push(x_161, x_136); -x_163 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_163 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_164 = lean_array_push(x_162, x_163); x_165 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; x_166 = lean_alloc_ctor(1, 2, 0); @@ -14369,7 +14369,7 @@ lean_ctor_set(x_206, 1, x_204); x_207 = lean_array_push(x_198, x_206); x_208 = l_Lean_Elab_Command_elabMacroRulesAux___lambda__1___closed__8; x_209 = lean_array_push(x_208, x_136); -x_210 = l___private_Init_Lean_Elab_Quotation_5__quoteSyntax___main___closed__56; +x_210 = l___private_Init_Lean_Elab_Quotation_2__quoteSyntax___main___closed__57; x_211 = lean_array_push(x_209, x_210); x_212 = l_Lean_Parser_Term_tacticStxQuot___elambda__1___closed__2; x_213 = lean_alloc_ctor(1, 2, 0); diff --git a/stage0/stdlib/Init/Lean/Elab/SyntheticMVars.c b/stage0/stdlib/Init/Lean/Elab/SyntheticMVars.c index 81b7c17556..703e98ee0b 100644 --- a/stage0/stdlib/Init/Lean/Elab/SyntheticMVars.c +++ b/stage0/stdlib/Init/Lean/Elab/SyntheticMVars.c @@ -2613,6 +2613,7 @@ x_52 = l_List_filterAuxM___main___at___private_Init_Lean_Elab_SyntheticMVars_7__ x_53 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_53, 0, x_52); lean_ctor_set(x_53, 1, x_51); +lean_inc(x_6); lean_inc(x_19); x_54 = l_Lean_Elab_Term_logTrace(x_19, x_21, x_53, x_6, x_49); x_55 = lean_ctor_get(x_54, 1); @@ -2703,6 +2704,7 @@ if (x_33 == 0) { lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; x_34 = l_List_filterAuxM___main___at___private_Init_Lean_Elab_SyntheticMVars_7__synthesizeSyntheticMVarsStep___spec__2___closed__3; +lean_inc(x_6); x_35 = l_Lean_Elab_Term_logTrace(x_19, x_21, x_34, x_6, x_28); lean_dec(x_21); x_36 = lean_ctor_get(x_35, 1); @@ -2717,6 +2719,7 @@ else { lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; x_38 = l_List_filterAuxM___main___at___private_Init_Lean_Elab_SyntheticMVars_7__synthesizeSyntheticMVarsStep___spec__2___closed__6; +lean_inc(x_6); x_39 = l_Lean_Elab_Term_logTrace(x_19, x_21, x_38, x_6, x_28); lean_dec(x_21); x_40 = lean_ctor_get(x_39, 1); @@ -2915,6 +2918,7 @@ x_115 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_115, 0, x_113); lean_ctor_set(x_115, 1, x_114); x_116 = lean_box(0); +lean_inc(x_3); x_117 = l_Lean_Elab_Term_logTrace(x_105, x_116, x_115, x_3, x_104); x_118 = lean_ctor_get(x_117, 1); lean_inc(x_118); @@ -2930,6 +2934,7 @@ x_120 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_120, 0, x_113); lean_ctor_set(x_120, 1, x_119); x_121 = lean_box(0); +lean_inc(x_3); x_122 = l_Lean_Elab_Term_logTrace(x_105, x_121, x_120, x_3, x_104); x_123 = lean_ctor_get(x_122, 1); lean_inc(x_123); @@ -4181,7 +4186,6 @@ _start: { lean_object* x_5; x_5 = l_List_forM___main___at___private_Init_Lean_Elab_SyntheticMVars_9__reportStuckSyntheticMVars___spec__1___lambda__1(x_1, x_2, x_3, x_4); -lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); return x_5; diff --git a/stage0/stdlib/Init/Lean/Elab/Tactic/Basic.c b/stage0/stdlib/Init/Lean/Elab/Tactic/Basic.c index ee79abfcb6..b18a940f85 100644 --- a/stage0/stdlib/Init/Lean/Elab/Tactic/Basic.c +++ b/stage0/stdlib/Init/Lean/Elab/Tactic/Basic.c @@ -32,7 +32,6 @@ lean_object* l_PersistentHashMap_find_x3f___at_Lean_Elab_Tactic_evalTactic___mai lean_object* l_Lean_Elab_Tactic_monadLog___lambda__4(lean_object*, lean_object*, lean_object*); lean_object* l_AssocList_find_x3f___main___at_Lean_Elab_Tactic_evalTactic___main___spec__6___boxed(lean_object*, lean_object*); lean_object* l_Lean_Elab_Tactic_monadQuotation; -extern lean_object* l_Lean_Meta_SynthInstance_inferTCGoalsLRAttr___closed__1; lean_object* l_Lean_Elab_Tactic_withMainMVarContext(lean_object*); lean_object* l_unreachable_x21___rarg(lean_object*); extern lean_object* l_Lean_nullKind; @@ -272,6 +271,7 @@ extern lean_object* l_Lean_Parser_Tactic_case___elambda__1___closed__2; lean_object* l_Lean_Elab_Tactic_forEachVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_nullKind___closed__2; lean_object* l_Lean_Elab_Tactic_monadLog___lambda__1(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5; lean_object* l_Lean_Elab_Tactic_evalRevert(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Tactic_evalAssumption___lambda__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Tactic_liftMetaTactic___lambda__1(lean_object*, lean_object*, lean_object*); @@ -279,7 +279,6 @@ lean_object* l_PersistentHashMap_empty___at_Lean_Elab_Tactic_tacticElabAttribute lean_object* l_Lean_Elab_Tactic_evalIntros___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_List_erase___main___at_Lean_Elab_Tactic_evalCase___spec__2(lean_object*, lean_object*); lean_object* l_Lean_Elab_Tactic_appendGoals(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Elab_Term_traceAtCmdPos___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Tactic_evalSubst___closed__1; lean_object* l_Lean_Elab_Tactic_throwUnsupportedSyntax(lean_object*); lean_object* l_Lean_Elab_Tactic_withLCtx(lean_object*); @@ -302,6 +301,7 @@ lean_object* l_Lean_Elab_Tactic_liftMetaTactic(lean_object*, lean_object*, lean_ lean_object* l_Lean_Elab_Tactic_evalTactic___main___closed__1; lean_object* l___regBuiltin_Lean_Elab_Tactic_evalNestedTacticBlock(lean_object*); lean_object* l_AssocList_find_x3f___main___at_Lean_Elab_Tactic_evalTactic___main___spec__6(lean_object*, lean_object*); +lean_object* l_Lean_Elab_Term_traceAtCmdPos(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_environment_main_module(lean_object*); lean_object* l___regBuiltin_Lean_Elab_Tactic_evalTraceState___closed__1; lean_object* l_Lean_Elab_Tactic_evalTactic___main___lambda__1___boxed(lean_object*, lean_object*); @@ -3053,7 +3053,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj x_1 = l_Lean_Elab_Tactic_tacticElabAttribute___closed__3; x_2 = lean_box(0); x_3 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__1; -x_4 = l_Lean_Meta_SynthInstance_inferTCGoalsLRAttr___closed__1; +x_4 = l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5; x_5 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__3; x_6 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__4; x_7 = lean_alloc_ctor(0, 6, 0); @@ -3106,7 +3106,7 @@ lean_object* l_Lean_Elab_Tactic_traceAtCmdPos(lean_object* x_1, lean_object* x_2 _start: { lean_object* x_5; lean_object* x_6; -x_5 = lean_alloc_closure((void*)(l_Lean_Elab_Term_traceAtCmdPos___boxed), 4, 2); +x_5 = lean_alloc_closure((void*)(l_Lean_Elab_Term_traceAtCmdPos), 4, 2); lean_closure_set(x_5, 0, x_1); lean_closure_set(x_5, 1, x_2); x_6 = l_Lean_Elab_Tactic_liftTermElabM___rarg(x_5, x_3, x_4); @@ -13013,7 +13013,6 @@ x_9 = lean_ctor_get(x_6, 3); lean_inc(x_9); lean_dec(x_6); x_10 = l_Lean_FileMap_toPosition(x_7, x_9); -lean_dec(x_9); lean_dec(x_7); x_11 = l_Lean_Elab_Tactic_addContext(x_1, x_4, x_5); if (lean_obj_tag(x_11) == 0) @@ -13095,6 +13094,8 @@ x_29 = lean_ctor_get(x_27, 1); lean_inc(x_29); lean_dec(x_27); x_30 = lean_ctor_get(x_3, 0); +lean_inc(x_30); +lean_dec(x_3); x_31 = l_Lean_FileMap_toPosition(x_28, x_30); lean_dec(x_28); x_32 = l_Lean_Elab_Tactic_addContext(x_1, x_4, x_5); @@ -13175,7 +13176,6 @@ lean_object* x_6; lean_object* x_7; x_6 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_6, 0, x_1); x_7 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Tactic_evalTraceState___spec__4(x_3, x_2, x_6, x_4, x_5); -lean_dec(x_6); if (lean_obj_tag(x_7) == 0) { lean_object* x_8; lean_object* x_9; uint8_t x_10; @@ -13453,7 +13453,6 @@ uint8_t x_6; lean_object* x_7; x_6 = lean_unbox(x_2); lean_dec(x_2); x_7 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Tactic_evalTraceState___spec__4(x_1, x_6, x_3, x_4, x_5); -lean_dec(x_3); return x_7; } } diff --git a/stage0/stdlib/Init/Lean/Elab/Tactic/Generalize.c b/stage0/stdlib/Init/Lean/Elab/Tactic/Generalize.c index 2517c11a57..ae131f671a 100644 --- a/stage0/stdlib/Init/Lean/Elab/Tactic/Generalize.c +++ b/stage0/stdlib/Init/Lean/Elab/Tactic/Generalize.c @@ -371,7 +371,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l___private_Init_Lean_Elab_Tactic_Generalize_4__evalGeneralizeWithEq___lambda__1___closed__1; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } diff --git a/stage0/stdlib/Init/Lean/Elab/Term.c b/stage0/stdlib/Init/Lean/Elab/Term.c index b8b88a9602..da0b12cc7e 100644 --- a/stage0/stdlib/Init/Lean/Elab/Term.c +++ b/stage0/stdlib/Init/Lean/Elab/Term.c @@ -30,6 +30,7 @@ lean_object* l_Lean_mkAppStx(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_monadQuotation; lean_object* l___regBuiltin_Lean_Elab_Term_elabArrayLit___closed__1; lean_object* l_Lean_Elab_Term_elabRawNumLit___closed__1; +extern lean_object* l_Lean_Closure_mkNewLevelParam___closed__2; lean_object* l___regBuiltin_Lean_Elab_Term_elabTypeStx___closed__1; lean_object* l_Lean_extractMacroScopes(lean_object*); lean_object* l_Lean_Elab_Term_synthesizeInstMVarCore___closed__8; @@ -56,7 +57,7 @@ lean_object* l_Lean_mkSort(lean_object*); lean_object* l_Lean_Elab_Term_instantiateMVars(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_synthesizeInstMVarCore___closed__9; lean_object* l_Lean_Elab_Term_mkFreshExprMVar(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_Meta_SynthInstance_inferTCGoalsLRAttr___closed__1; +extern lean_object* l_Lean_Nat_HasQuote___closed__2; extern lean_object* l_Lean_nullKind; lean_object* l_Lean_Meta_whnfForall(lean_object*, lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at___private_Init_Lean_Elab_Term_5__expandCDot___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -90,7 +91,6 @@ lean_object* l___private_Init_Lean_Elab_Term_8__exceptionToSorry(lean_object*, l lean_object* l_Lean_Elab_Term_elabTermAux___main___closed__4; lean_object* l___private_Init_Lean_Elab_Term_8__exceptionToSorry___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_mkAppM(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Elab_Term_levelMVarToParam___closed__1; lean_object* l_Lean_Elab_Term_elabParen(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getIdAt(lean_object*, lean_object*); lean_object* l_ReaderT_read___at_Lean_Elab_Term_monadLog___spec__1(lean_object*, lean_object*); @@ -163,7 +163,6 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabProp(lean_object*); lean_object* lean_string_append(lean_object*, lean_object*); lean_object* l_PersistentArray_forM___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Meta_Exception_toStr___closed__1; -extern lean_object* l_Lean_Parser_Term_num___elambda__1___closed__1; lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Elab_Term_elabListLit___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_ensureType(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabBadCDot___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -181,6 +180,7 @@ lean_object* l_Lean_Elab_Term_mkFreshAnonymousName___rarg___closed__1; uint8_t l___private_Init_Lean_Elab_Term_11__isExplicit(lean_object*); lean_object* l_Lean_Elab_Term_isTypeFormer(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_withIncRecDepth(lean_object*); +lean_object* l_Lean_Elab_Level_elabLevel(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_mkAuxName(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_unfoldDefinitionAux___at_Lean_Meta_unfoldDefinition_x3f___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabRawCharLit(lean_object*); @@ -349,7 +349,6 @@ lean_object* l_Lean_Elab_Term_elabByTactic___closed__2; lean_object* l_Lean_Elab_Term_mkExplicitBinder___closed__3; lean_object* l___private_Init_Lean_Elab_Term_10__elabTermUsing(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_KernelException_toMessageData(lean_object*, lean_object*); -lean_object* l_Lean_Elab_Term_levelMVarToParam___closed__2; lean_object* l_Lean_Elab_Term_elabStr___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_mkConst___closed__2; lean_object* l_Lean_Elab_Term_isType(lean_object*, lean_object*, lean_object*, lean_object*); @@ -473,6 +472,7 @@ size_t lean_usize_modn(size_t, lean_object*); lean_object* l_Lean_Elab_Term_expandCDot_x3f___closed__2; lean_object* l_Lean_Elab_Term_elabImplicitLambda___main___lambda__1(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_FileMap_toPosition(lean_object*, lean_object*); +extern lean_object* l_Lean_KernelException_toMessageData___closed__15; lean_object* l_Lean_Elab_Term_liftLevelM(lean_object*); lean_object* l_Lean_Elab_Term_elabProp(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_charToExpr___lambda__1___closed__2; @@ -489,7 +489,6 @@ lean_object* l_Lean_Elab_mkMessageAt___at_Lean_Elab_Term_throwError___spec__3(le lean_object* l_mkHashMapImp___rarg(lean_object*); lean_object* l_Lean_Elab_Term_whnfCore___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_getCurrNamespace___boxed(lean_object*, lean_object*); -lean_object* l_Lean_Elab_Level_elabLevel___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_getLocalInsts(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_mkFreshInstanceName___rarg(lean_object*); lean_object* l_Lean_Meta_whnf(lean_object*, lean_object*, lean_object*); @@ -520,10 +519,12 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabSort(lean_object*); lean_object* l_Lean_Elab_Term_resolveName___closed__9; lean_object* l_Lean_Elab_Term_throwUnsupportedSyntax(lean_object*, lean_object*); size_t l_USize_land(size_t, size_t); +extern lean_object* l_Lean_String_HasQuote___closed__2; lean_object* l_Lean_Elab_Term_mkConst(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_mkConst___closed__3; lean_object* l_Lean_Elab_Term_resolveName___closed__4; extern lean_object* l_Lean_nullKind___closed__2; +extern lean_object* l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5; lean_object* l_Lean_Elab_Term_throwTypeMismatchError___rarg___closed__2; lean_object* l___private_Init_Lean_Elab_Term_10__elabTermUsing___main___closed__2; lean_object* l_Lean_Elab_Term_elabNamedHole___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -542,7 +543,6 @@ lean_object* l_Lean_Elab_Term_isDefEq(lean_object*, lean_object*, lean_object*, lean_object* l___private_Init_Lean_Elab_Term_13__tryCoeSort___closed__5; lean_object* l_Lean_Elab_Term_synthesizeInstMVarCore___closed__10; lean_object* l_Lean_Elab_Term_Lean_Elab_MonadMacroAdapter___closed__5; -lean_object* l_Lean_Elab_Term_logDbgTrace___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_ConstantInfo_lparams(lean_object*); lean_object* l_Lean_Elab_Term_mkTermElabAttribute___closed__9; lean_object* lean_local_ctx_mk_local_decl(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); @@ -550,16 +550,13 @@ lean_object* l_Lean_Elab_Term_mkFreshAnonymousName(lean_object*); uint8_t l___private_Init_Lean_Elab_Term_4__hasCDot(lean_object*); lean_object* l_Lean_Elab_Term_withLCtx(lean_object*); extern lean_object* l_Option_HasRepr___rarg___closed__3; -lean_object* l_Lean_Elab_Term_traceAtCmdPos___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_PersistentHashMap_findAtAux___main___at_Lean_Elab_Term_elabTermAux___main___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l___private_Init_Lean_Elab_Term_4__hasCDot___main(lean_object*); lean_object* l_Lean_Elab_Term_withoutPostponing___rarg(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Parser_Term_prop___elambda__1___closed__2; -extern lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8; lean_object* l_Lean_Elab_Term_savingMCtx(lean_object*); lean_object* l_Lean_Elab_Term_Exception_inhabited; lean_object* l_Lean_Elab_Term_elabHole(lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__2; extern lean_object* l_Lean_Syntax_inhabited; lean_object* l___regBuiltin_Lean_Elab_Term_elabNamedHole___closed__1; lean_object* l_Lean_Elab_Term_elabBadCDot___closed__2; @@ -568,7 +565,7 @@ lean_object* l_Lean_Elab_Term_liftMetaM___rarg___boxed(lean_object*, lean_object lean_object* l_Lean_Meta_trySynthInstance(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_mkAppStx___closed__5; extern lean_object* l_Lean_Expr_listLitAux___main___closed__6; -lean_object* l_Lean_Elab_Term_MetaHasEval___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Elab_Term_MetaHasEval___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); lean_object* l___private_Init_Lean_Elab_Term_6__isTypeApp_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Elab_Term_3__fromMetaState___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_isTypeFormer___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -594,6 +591,7 @@ lean_object* l_HashMapImp_find_x3f___at_Lean_Elab_Term_elabTermAux___main___spec lean_object* l_Lean_getMaxRecDepth(lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabChar(lean_object*); lean_object* l_Lean_Elab_Term_throwError___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Elab_Term_MetaHasEval___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___regBuiltin_Lean_Elab_Term_elabHole___closed__1; lean_object* l_Lean_Syntax_isTermId_x3f(lean_object*, uint8_t); lean_object* l_Lean_Elab_Term_ensureType___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -764,7 +762,7 @@ lean_object* lean_compile_decl(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Meta_resettingSynthInstanceCache___rarg___closed__1; lean_object* l_Lean_Elab_Term_elabRawCharLit___closed__1; lean_object* l_Lean_MetavarContext_getDecl(lean_object*, lean_object*); -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_resetSynthInstanceCache___boxed(lean_object*); lean_object* l_Lean_Elab_Term_decLevel___closed__2; lean_object* l_Lean_Elab_Term_decLevel___closed__1; @@ -2000,10 +1998,15 @@ if (lean_obj_tag(x_3) == 0) { lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; x_6 = lean_ctor_get(x_4, 2); +lean_inc(x_6); x_7 = lean_ctor_get(x_4, 1); +lean_inc(x_7); x_8 = lean_ctor_get(x_4, 3); +lean_inc(x_8); x_9 = l_Lean_FileMap_toPosition(x_6, x_8); +lean_dec(x_6); x_10 = l_Lean_Elab_Term_addContext(x_1, x_4, x_5); +lean_dec(x_4); x_11 = !lean_is_exclusive(x_10); if (x_11 == 0) { @@ -2011,7 +2014,6 @@ lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; x_12 = lean_ctor_get(x_10, 0); x_13 = lean_box(0); x_14 = l_String_splitAux___main___closed__1; -lean_inc(x_7); x_15 = lean_alloc_ctor(0, 5, 1); lean_ctor_set(x_15, 0, x_7); lean_ctor_set(x_15, 1, x_9); @@ -2032,7 +2034,6 @@ lean_inc(x_16); lean_dec(x_10); x_18 = lean_box(0); x_19 = l_String_splitAux___main___closed__1; -lean_inc(x_7); x_20 = lean_alloc_ctor(0, 5, 1); lean_ctor_set(x_20, 0, x_7); lean_ctor_set(x_20, 1, x_9); @@ -2050,10 +2051,16 @@ else { lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; x_22 = lean_ctor_get(x_4, 2); +lean_inc(x_22); x_23 = lean_ctor_get(x_4, 1); +lean_inc(x_23); x_24 = lean_ctor_get(x_3, 0); +lean_inc(x_24); +lean_dec(x_3); x_25 = l_Lean_FileMap_toPosition(x_22, x_24); +lean_dec(x_22); x_26 = l_Lean_Elab_Term_addContext(x_1, x_4, x_5); +lean_dec(x_4); x_27 = !lean_is_exclusive(x_26); if (x_27 == 0) { @@ -2061,7 +2068,6 @@ lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; x_28 = lean_ctor_get(x_26, 0); x_29 = lean_box(0); x_30 = l_String_splitAux___main___closed__1; -lean_inc(x_23); x_31 = lean_alloc_ctor(0, 5, 1); lean_ctor_set(x_31, 0, x_23); lean_ctor_set(x_31, 1, x_25); @@ -2082,7 +2088,6 @@ lean_inc(x_32); lean_dec(x_26); x_34 = lean_box(0); x_35 = l_String_splitAux___main___closed__1; -lean_inc(x_23); x_36 = lean_alloc_ctor(0, 5, 1); lean_ctor_set(x_36, 0, x_23); lean_ctor_set(x_36, 1, x_25); @@ -2111,7 +2116,6 @@ lean_dec(x_6); x_9 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_9, 0, x_7); x_10 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Term_throwError___spec__3(x_1, x_2, x_9, x_4, x_8); -lean_dec(x_9); return x_10; } } @@ -2130,7 +2134,6 @@ uint8_t x_8; lean_object* x_9; uint8_t x_10; lean_dec(x_5); x_8 = 2; x_9 = l_Lean_Elab_mkMessage___at_Lean_Elab_Term_throwError___spec__1(x_2, x_8, x_6, x_3, x_4); -lean_dec(x_3); lean_dec(x_6); x_10 = !lean_is_exclusive(x_9); if (x_10 == 0) @@ -2169,7 +2172,6 @@ lean_object* x_19; uint8_t x_20; lean_object* x_21; uint8_t x_22; x_19 = l_Lean_Elab_addMacroStack(x_2, x_5); x_20 = 2; x_21 = l_Lean_Elab_mkMessage___at_Lean_Elab_Term_throwError___spec__1(x_19, x_20, x_6, x_3, x_4); -lean_dec(x_3); lean_dec(x_6); x_22 = !lean_is_exclusive(x_21); if (x_22 == 0) @@ -2229,8 +2231,6 @@ uint8_t x_6; lean_object* x_7; x_6 = lean_unbox(x_2); lean_dec(x_2); x_7 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Term_throwError___spec__3(x_1, x_6, x_3, x_4, x_5); -lean_dec(x_4); -lean_dec(x_3); return x_7; } } @@ -2241,7 +2241,6 @@ uint8_t x_6; lean_object* x_7; x_6 = lean_unbox(x_2); lean_dec(x_2); x_7 = l_Lean_Elab_mkMessage___at_Lean_Elab_Term_throwError___spec__1(x_1, x_6, x_3, x_4, x_5); -lean_dec(x_4); lean_dec(x_3); return x_7; } @@ -2963,7 +2962,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj x_1 = l_Lean_Elab_Term_termElabAttribute___closed__3; x_2 = lean_box(0); x_3 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__1; -x_4 = l_Lean_Meta_SynthInstance_inferTCGoalsLRAttr___closed__1; +x_4 = l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5; x_5 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__3; x_6 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__4; x_7 = lean_alloc_ctor(0, 6, 0); @@ -3011,21 +3010,22 @@ return x_4; } default: { -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_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; x_5 = lean_ctor_get(x_1, 0); lean_inc(x_5); lean_dec(x_1); x_6 = lean_box(0); -x_7 = lean_unsigned_to_nat(0u); -x_8 = l_Lean_Syntax_formatStxAux___main(x_6, x_7, x_5); -x_9 = l_Lean_Options_empty; -x_10 = l_Lean_Format_pretty(x_8, x_9); -x_11 = l_List_repr___rarg___closed__2; -x_12 = lean_string_append(x_11, x_10); -lean_dec(x_10); -x_13 = l_List_repr___rarg___closed__3; -x_14 = lean_string_append(x_12, x_13); -return x_14; +x_7 = 0; +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_Syntax_formatStxAux___main(x_6, x_7, x_8, x_5); +x_10 = l_Lean_Options_empty; +x_11 = l_Lean_Format_pretty(x_9, x_10); +x_12 = l_List_repr___rarg___closed__2; +x_13 = lean_string_append(x_12, x_11); +lean_dec(x_11); +x_14 = l_List_repr___rarg___closed__3; +x_15 = lean_string_append(x_13, x_14); +return x_15; } } } @@ -3467,7 +3467,6 @@ lean_object* x_6; lean_object* x_7; uint8_t x_8; x_6 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_6, 0, x_1); x_7 = l_Lean_Elab_mkMessageAt___at_Lean_Elab_Term_throwError___spec__3(x_3, x_2, x_6, x_4, x_5); -lean_dec(x_6); x_8 = !lean_is_exclusive(x_7); if (x_8 == 0) { @@ -3594,11 +3593,15 @@ x_8 = lean_ctor_get(x_6, 1); lean_inc(x_8); lean_dec(x_6); x_9 = lean_ctor_get(x_4, 0); +lean_inc(x_9); x_10 = lean_ctor_get(x_9, 1); +lean_inc(x_10); x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +lean_dec(x_9); x_12 = lean_ctor_get(x_11, 0); lean_inc(x_12); -lean_inc(x_10); +lean_dec(x_11); x_13 = lean_alloc_ctor(0, 4, 0); lean_ctor_set(x_13, 0, x_7); lean_ctor_set(x_13, 1, x_8); @@ -3622,7 +3625,6 @@ uint8_t x_6; lean_object* x_7; x_6 = lean_unbox(x_2); lean_dec(x_2); x_7 = l_Lean_Elab_logAt___at_Lean_Elab_Term_logTrace___spec__2(x_1, x_6, x_3, x_4, x_5); -lean_dec(x_4); return x_7; } } @@ -3633,7 +3635,6 @@ uint8_t x_6; lean_object* x_7; x_6 = lean_unbox(x_2); lean_dec(x_2); x_7 = l_Lean_Elab_log___at_Lean_Elab_Term_logTrace___spec__1(x_1, x_6, x_3, x_4, x_5); -lean_dec(x_4); lean_dec(x_1); return x_7; } @@ -3643,7 +3644,6 @@ _start: { lean_object* x_6; x_6 = l_Lean_Elab_Term_logTrace(x_1, x_2, x_3, x_4, x_5); -lean_dec(x_4); lean_dec(x_2); return x_6; } @@ -3665,6 +3665,7 @@ lean_dec(x_8); if (x_10 == 0) { lean_object* x_11; +lean_dec(x_4); lean_dec(x_3); lean_dec(x_1); x_11 = lean_box(0); @@ -3695,6 +3696,7 @@ lean_dec(x_15); if (x_17 == 0) { lean_object* x_18; lean_object* x_19; +lean_dec(x_4); lean_dec(x_3); lean_dec(x_1); x_18 = lean_box(0); @@ -3719,7 +3721,6 @@ _start: { lean_object* x_6; x_6 = l_Lean_Elab_Term_trace(x_1, x_2, x_3, x_4, x_5); -lean_dec(x_4); lean_dec(x_2); return x_6; } @@ -3751,6 +3752,7 @@ lean_dec(x_6); if (x_9 == 0) { lean_object* x_10; +lean_dec(x_2); lean_dec(x_1); x_10 = lean_box(0); lean_ctor_set(x_4, 0, x_10); @@ -3779,6 +3781,7 @@ lean_dec(x_13); if (x_16 == 0) { lean_object* x_17; lean_object* x_18; +lean_dec(x_2); lean_dec(x_1); x_17 = lean_box(0); x_18 = lean_alloc_ctor(0, 2, 0); @@ -3796,15 +3799,6 @@ return x_20; } } } -lean_object* l_Lean_Elab_Term_logDbgTrace___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -lean_object* x_4; -x_4 = l_Lean_Elab_Term_logDbgTrace(x_1, x_2, x_3); -lean_dec(x_2); -return x_4; -} -} lean_object* _init_l_Lean_Elab_Term_throwErrorIfErrors___closed__1() { _start: { @@ -3878,6 +3872,7 @@ lean_dec(x_7); if (x_9 == 0) { lean_object* x_10; +lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); x_10 = lean_box(0); @@ -3909,6 +3904,7 @@ lean_dec(x_15); if (x_17 == 0) { lean_object* x_18; lean_object* x_19; +lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); x_18 = lean_box(0); @@ -3929,15 +3925,6 @@ return x_23; } } } -lean_object* l_Lean_Elab_Term_traceAtCmdPos___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_Elab_Term_traceAtCmdPos(x_1, x_2, x_3, x_4); -lean_dec(x_3); -return x_5; -} -} lean_object* l_Lean_Elab_Term_dbgTrace___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { @@ -3973,7 +3960,6 @@ x_8 = lean_ctor_get(x_1, 3); lean_inc(x_8); lean_dec(x_1); x_9 = l_Lean_Elab_mkMessageCore(x_5, x_6, x_3, x_4, x_8); -lean_dec(x_8); lean_dec(x_6); return x_9; } @@ -3985,7 +3971,6 @@ x_10 = lean_ctor_get(x_7, 0); lean_inc(x_10); lean_dec(x_7); x_11 = l_Lean_Elab_mkMessageCore(x_5, x_6, x_3, x_4, x_10); -lean_dec(x_10); lean_dec(x_6); return x_11; } @@ -9609,7 +9594,7 @@ lean_object* l_Lean_Elab_Term_elabLevel(lean_object* x_1, lean_object* x_2, lean _start: { lean_object* x_4; lean_object* x_5; -x_4 = lean_alloc_closure((void*)(l_Lean_Elab_Level_elabLevel___boxed), 3, 1); +x_4 = lean_alloc_closure((void*)(l_Lean_Elab_Level_elabLevel), 3, 1); lean_closure_set(x_4, 0, x_1); x_5 = l_Lean_Elab_Term_liftLevelM___rarg(x_4, x_2, x_3); return x_5; @@ -10507,24 +10492,6 @@ x_4 = l_List_elem___main___at_Lean_NameHashSet_insert___spec__2(x_2, x_3); return x_4; } } -lean_object* _init_l_Lean_Elab_Term_levelMVarToParam___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("u"); -return x_1; -} -} -lean_object* _init_l_Lean_Elab_Term_levelMVarToParam___closed__2() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = lean_box(0); -x_2 = l_Lean_Elab_Term_levelMVarToParam___closed__1; -x_3 = lean_name_mk_string(x_1, x_2); -return x_3; -} -} lean_object* l_Lean_Elab_Term_levelMVarToParam(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { @@ -10538,7 +10505,7 @@ x_6 = lean_ctor_get(x_4, 0); x_7 = lean_ctor_get(x_4, 1); x_8 = lean_alloc_closure((void*)(l_Lean_Elab_Term_levelMVarToParam___lambda__1___boxed), 2, 1); lean_closure_set(x_8, 0, x_2); -x_9 = l_Lean_Elab_Term_levelMVarToParam___closed__2; +x_9 = l_Lean_Closure_mkNewLevelParam___closed__2; x_10 = lean_unsigned_to_nat(1u); x_11 = l_Lean_MetavarContext_levelMVarToParam(x_6, x_8, x_1, x_9, x_10); x_12 = !lean_is_exclusive(x_7); @@ -10668,7 +10635,7 @@ lean_inc(x_42); lean_dec(x_4); x_44 = lean_alloc_closure((void*)(l_Lean_Elab_Term_levelMVarToParam___lambda__1___boxed), 2, 1); lean_closure_set(x_44, 0, x_2); -x_45 = l_Lean_Elab_Term_levelMVarToParam___closed__2; +x_45 = l_Lean_Closure_mkNewLevelParam___closed__2; x_46 = lean_unsigned_to_nat(1u); x_47 = l_Lean_MetavarContext_levelMVarToParam(x_42, x_44, x_1, x_45, x_46); x_48 = lean_ctor_get(x_43, 0); @@ -12960,7 +12927,7 @@ x_14 = l_Lean_MessageData_ofList___closed__3; x_15 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_15, 0, x_13); lean_ctor_set(x_15, 1, x_14); -x_16 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8; +x_16 = l_Lean_KernelException_toMessageData___closed__12; x_17 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_17, 0, x_15); lean_ctor_set(x_17, 1, x_16); @@ -12973,7 +12940,7 @@ lean_ctor_set(x_20, 1, x_19); x_21 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_21, 0, x_20); lean_ctor_set(x_21, 1, x_14); -x_22 = l_Lean_KernelException_toMessageData___closed__12; +x_22 = l_Lean_KernelException_toMessageData___closed__15; x_23 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_23, 0, x_21); lean_ctor_set(x_23, 1, x_22); @@ -16746,6 +16713,7 @@ x_28 = l_Lean_MessageData_coeOfOptExpr___closed__1; x_29 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_29, 0, x_27); lean_ctor_set(x_29, 1, x_28); +lean_inc(x_3); x_30 = l_Lean_Elab_Term_logTrace(x_23, x_1, x_29, x_3, x_22); x_31 = lean_ctor_get(x_30, 1); lean_inc(x_31); @@ -16763,6 +16731,7 @@ lean_ctor_set(x_33, 0, x_32); x_34 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_34, 0, x_27); lean_ctor_set(x_34, 1, x_33); +lean_inc(x_3); x_35 = l_Lean_Elab_Term_logTrace(x_23, x_1, x_34, x_3, x_22); x_36 = lean_ctor_get(x_35, 1); lean_inc(x_36); @@ -17662,6 +17631,7 @@ x_110 = l_Lean_Elab_Term_elabTermAux___main___closed__7; x_111 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_111, 0, x_110); lean_ctor_set(x_111, 1, x_109); +lean_inc(x_28); x_112 = l_Lean_Elab_Term_logTrace(x_107, x_3, x_111, x_28, x_106); x_113 = lean_ctor_get(x_112, 1); lean_inc(x_113); @@ -17683,6 +17653,7 @@ lean_ctor_set(x_117, 1, x_116); x_118 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_118, 0, x_117); lean_ctor_set(x_118, 1, x_109); +lean_inc(x_28); x_119 = l_Lean_Elab_Term_logTrace(x_107, x_3, x_118, x_28, x_106); x_120 = lean_ctor_get(x_119, 1); lean_inc(x_120); @@ -18044,6 +18015,7 @@ x_201 = l_Lean_Elab_Term_elabTermAux___main___closed__7; x_202 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_202, 0, x_201); lean_ctor_set(x_202, 1, x_200); +lean_inc(x_128); x_203 = l_Lean_Elab_Term_logTrace(x_198, x_3, x_202, x_128, x_197); x_204 = lean_ctor_get(x_203, 1); lean_inc(x_204); @@ -18065,6 +18037,7 @@ lean_ctor_set(x_208, 1, x_207); x_209 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_209, 0, x_208); lean_ctor_set(x_209, 1, x_200); +lean_inc(x_128); x_210 = l_Lean_Elab_Term_logTrace(x_198, x_3, x_209, x_128, x_197); x_211 = lean_ctor_get(x_210, 1); lean_inc(x_211); @@ -18525,6 +18498,7 @@ x_317 = l_Lean_Elab_Term_elabTermAux___main___closed__7; x_318 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_318, 0, x_317); lean_ctor_set(x_318, 1, x_316); +lean_inc(x_244); x_319 = l_Lean_Elab_Term_logTrace(x_314, x_3, x_318, x_244, x_313); x_320 = lean_ctor_get(x_319, 1); lean_inc(x_320); @@ -18546,6 +18520,7 @@ lean_ctor_set(x_324, 1, x_323); x_325 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_325, 0, x_324); lean_ctor_set(x_325, 1, x_316); +lean_inc(x_244); x_326 = l_Lean_Elab_Term_logTrace(x_314, x_3, x_325, x_244, x_313); x_327 = lean_ctor_get(x_326, 1); lean_inc(x_327); @@ -19047,6 +19022,7 @@ x_443 = l_Lean_Elab_Term_elabTermAux___main___closed__7; x_444 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_444, 0, x_443); lean_ctor_set(x_444, 1, x_442); +lean_inc(x_370); x_445 = l_Lean_Elab_Term_logTrace(x_440, x_3, x_444, x_370, x_439); x_446 = lean_ctor_get(x_445, 1); lean_inc(x_446); @@ -19068,6 +19044,7 @@ lean_ctor_set(x_450, 1, x_449); x_451 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_451, 0, x_450); lean_ctor_set(x_451, 1, x_442); +lean_inc(x_370); x_452 = l_Lean_Elab_Term_logTrace(x_440, x_3, x_451, x_370, x_439); x_453 = lean_ctor_get(x_452, 1); lean_inc(x_453); @@ -19860,7 +19837,6 @@ lean_inc(x_12); x_20 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_20, 0, x_12); x_21 = l_Lean_Elab_Term_logTrace(x_18, x_1, x_20, x_5, x_17); -lean_dec(x_5); lean_dec(x_1); x_22 = !lean_is_exclusive(x_21); if (x_22 == 0) @@ -19912,7 +19888,6 @@ lean_inc(x_12); x_31 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_31, 0, x_12); x_32 = l_Lean_Elab_Term_logTrace(x_28, x_1, x_31, x_5, x_27); -lean_dec(x_5); lean_dec(x_1); x_33 = lean_ctor_get(x_32, 1); lean_inc(x_33); @@ -27447,7 +27422,7 @@ _start: { lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; x_2 = l_Lean_Elab_Term_termElabAttribute; -x_3 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_3 = l_Lean_String_HasQuote___closed__2; x_4 = l___regBuiltin_Lean_Elab_Term_elabStr___closed__1; x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); return x_5; @@ -27778,7 +27753,7 @@ _start: { lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; x_2 = l_Lean_Elab_Term_termElabAttribute; -x_3 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_3 = l_Lean_Nat_HasQuote___closed__2; x_4 = l___regBuiltin_Lean_Elab_Term_elabNum___closed__1; x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); return x_5; @@ -28013,7 +27988,7 @@ lean_object* _init_l_Lean_Elab_Term_MetaHasEval___rarg___closed__5() { _start: { lean_object* x_1; -x_1 = lean_mk_string("error: elaborator posponed"); +x_1 = lean_mk_string("error: elaborator postponed"); return x_1; } } @@ -28027,343 +28002,344 @@ lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* l_Lean_Elab_Term_MetaHasEval___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l_Lean_Elab_Term_MetaHasEval___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6) { _start: { -uint8_t x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -x_6 = 0; -x_7 = 1; +uint8_t x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_7 = 0; +x_8 = 1; lean_inc(x_3); -x_8 = lean_alloc_ctor(0, 1, 7); -lean_ctor_set(x_8, 0, x_3); -lean_ctor_set_uint8(x_8, sizeof(void*)*1, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 1, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 2, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 3, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 4, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 5, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 6, x_7); -x_9 = l_Lean_getMaxRecDepth(x_3); -x_10 = l_Lean_LocalContext_Inhabited___closed__2; -x_11 = l_Array_empty___closed__1; -x_12 = lean_unsigned_to_nat(0u); -x_13 = lean_alloc_ctor(0, 5, 0); -lean_ctor_set(x_13, 0, x_8); -lean_ctor_set(x_13, 1, x_10); -lean_ctor_set(x_13, 2, x_11); -lean_ctor_set(x_13, 3, x_12); -lean_ctor_set(x_13, 4, x_9); -x_14 = lean_box(0); +x_9 = lean_alloc_ctor(0, 1, 7); +lean_ctor_set(x_9, 0, x_3); +lean_ctor_set_uint8(x_9, sizeof(void*)*1, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 1, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 2, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 3, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 4, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 5, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 6, x_8); +x_10 = l_Lean_getMaxRecDepth(x_3); +x_11 = l_Lean_LocalContext_Inhabited___closed__2; +x_12 = l_Array_empty___closed__1; +x_13 = lean_unsigned_to_nat(0u); +x_14 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_14, 0, x_9); +lean_ctor_set(x_14, 1, x_11); +lean_ctor_set(x_14, 2, x_12); +lean_ctor_set(x_14, 3, x_13); +lean_ctor_set(x_14, 4, x_10); x_15 = lean_box(0); -x_16 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__1; -x_17 = l_Lean_FileMap_Inhabited___closed__1; -x_18 = lean_box(0); -x_19 = l_Lean_firstFrontendMacroScope; -x_20 = 1; -x_21 = lean_alloc_ctor(0, 10, 3); -lean_ctor_set(x_21, 0, x_13); -lean_ctor_set(x_21, 1, x_16); -lean_ctor_set(x_21, 2, x_17); -lean_ctor_set(x_21, 3, x_12); -lean_ctor_set(x_21, 4, x_18); -lean_ctor_set(x_21, 5, x_14); -lean_ctor_set(x_21, 6, x_15); -lean_ctor_set(x_21, 7, x_15); -lean_ctor_set(x_21, 8, x_15); -lean_ctor_set(x_21, 9, x_19); -lean_ctor_set_uint8(x_21, sizeof(void*)*10, x_20); -lean_ctor_set_uint8(x_21, sizeof(void*)*10 + 1, x_20); -lean_ctor_set_uint8(x_21, sizeof(void*)*10 + 2, x_20); -x_22 = l_Lean_MetavarContext_Inhabited___closed__1; -x_23 = l_Lean_Meta_run___rarg___closed__5; -x_24 = l_Lean_NameGenerator_Inhabited___closed__3; -x_25 = l_Lean_TraceState_Inhabited___closed__1; -x_26 = l_PersistentArray_empty___closed__3; -x_27 = lean_alloc_ctor(0, 6, 0); -lean_ctor_set(x_27, 0, x_2); -lean_ctor_set(x_27, 1, x_22); -lean_ctor_set(x_27, 2, x_23); -lean_ctor_set(x_27, 3, x_24); -lean_ctor_set(x_27, 4, x_25); -lean_ctor_set(x_27, 5, x_26); -x_28 = lean_unsigned_to_nat(1u); -x_29 = l_Lean_Unhygienic_run___rarg___closed__1; -x_30 = lean_alloc_ctor(0, 6, 0); -lean_ctor_set(x_30, 0, x_27); -lean_ctor_set(x_30, 1, x_15); -lean_ctor_set(x_30, 2, x_26); -lean_ctor_set(x_30, 3, x_28); -lean_ctor_set(x_30, 4, x_28); -lean_ctor_set(x_30, 5, x_29); -x_31 = lean_apply_2(x_4, x_21, x_30); -if (lean_obj_tag(x_31) == 0) +x_16 = lean_box(0); +x_17 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__1; +x_18 = l_Lean_FileMap_Inhabited___closed__1; +x_19 = lean_box(0); +x_20 = l_Lean_firstFrontendMacroScope; +x_21 = 1; +x_22 = lean_alloc_ctor(0, 10, 3); +lean_ctor_set(x_22, 0, x_14); +lean_ctor_set(x_22, 1, x_17); +lean_ctor_set(x_22, 2, x_18); +lean_ctor_set(x_22, 3, x_13); +lean_ctor_set(x_22, 4, x_19); +lean_ctor_set(x_22, 5, x_15); +lean_ctor_set(x_22, 6, x_16); +lean_ctor_set(x_22, 7, x_16); +lean_ctor_set(x_22, 8, x_16); +lean_ctor_set(x_22, 9, x_20); +lean_ctor_set_uint8(x_22, sizeof(void*)*10, x_21); +lean_ctor_set_uint8(x_22, sizeof(void*)*10 + 1, x_21); +lean_ctor_set_uint8(x_22, sizeof(void*)*10 + 2, x_21); +x_23 = l_Lean_MetavarContext_Inhabited___closed__1; +x_24 = l_Lean_Meta_run___rarg___closed__5; +x_25 = l_Lean_NameGenerator_Inhabited___closed__3; +x_26 = l_Lean_TraceState_Inhabited___closed__1; +x_27 = l_PersistentArray_empty___closed__3; +x_28 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_28, 0, x_2); +lean_ctor_set(x_28, 1, x_23); +lean_ctor_set(x_28, 2, x_24); +lean_ctor_set(x_28, 3, x_25); +lean_ctor_set(x_28, 4, x_26); +lean_ctor_set(x_28, 5, x_27); +x_29 = lean_unsigned_to_nat(1u); +x_30 = l_Lean_Unhygienic_run___rarg___closed__1; +x_31 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_31, 0, x_28); +lean_ctor_set(x_31, 1, x_16); +lean_ctor_set(x_31, 2, x_27); +lean_ctor_set(x_31, 3, x_29); +lean_ctor_set(x_31, 4, x_29); +lean_ctor_set(x_31, 5, x_30); +x_32 = lean_apply_2(x_4, x_22, x_31); +if (lean_obj_tag(x_32) == 0) { -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_31, 0); -lean_inc(x_32); -x_33 = lean_ctor_get(x_31, 1); +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_32, 0); lean_inc(x_33); -lean_dec(x_31); -x_34 = lean_ctor_get(x_33, 2); +x_34 = lean_ctor_get(x_32, 1); lean_inc(x_34); -x_35 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__2; -x_36 = l_PersistentArray_forM___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(x_35, x_34, x_5); -lean_dec(x_34); -if (lean_obj_tag(x_36) == 0) -{ -lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; -x_37 = lean_ctor_get(x_36, 1); -lean_inc(x_37); -lean_dec(x_36); -x_38 = lean_ctor_get(x_33, 0); -lean_inc(x_38); -lean_dec(x_33); -x_39 = lean_ctor_get(x_38, 0); -lean_inc(x_39); -lean_dec(x_38); -x_40 = lean_apply_4(x_1, x_39, x_3, x_32, x_37); -return x_40; -} -else -{ -uint8_t x_41; -lean_dec(x_33); lean_dec(x_32); -lean_dec(x_3); -lean_dec(x_1); -x_41 = !lean_is_exclusive(x_36); -if (x_41 == 0) +x_35 = lean_ctor_get(x_34, 2); +lean_inc(x_35); +x_36 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__2; +x_37 = l_PersistentArray_forM___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(x_36, x_35, x_6); +lean_dec(x_35); +if (lean_obj_tag(x_37) == 0) { -return x_36; +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_38 = lean_ctor_get(x_37, 1); +lean_inc(x_38); +lean_dec(x_37); +x_39 = lean_ctor_get(x_34, 0); +lean_inc(x_39); +lean_dec(x_34); +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +lean_dec(x_39); +x_41 = lean_box(x_21); +x_42 = lean_apply_5(x_1, x_40, x_3, x_33, x_41, x_38); +return x_42; } else { -lean_object* x_42; lean_object* x_43; lean_object* x_44; -x_42 = lean_ctor_get(x_36, 0); -x_43 = lean_ctor_get(x_36, 1); -lean_inc(x_43); -lean_inc(x_42); -lean_dec(x_36); -x_44 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_44, 0, x_42); -lean_ctor_set(x_44, 1, x_43); -return x_44; -} -} +uint8_t x_43; +lean_dec(x_34); +lean_dec(x_33); +lean_dec(x_3); +lean_dec(x_1); +x_43 = !lean_is_exclusive(x_37); +if (x_43 == 0) +{ +return x_37; } else { -lean_object* x_45; -lean_dec(x_3); -lean_dec(x_1); -x_45 = lean_ctor_get(x_31, 0); +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_37, 0); +x_45 = lean_ctor_get(x_37, 1); lean_inc(x_45); -if (lean_obj_tag(x_45) == 0) +lean_inc(x_44); +lean_dec(x_37); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set(x_46, 1, x_45); +return x_46; +} +} +} +else { -lean_object* x_46; -x_46 = lean_ctor_get(x_45, 0); -lean_inc(x_46); -lean_dec(x_45); -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_31, 1); +lean_object* x_47; +lean_dec(x_3); +lean_dec(x_1); +x_47 = lean_ctor_get(x_32, 0); lean_inc(x_47); -lean_dec(x_31); -x_48 = lean_ctor_get(x_46, 0); +if (lean_obj_tag(x_47) == 0) +{ +lean_object* x_48; +x_48 = lean_ctor_get(x_47, 0); lean_inc(x_48); -lean_dec(x_46); -x_49 = lean_ctor_get(x_47, 2); -lean_inc(x_49); lean_dec(x_47); -x_50 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__2; -x_51 = l_PersistentArray_forM___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(x_50, x_49, x_5); -lean_dec(x_49); -if (lean_obj_tag(x_51) == 0) +if (lean_obj_tag(x_48) == 0) { -uint8_t x_52; -x_52 = !lean_is_exclusive(x_51); -if (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 = lean_ctor_get(x_51, 0); -lean_dec(x_53); -x_54 = l_Lean_Message_toString(x_48); -x_55 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_55, 0, x_54); -x_56 = l_Lean_Options_empty; -x_57 = l_Lean_Format_pretty(x_55, x_56); -x_58 = lean_alloc_ctor(18, 1, 0); -lean_ctor_set(x_58, 0, x_57); -lean_ctor_set_tag(x_51, 1); -lean_ctor_set(x_51, 0, x_58); -return x_51; -} -else -{ -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; -x_59 = lean_ctor_get(x_51, 1); -lean_inc(x_59); -lean_dec(x_51); -x_60 = l_Lean_Message_toString(x_48); -x_61 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_61, 0, x_60); -x_62 = l_Lean_Options_empty; -x_63 = l_Lean_Format_pretty(x_61, x_62); -x_64 = lean_alloc_ctor(18, 1, 0); -lean_ctor_set(x_64, 0, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_59); -return x_65; -} -} -else -{ -uint8_t x_66; +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_32, 1); +lean_inc(x_49); +lean_dec(x_32); +x_50 = lean_ctor_get(x_48, 0); +lean_inc(x_50); lean_dec(x_48); -x_66 = !lean_is_exclusive(x_51); -if (x_66 == 0) -{ -return x_51; -} -else -{ -lean_object* x_67; lean_object* x_68; lean_object* x_69; -x_67 = lean_ctor_get(x_51, 0); -x_68 = lean_ctor_get(x_51, 1); -lean_inc(x_68); -lean_inc(x_67); +x_51 = lean_ctor_get(x_49, 2); +lean_inc(x_51); +lean_dec(x_49); +x_52 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__2; +x_53 = l_PersistentArray_forM___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(x_52, x_51, x_6); lean_dec(x_51); -x_69 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_69, 0, x_67); -lean_ctor_set(x_69, 1, x_68); -return x_69; +if (lean_obj_tag(x_53) == 0) +{ +uint8_t x_54; +x_54 = !lean_is_exclusive(x_53); +if (x_54 == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_55 = lean_ctor_get(x_53, 0); +lean_dec(x_55); +x_56 = l_Lean_Message_toString(x_50); +x_57 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_57, 0, x_56); +x_58 = l_Lean_Options_empty; +x_59 = l_Lean_Format_pretty(x_57, x_58); +x_60 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_60, 0, x_59); +lean_ctor_set_tag(x_53, 1); +lean_ctor_set(x_53, 0, x_60); +return x_53; } +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_61 = lean_ctor_get(x_53, 1); +lean_inc(x_61); +lean_dec(x_53); +x_62 = l_Lean_Message_toString(x_50); +x_63 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_63, 0, x_62); +x_64 = l_Lean_Options_empty; +x_65 = l_Lean_Format_pretty(x_63, x_64); +x_66 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_66, 0, x_65); +x_67 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_67, 0, x_66); +lean_ctor_set(x_67, 1, x_61); +return x_67; } } else { -lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; -x_70 = lean_ctor_get(x_31, 1); +uint8_t x_68; +lean_dec(x_50); +x_68 = !lean_is_exclusive(x_53); +if (x_68 == 0) +{ +return x_53; +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_53, 0); +x_70 = lean_ctor_get(x_53, 1); lean_inc(x_70); -lean_dec(x_31); -x_71 = lean_ctor_get(x_70, 2); -lean_inc(x_71); -lean_dec(x_70); -x_72 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__2; -x_73 = l_PersistentArray_forM___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(x_72, x_71, x_5); -lean_dec(x_71); -if (lean_obj_tag(x_73) == 0) -{ -uint8_t x_74; -x_74 = !lean_is_exclusive(x_73); -if (x_74 == 0) -{ -lean_object* x_75; lean_object* x_76; -x_75 = lean_ctor_get(x_73, 0); -lean_dec(x_75); -x_76 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__4; -lean_ctor_set_tag(x_73, 1); -lean_ctor_set(x_73, 0, x_76); -return x_73; +lean_inc(x_69); +lean_dec(x_53); +x_71 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_71, 0, x_69); +lean_ctor_set(x_71, 1, x_70); +return x_71; +} +} } else { -lean_object* x_77; lean_object* x_78; lean_object* x_79; -x_77 = lean_ctor_get(x_73, 1); -lean_inc(x_77); +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_72 = lean_ctor_get(x_32, 1); +lean_inc(x_72); +lean_dec(x_32); +x_73 = lean_ctor_get(x_72, 2); +lean_inc(x_73); +lean_dec(x_72); +x_74 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__2; +x_75 = l_PersistentArray_forM___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(x_74, x_73, x_6); lean_dec(x_73); +if (lean_obj_tag(x_75) == 0) +{ +uint8_t x_76; +x_76 = !lean_is_exclusive(x_75); +if (x_76 == 0) +{ +lean_object* x_77; lean_object* x_78; +x_77 = lean_ctor_get(x_75, 0); +lean_dec(x_77); x_78 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__4; -x_79 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_79, 0, x_78); -lean_ctor_set(x_79, 1, x_77); -return x_79; +lean_ctor_set_tag(x_75, 1); +lean_ctor_set(x_75, 0, x_78); +return x_75; +} +else +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_79 = lean_ctor_get(x_75, 1); +lean_inc(x_79); +lean_dec(x_75); +x_80 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__4; +x_81 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_79); +return x_81; } } else { -uint8_t x_80; -x_80 = !lean_is_exclusive(x_73); -if (x_80 == 0) +uint8_t x_82; +x_82 = !lean_is_exclusive(x_75); +if (x_82 == 0) { -return x_73; +return x_75; } else { -lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_81 = lean_ctor_get(x_73, 0); -x_82 = lean_ctor_get(x_73, 1); -lean_inc(x_82); -lean_inc(x_81); -lean_dec(x_73); -x_83 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_83, 0, x_81); -lean_ctor_set(x_83, 1, x_82); -return x_83; -} -} -} -} -else -{ -lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; -x_84 = lean_ctor_get(x_31, 1); +lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_83 = lean_ctor_get(x_75, 0); +x_84 = lean_ctor_get(x_75, 1); lean_inc(x_84); -lean_dec(x_31); -x_85 = lean_ctor_get(x_84, 2); -lean_inc(x_85); -lean_dec(x_84); -x_86 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__2; -x_87 = l_PersistentArray_forM___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(x_86, x_85, x_5); -lean_dec(x_85); -if (lean_obj_tag(x_87) == 0) -{ -uint8_t x_88; -x_88 = !lean_is_exclusive(x_87); -if (x_88 == 0) -{ -lean_object* x_89; lean_object* x_90; -x_89 = lean_ctor_get(x_87, 0); -lean_dec(x_89); -x_90 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__6; -lean_ctor_set_tag(x_87, 1); -lean_ctor_set(x_87, 0, x_90); -return x_87; +lean_inc(x_83); +lean_dec(x_75); +x_85 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_85, 0, x_83); +lean_ctor_set(x_85, 1, x_84); +return x_85; +} +} +} } else { -lean_object* x_91; lean_object* x_92; lean_object* x_93; -x_91 = lean_ctor_get(x_87, 1); -lean_inc(x_91); +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_86 = lean_ctor_get(x_32, 1); +lean_inc(x_86); +lean_dec(x_32); +x_87 = lean_ctor_get(x_86, 2); +lean_inc(x_87); +lean_dec(x_86); +x_88 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__2; +x_89 = l_PersistentArray_forM___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__6(x_88, x_87, x_6); lean_dec(x_87); +if (lean_obj_tag(x_89) == 0) +{ +uint8_t x_90; +x_90 = !lean_is_exclusive(x_89); +if (x_90 == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_89, 0); +lean_dec(x_91); x_92 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__6; -x_93 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_93, 0, x_92); -lean_ctor_set(x_93, 1, x_91); -return x_93; +lean_ctor_set_tag(x_89, 1); +lean_ctor_set(x_89, 0, x_92); +return x_89; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_93 = lean_ctor_get(x_89, 1); +lean_inc(x_93); +lean_dec(x_89); +x_94 = l_Lean_Elab_Term_MetaHasEval___rarg___closed__6; +x_95 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_93); +return x_95; } } else { -uint8_t x_94; -x_94 = !lean_is_exclusive(x_87); -if (x_94 == 0) +uint8_t x_96; +x_96 = !lean_is_exclusive(x_89); +if (x_96 == 0) { -return x_87; +return x_89; } else { -lean_object* x_95; lean_object* x_96; lean_object* x_97; -x_95 = lean_ctor_get(x_87, 0); -x_96 = lean_ctor_get(x_87, 1); -lean_inc(x_96); -lean_inc(x_95); -lean_dec(x_87); -x_97 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_97, 0, x_95); -lean_ctor_set(x_97, 1, x_96); -return x_97; +lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_97 = lean_ctor_get(x_89, 0); +x_98 = lean_ctor_get(x_89, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_89); +x_99 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_99, 0, x_97); +lean_ctor_set(x_99, 1, x_98); +return x_99; } } } @@ -28374,10 +28350,20 @@ lean_object* l_Lean_Elab_Term_MetaHasEval(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l_Lean_Elab_Term_MetaHasEval___rarg), 5, 0); +x_2 = lean_alloc_closure((void*)(l_Lean_Elab_Term_MetaHasEval___rarg___boxed), 6, 0); return x_2; } } +lean_object* l_Lean_Elab_Term_MetaHasEval___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_5); +lean_dec(x_5); +x_8 = l_Lean_Elab_Term_MetaHasEval___rarg(x_1, x_2, x_3, x_4, x_7, x_6); +return x_8; +} +} lean_object* _init_l___private_Init_Lean_Elab_Term_21__regTraceClasses___closed__1() { _start: { @@ -28684,10 +28670,6 @@ l_Lean_Elab_Term_mkExplicitBinder___closed__5 = _init_l_Lean_Elab_Term_mkExplici lean_mark_persistent(l_Lean_Elab_Term_mkExplicitBinder___closed__5); l_Lean_Elab_Term_mkExplicitBinder___closed__6 = _init_l_Lean_Elab_Term_mkExplicitBinder___closed__6(); lean_mark_persistent(l_Lean_Elab_Term_mkExplicitBinder___closed__6); -l_Lean_Elab_Term_levelMVarToParam___closed__1 = _init_l_Lean_Elab_Term_levelMVarToParam___closed__1(); -lean_mark_persistent(l_Lean_Elab_Term_levelMVarToParam___closed__1); -l_Lean_Elab_Term_levelMVarToParam___closed__2 = _init_l_Lean_Elab_Term_levelMVarToParam___closed__2(); -lean_mark_persistent(l_Lean_Elab_Term_levelMVarToParam___closed__2); l_Lean_Elab_Term_mkFreshAnonymousName___rarg___closed__1 = _init_l_Lean_Elab_Term_mkFreshAnonymousName___rarg___closed__1(); lean_mark_persistent(l_Lean_Elab_Term_mkFreshAnonymousName___rarg___closed__1); l_Lean_Elab_Term_mkFreshAnonymousName___rarg___closed__2 = _init_l_Lean_Elab_Term_mkFreshAnonymousName___rarg___closed__2(); diff --git a/stage0/stdlib/Init/Lean/Elab/Util.c b/stage0/stdlib/Init/Lean/Elab/Util.c index 6bf3b8095d..905dab9282 100644 --- a/stage0/stdlib/Init/Lean/Elab/Util.c +++ b/stage0/stdlib/Init/Lean/Elab/Util.c @@ -70,7 +70,6 @@ lean_object* l_List_foldl___main___at_Lean_Elab_addMacroStack___spec__1(lean_obj lean_object* l_Lean_SMap_find_x3f___at_Lean_Elab_getMacros___spec__1(lean_object*, lean_object*); lean_object* l_Lean_Elab_syntaxNodeKindOfAttrParam___closed__2; lean_object* l_Lean_Name_append___main(lean_object*, lean_object*); -extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__2; lean_object* l_finally___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_liftMacroM___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_checkSyntaxNodeKindAtNamespaces___boxed(lean_object*, lean_object*, lean_object*); @@ -104,6 +103,7 @@ lean_object* l___private_Init_Lean_Elab_Util_1__evalSyntaxConstantUnsafe(lean_ob extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__3; size_t l_USize_land(size_t, size_t); lean_object* l_Lean_Environment_evalConstCheck___rarg(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5; lean_object* l_Lean_Elab_syntaxNodeKindOfAttrParam___closed__1; lean_object* l_Lean_Elab_syntaxNodeKindOfAttrParam___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_PersistentHashMap_find_x3f___at_Lean_Elab_getMacros___spec__2(lean_object*, lean_object*); @@ -133,7 +133,7 @@ lean_object* l_List_foldl___main___at_Lean_MacroScopesView_review___spec__1(lean lean_object* l_Lean_Elab_checkSyntaxNodeKind(lean_object*, lean_object*); lean_object* l_Lean_Elab_addMacroStack___closed__3; lean_object* l_Lean_Elab_checkSyntaxNodeKindAtNamespaces___main___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_SMap_empty___at_Lean_Elab_macroAttribute___spec__1___closed__1; lean_object* l___private_Init_Lean_Elab_Util_4__regTraceClasses___closed__1; uint8_t l_List_isEmpty___rarg(lean_object*); @@ -164,21 +164,22 @@ x_3 = l_Lean_Syntax_reprint___main(x_2); lean_dec(x_2); if (lean_obj_tag(x_3) == 0) { -lean_object* x_4; lean_object* x_5; lean_object* x_6; +lean_object* x_4; uint8_t x_5; lean_object* x_6; lean_object* x_7; x_4 = lean_box(0); -x_5 = lean_unsigned_to_nat(0u); -x_6 = l_Lean_Syntax_formatStxAux___main(x_4, x_5, x_1); -return x_6; +x_5 = 0; +x_6 = lean_unsigned_to_nat(0u); +x_7 = l_Lean_Syntax_formatStxAux___main(x_4, x_5, x_6, x_1); +return x_7; } else { -lean_object* x_7; lean_object* x_8; +lean_object* x_8; lean_object* x_9; lean_dec(x_1); -x_7 = lean_ctor_get(x_3, 0); -lean_inc(x_7); +x_8 = lean_ctor_get(x_3, 0); +lean_inc(x_8); lean_dec(x_3); -x_8 = l_String_toFormat(x_7); -return x_8; +x_9 = l_String_toFormat(x_8); +return x_9; } } } @@ -1079,7 +1080,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj x_1 = l_Lean_Elab_macroAttribute___closed__3; x_2 = lean_box(0); x_3 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__1; -x_4 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__2; +x_4 = l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5; x_5 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__3; x_6 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__4; x_7 = lean_alloc_ctor(0, 6, 0); diff --git a/stage0/stdlib/Init/Lean/Environment.c b/stage0/stdlib/Init/Lean/Environment.c index ed5cad6369..6ee5c953b2 100644 --- a/stage0/stdlib/Init/Lean/Environment.c +++ b/stage0/stdlib/Init/Lean/Environment.c @@ -1,6 +1,6 @@ // Lean compiler output // Module: Init.Lean.Environment -// Imports: Init.System.IO Init.Util Init.Data.ByteArray Init.Lean.Data.SMap Init.Lean.Util.Path Init.Lean.Declaration Init.Lean.LocalContext +// Imports: Init.System.IO Init.Util Init.Data.ByteArray Init.Lean.Data.SMap Init.Lean.Declaration Init.Lean.LocalContext Init.Lean.Util.Path Init.Lean.Util.FindExpr #include "runtime/lean.h" #if defined(__clang__) #pragma clang diagnostic ignored "-Wunused-parameter" @@ -16,6 +16,7 @@ extern "C" { lean_object* l_HashMapImp_find_x3f___at_Lean_Environment_getModuleIdxFor_x3f___spec__1(lean_object*, lean_object*); lean_object* l_List_reverse___rarg(lean_object*); extern lean_object* l_Lean_Name_toString___closed__1; +lean_object* l_Lean_Environment_hasUnsafe___boxed(lean_object*, lean_object*); lean_object* lean_get_extension(lean_object*, lean_object*); lean_object* lean_array_set(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_isNamespace___boxed(lean_object*, lean_object*); @@ -39,6 +40,7 @@ lean_object* l_Lean_namespacesExt___elambda__3(lean_object*, lean_object*); lean_object* l_Lean_EnvExtension_setState(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Environment_displayStats___closed__1; lean_object* l_Nat_foldAux___main___at_Lean_mkModuleData___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_USize_decEq(size_t, size_t); lean_object* lean_array_uget(lean_object*, size_t); lean_object* l_Array_iterateMAux___main___at_Lean_importModules___spec__10(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Environment_14__throwUnexpectedType(lean_object*); @@ -81,6 +83,7 @@ size_t l_USize_sub(size_t, size_t); extern lean_object* l_Array_empty___closed__1; lean_object* lean_environment_find(lean_object*, lean_object*); lean_object* lean_io_mk_ref(lean_object*, lean_object*); +lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(lean_object*, size_t, lean_object*, lean_object*); lean_object* lean_read_module_data(lean_object*, lean_object*); lean_object* l_Lean_TagDeclarationExtension_Inhabited___closed__1; lean_object* lean_environment_mark_quot_init(lean_object*); @@ -88,6 +91,7 @@ lean_object* lean_io_ref_get(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_importModules___spec__13(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Environment_7__mkPersistentEnvExtensionsRef(lean_object*); lean_object* l___private_Init_Lean_Environment_6__mkInitialExtensionStates(lean_object*); +uint8_t l_Lean_ConstantInfo_isUnsafe(lean_object*); lean_object* l_Lean_mkTagDeclarationExtension___closed__2; lean_object* l_Lean_PersistentEnvExtension_setState___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_EnvExtension_Inhabited___rarg___lambda__1(lean_object*); @@ -143,6 +147,7 @@ lean_object* l_Lean_mkStateFromImportedEntries___rarg___lambda__1___boxed(lean_o lean_object* l_Lean_PersistentEnvExtension_setState(lean_object*, lean_object*, lean_object*); lean_object* l_PersistentHashMap_find_x3f___at_Lean_Environment_find_x3f___spec__4(lean_object*, lean_object*); lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__1; +uint8_t l_Lean_Environment_hasUnsafe(lean_object*, lean_object*); lean_object* l_AssocList_find_x3f___main___at_Lean_Environment_find_x3f___spec__3___boxed(lean_object*, lean_object*); uint8_t l_Lean_Environment_isConstructor(lean_object*, lean_object*); lean_object* l_Lean_Environment_displayStats___closed__7; @@ -180,6 +185,7 @@ lean_object* l_Lean_CPPExtensionState_inhabited; lean_object* l_Lean_EnvExtension_setStateUnsafe___rarg(lean_object*, lean_object*, lean_object*); lean_object* lean_nat_sub(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Environment_11__finalizePersistentExtensions___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_IO_println___at_Lean_HasRepr_hasEval___spec__1(lean_object*, lean_object*); lean_object* lean_array_swap(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_EnvExtension_setStateUnsafe(lean_object*); lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_mkTagDeclarationExtension___spec__4(lean_object*, lean_object*); @@ -194,7 +200,6 @@ lean_object* l_Lean_ModuleData_inhabited___closed__1; lean_object* lean_set_extension(lean_object*, lean_object*, lean_object*); lean_object* l_Nat_foldAux___main___at_Lean_mkModuleData___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); -lean_object* l_IO_println___at_Lean_HasRepr_HasEval___spec__1(lean_object*, lean_object*); lean_object* l_Lean_SimplePersistentEnvExtension_modifyState___rarg___lambda__1(lean_object*, lean_object*); lean_object* l_Lean_SMap_size___at_Lean_Environment_displayStats___spec__3___boxed(lean_object*); lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); @@ -321,18 +326,22 @@ lean_object* l_Lean_mkEmptyEnvironment___boxed(lean_object*, lean_object*); lean_object* lean_kernel_whnf(lean_object*, lean_object*, lean_object*); uint8_t l_PersistentHashMap_contains___at_Lean_Environment_contains___spec__3(lean_object*, lean_object*); lean_object* l_Array_forMAux___main___at_Lean_Environment_displayStats___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +size_t l_USize_mod(size_t, size_t); lean_object* l_Lean_namespacesExt___elambda__2___boxed(lean_object*); +lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__3; lean_object* l_Array_anyRangeMAux___main___at_Lean_registerSimplePersistentEnvExtension___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_namespacesExt___elambda__2(lean_object*); lean_object* l_PersistentHashMap_insert___at_Lean_Environment_addAux___spec__2(lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Environment_10__setImportedEntries___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_regNamespacesExtension(lean_object*); +extern lean_object* l_Lean_Expr_FindImpl_initCache; lean_object* lean_io_file_exists(lean_object*, lean_object*); lean_object* lean_mk_empty_environment(uint32_t, lean_object*); lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Environment_Inhabited; lean_object* lean_import_modules(lean_object*, uint32_t, lean_object*); +size_t lean_ptr_addr(lean_object*); lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__1; lean_object* l_Array_anyRangeMAux___main___at_Lean_registerPersistentEnvExtensionUnsafe___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Environment_9__getEntriesFor(lean_object*, lean_object*, lean_object*); @@ -11671,7 +11680,7 @@ x_14 = lean_string_append(x_13, x_12); lean_dec(x_12); x_15 = l_Char_HasRepr___closed__1; x_16 = lean_string_append(x_14, x_15); -x_17 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_16, x_4); +x_17 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_16, x_4); lean_dec(x_16); if (lean_obj_tag(x_17) == 0) { @@ -11701,7 +11710,7 @@ x_28 = l_Lean_Format_pretty(x_26, x_27); x_29 = l_Array_forMAux___main___at_Lean_Environment_displayStats___spec__9___closed__2; x_30 = lean_string_append(x_29, x_28); lean_dec(x_28); -x_31 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_30, x_18); +x_31 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_30, x_18); lean_dec(x_30); if (lean_obj_tag(x_31) == 0) { @@ -11720,7 +11729,7 @@ x_36 = l_Nat_repr(x_35); x_37 = l_Array_forMAux___main___at_Lean_Environment_displayStats___spec__9___closed__3; x_38 = lean_string_append(x_37, x_36); lean_dec(x_36); -x_39 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_38, x_32); +x_39 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_38, x_32); lean_dec(x_38); if (lean_obj_tag(x_39) == 0) { @@ -11800,7 +11809,7 @@ x_55 = l_Nat_repr(x_54); x_56 = l_Array_forMAux___main___at_Lean_Environment_displayStats___spec__9___closed__3; x_57 = lean_string_append(x_56, x_55); lean_dec(x_55); -x_58 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_57, x_18); +x_58 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_57, x_18); lean_dec(x_57); if (lean_obj_tag(x_58) == 0) { @@ -11971,7 +11980,7 @@ lean_dec(x_17); x_20 = l_Lean_Environment_displayStats___closed__1; x_21 = lean_string_append(x_20, x_19); lean_dec(x_19); -x_22 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_21, x_6); +x_22 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_21, x_6); lean_dec(x_21); if (lean_obj_tag(x_22) == 0) { @@ -11983,7 +11992,7 @@ x_24 = l_Nat_repr(x_13); x_25 = l_Lean_Environment_displayStats___closed__2; x_26 = lean_string_append(x_25, x_24); lean_dec(x_24); -x_27 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_26, x_23); +x_27 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_26, x_23); lean_dec(x_26); if (lean_obj_tag(x_27) == 0) { @@ -11998,7 +12007,7 @@ x_31 = l_Nat_repr(x_30); x_32 = l_Lean_Environment_displayStats___closed__3; x_33 = lean_string_append(x_32, x_31); lean_dec(x_31); -x_34 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_33, x_28); +x_34 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_33, x_28); lean_dec(x_33); if (lean_obj_tag(x_34) == 0) { @@ -12013,7 +12022,7 @@ x_38 = l_Nat_repr(x_37); x_39 = l_Lean_Environment_displayStats___closed__4; x_40 = lean_string_append(x_39, x_38); lean_dec(x_38); -x_41 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_40, x_35); +x_41 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_40, x_35); lean_dec(x_40); if (lean_obj_tag(x_41) == 0) { @@ -12028,7 +12037,7 @@ x_44 = l_Nat_repr(x_43); x_45 = l_Lean_Environment_displayStats___closed__5; x_46 = lean_string_append(x_45, x_44); lean_dec(x_44); -x_47 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_46, x_42); +x_47 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_46, x_42); lean_dec(x_46); if (lean_obj_tag(x_47) == 0) { @@ -12042,7 +12051,7 @@ x_50 = l_Nat_repr(x_49); x_51 = l_Lean_Environment_displayStats___closed__6; x_52 = lean_string_append(x_51, x_50); lean_dec(x_50); -x_53 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_52, x_48); +x_53 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_52, x_48); lean_dec(x_52); if (lean_obj_tag(x_53) == 0) { @@ -12057,7 +12066,7 @@ x_57 = l_Nat_repr(x_56); x_58 = l_Lean_Environment_displayStats___closed__7; x_59 = lean_string_append(x_58, x_57); lean_dec(x_57); -x_60 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_59, x_54); +x_60 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_59, x_54); lean_dec(x_59); if (lean_obj_tag(x_60) == 0) { @@ -12073,7 +12082,7 @@ x_64 = l_Nat_repr(x_63); x_65 = l_Lean_Environment_displayStats___closed__8; x_66 = lean_string_append(x_65, x_64); lean_dec(x_64); -x_67 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_66, x_61); +x_67 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_66, x_61); lean_dec(x_66); if (lean_obj_tag(x_67) == 0) { @@ -12593,6 +12602,595 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Environment_evalConstCheck___rarg), 3, 0 return x_2; } } +lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; size_t x_110; size_t x_111; lean_object* x_112; size_t x_113; uint8_t x_114; +x_110 = lean_ptr_addr(x_3); +x_111 = x_2 == 0 ? 0 : x_110 % x_2; +x_112 = lean_array_uget(x_4, x_111); +x_113 = lean_ptr_addr(x_112); +lean_dec(x_112); +x_114 = x_113 == x_110; +if (x_114 == 0) +{ +lean_object* x_115; uint8_t x_116; +lean_inc(x_3); +x_115 = lean_array_uset(x_4, x_111, x_3); +x_116 = 0; +x_5 = x_116; +x_6 = x_115; +goto block_109; +} +else +{ +uint8_t x_117; +x_117 = 1; +x_5 = x_117; +x_6 = x_4; +goto block_109; +} +block_109: +{ +lean_object* x_7; +if (x_5 == 0) +{ +if (lean_obj_tag(x_3) == 4) +{ +lean_object* x_93; lean_object* x_94; +x_93 = lean_ctor_get(x_3, 0); +lean_inc(x_93); +lean_inc(x_1); +x_94 = lean_environment_find(x_1, x_93); +if (lean_obj_tag(x_94) == 0) +{ +lean_object* x_95; +x_95 = lean_box(0); +x_7 = x_95; +goto block_92; +} +else +{ +uint8_t x_96; +x_96 = !lean_is_exclusive(x_94); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_94, 0); +x_98 = l_Lean_ConstantInfo_isUnsafe(x_97); +lean_dec(x_97); +if (x_98 == 0) +{ +lean_object* x_99; +lean_free_object(x_94); +x_99 = lean_box(0); +x_7 = x_99; +goto block_92; +} +else +{ +lean_object* x_100; +lean_dec(x_1); +lean_ctor_set(x_94, 0, x_3); +x_100 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_100, 0, x_94); +lean_ctor_set(x_100, 1, x_6); +return x_100; +} +} +else +{ +lean_object* x_101; uint8_t x_102; +x_101 = lean_ctor_get(x_94, 0); +lean_inc(x_101); +lean_dec(x_94); +x_102 = l_Lean_ConstantInfo_isUnsafe(x_101); +lean_dec(x_101); +if (x_102 == 0) +{ +lean_object* x_103; +x_103 = lean_box(0); +x_7 = x_103; +goto block_92; +} +else +{ +lean_object* x_104; lean_object* x_105; +lean_dec(x_1); +x_104 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_104, 0, x_3); +x_105 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_105, 0, x_104); +lean_ctor_set(x_105, 1, x_6); +return x_105; +} +} +} +} +else +{ +lean_object* x_106; +x_106 = lean_box(0); +x_7 = x_106; +goto block_92; +} +} +else +{ +lean_object* x_107; lean_object* x_108; +lean_dec(x_3); +lean_dec(x_1); +x_107 = lean_box(0); +x_108 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_108, 0, x_107); +lean_ctor_set(x_108, 1, x_6); +return x_108; +} +block_92: +{ +lean_dec(x_7); +switch (lean_obj_tag(x_3)) { +case 5: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_3, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_3, 1); +lean_inc(x_9); +lean_dec(x_3); +lean_inc(x_1); +x_10 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_8, x_6); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_3 = x_9; +x_4 = x_12; +goto _start; +} +else +{ +uint8_t x_14; +lean_dec(x_9); +lean_dec(x_1); +x_14 = !lean_is_exclusive(x_10); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_10, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_11); +if (x_16 == 0) +{ +return x_10; +} +else +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_ctor_get(x_11, 0); +lean_inc(x_17); +lean_dec(x_11); +x_18 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_10, 0, x_18); +return x_10; +} +} +else +{ +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_10, 1); +lean_inc(x_19); +lean_dec(x_10); +x_20 = lean_ctor_get(x_11, 0); +lean_inc(x_20); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + x_21 = x_11; +} else { + lean_dec_ref(x_11); + x_21 = lean_box(0); +} +if (lean_is_scalar(x_21)) { + x_22 = lean_alloc_ctor(1, 1, 0); +} else { + x_22 = x_21; +} +lean_ctor_set(x_22, 0, x_20); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_19); +return x_23; +} +} +} +case 6: +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_24 = lean_ctor_get(x_3, 1); +lean_inc(x_24); +x_25 = lean_ctor_get(x_3, 2); +lean_inc(x_25); +lean_dec(x_3); +lean_inc(x_1); +x_26 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_24, x_6); +x_27 = lean_ctor_get(x_26, 0); +lean_inc(x_27); +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_28; +x_28 = lean_ctor_get(x_26, 1); +lean_inc(x_28); +lean_dec(x_26); +x_3 = x_25; +x_4 = x_28; +goto _start; +} +else +{ +uint8_t x_30; +lean_dec(x_25); +lean_dec(x_1); +x_30 = !lean_is_exclusive(x_26); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_26, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_27); +if (x_32 == 0) +{ +return x_26; +} +else +{ +lean_object* x_33; lean_object* x_34; +x_33 = lean_ctor_get(x_27, 0); +lean_inc(x_33); +lean_dec(x_27); +x_34 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_26, 0, x_34); +return x_26; +} +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_35 = lean_ctor_get(x_26, 1); +lean_inc(x_35); +lean_dec(x_26); +x_36 = lean_ctor_get(x_27, 0); +lean_inc(x_36); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + x_37 = x_27; +} else { + lean_dec_ref(x_27); + x_37 = lean_box(0); +} +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(1, 1, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_36); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_35); +return x_39; +} +} +} +case 7: +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_40 = lean_ctor_get(x_3, 1); +lean_inc(x_40); +x_41 = lean_ctor_get(x_3, 2); +lean_inc(x_41); +lean_dec(x_3); +lean_inc(x_1); +x_42 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_40, x_6); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +if (lean_obj_tag(x_43) == 0) +{ +lean_object* x_44; +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +lean_dec(x_42); +x_3 = x_41; +x_4 = x_44; +goto _start; +} +else +{ +uint8_t x_46; +lean_dec(x_41); +lean_dec(x_1); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +lean_object* x_47; uint8_t x_48; +x_47 = lean_ctor_get(x_42, 0); +lean_dec(x_47); +x_48 = !lean_is_exclusive(x_43); +if (x_48 == 0) +{ +return x_42; +} +else +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_43, 0); +lean_inc(x_49); +lean_dec(x_43); +x_50 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set(x_42, 0, x_50); +return x_42; +} +} +else +{ +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_42, 1); +lean_inc(x_51); +lean_dec(x_42); +x_52 = lean_ctor_get(x_43, 0); +lean_inc(x_52); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + x_53 = x_43; +} else { + lean_dec_ref(x_43); + x_53 = lean_box(0); +} +if (lean_is_scalar(x_53)) { + x_54 = lean_alloc_ctor(1, 1, 0); +} else { + x_54 = x_53; +} +lean_ctor_set(x_54, 0, x_52); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_51); +return x_55; +} +} +} +case 8: +{ +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_3, 1); +lean_inc(x_56); +x_57 = lean_ctor_get(x_3, 2); +lean_inc(x_57); +x_58 = lean_ctor_get(x_3, 3); +lean_inc(x_58); +lean_dec(x_3); +lean_inc(x_1); +x_59 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_56, x_6); +x_60 = lean_ctor_get(x_59, 0); +lean_inc(x_60); +if (lean_obj_tag(x_60) == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_61 = lean_ctor_get(x_59, 1); +lean_inc(x_61); +lean_dec(x_59); +lean_inc(x_1); +x_62 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_57, x_61); +x_63 = lean_ctor_get(x_62, 0); +lean_inc(x_63); +if (lean_obj_tag(x_63) == 0) +{ +lean_object* x_64; +x_64 = lean_ctor_get(x_62, 1); +lean_inc(x_64); +lean_dec(x_62); +x_3 = x_58; +x_4 = x_64; +goto _start; +} +else +{ +uint8_t x_66; +lean_dec(x_58); +lean_dec(x_1); +x_66 = !lean_is_exclusive(x_62); +if (x_66 == 0) +{ +lean_object* x_67; uint8_t x_68; +x_67 = lean_ctor_get(x_62, 0); +lean_dec(x_67); +x_68 = !lean_is_exclusive(x_63); +if (x_68 == 0) +{ +return x_62; +} +else +{ +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(1, 1, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_62, 0, x_70); +return x_62; +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_71 = lean_ctor_get(x_62, 1); +lean_inc(x_71); +lean_dec(x_62); +x_72 = lean_ctor_get(x_63, 0); +lean_inc(x_72); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + x_73 = x_63; +} else { + lean_dec_ref(x_63); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 1, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_72); +x_75 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_71); +return x_75; +} +} +} +else +{ +uint8_t x_76; +lean_dec(x_58); +lean_dec(x_57); +lean_dec(x_1); +x_76 = !lean_is_exclusive(x_59); +if (x_76 == 0) +{ +lean_object* x_77; uint8_t x_78; +x_77 = lean_ctor_get(x_59, 0); +lean_dec(x_77); +x_78 = !lean_is_exclusive(x_60); +if (x_78 == 0) +{ +return x_59; +} +else +{ +lean_object* x_79; lean_object* x_80; +x_79 = lean_ctor_get(x_60, 0); +lean_inc(x_79); +lean_dec(x_60); +x_80 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_59, 0, x_80); +return x_59; +} +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_81 = lean_ctor_get(x_59, 1); +lean_inc(x_81); +lean_dec(x_59); +x_82 = lean_ctor_get(x_60, 0); +lean_inc(x_82); +if (lean_is_exclusive(x_60)) { + lean_ctor_release(x_60, 0); + x_83 = x_60; +} else { + lean_dec_ref(x_60); + x_83 = lean_box(0); +} +if (lean_is_scalar(x_83)) { + x_84 = lean_alloc_ctor(1, 1, 0); +} else { + x_84 = x_83; +} +lean_ctor_set(x_84, 0, x_82); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_81); +return x_85; +} +} +} +case 10: +{ +lean_object* x_86; +x_86 = lean_ctor_get(x_3, 1); +lean_inc(x_86); +lean_dec(x_3); +x_3 = x_86; +x_4 = x_6; +goto _start; +} +case 11: +{ +lean_object* x_88; +x_88 = lean_ctor_get(x_3, 2); +lean_inc(x_88); +lean_dec(x_3); +x_3 = x_88; +x_4 = x_6; +goto _start; +} +default: +{ +lean_object* x_90; lean_object* x_91; +lean_dec(x_3); +lean_dec(x_1); +x_90 = lean_box(0); +x_91 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_6); +return x_91; +} +} +} +} +} +} +uint8_t l_Lean_Environment_hasUnsafe(lean_object* x_1, lean_object* x_2) { +_start: +{ +size_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_3 = 8192; +x_4 = l_Lean_Expr_FindImpl_initCache; +x_5 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_3, x_2, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +lean_dec(x_5); +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_7; +x_7 = 0; +return x_7; +} +else +{ +uint8_t x_8; +lean_dec(x_6); +x_8 = 1; +return x_8; +} +} +} +lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; lean_object* x_6; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_5, x_3, x_4); +return x_6; +} +} +lean_object* l_Lean_Environment_hasUnsafe___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_Lean_Environment_hasUnsafe(x_1, x_2); +x_4 = lean_box(x_3); +return x_4; +} +} lean_object* l_Lean_matchConst___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { @@ -12666,9 +13264,10 @@ lean_object* initialize_Init_System_IO(lean_object*); lean_object* initialize_Init_Util(lean_object*); lean_object* initialize_Init_Data_ByteArray(lean_object*); lean_object* initialize_Init_Lean_Data_SMap(lean_object*); -lean_object* initialize_Init_Lean_Util_Path(lean_object*); lean_object* initialize_Init_Lean_Declaration(lean_object*); lean_object* initialize_Init_Lean_LocalContext(lean_object*); +lean_object* initialize_Init_Lean_Util_Path(lean_object*); +lean_object* initialize_Init_Lean_Util_FindExpr(lean_object*); static bool _G_initialized = false; lean_object* initialize_Init_Lean_Environment(lean_object* w) { lean_object * res; @@ -12686,15 +13285,18 @@ lean_dec_ref(res); res = initialize_Init_Lean_Data_SMap(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); -res = initialize_Init_Lean_Util_Path(lean_io_mk_world()); -if (lean_io_result_is_error(res)) return res; -lean_dec_ref(res); res = initialize_Init_Lean_Declaration(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); res = initialize_Init_Lean_LocalContext(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); +res = initialize_Init_Lean_Util_Path(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Init_Lean_Util_FindExpr(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); l_Lean_EnvExtensionState_inhabited = _init_l_Lean_EnvExtensionState_inhabited(); lean_mark_persistent(l_Lean_EnvExtensionState_inhabited); l_Lean_ModuleIdx_inhabited = _init_l_Lean_ModuleIdx_inhabited(); diff --git a/stage0/stdlib/Init/Lean/Eval.c b/stage0/stdlib/Init/Lean/Eval.c index 651b907a2c..d3b2be2133 100644 --- a/stage0/stdlib/Init/Lean/Eval.c +++ b/stage0/stdlib/Init/Lean/Eval.c @@ -13,41 +13,46 @@ #ifdef __cplusplus extern "C" { #endif +lean_object* l_Lean_MetaIO_metaHasEval___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); lean_object* l_Lean_MetaIO_getOptions(lean_object*, lean_object*); +lean_object* l_Lean_metaHasEvalOfHasEval(lean_object*); lean_object* l_Lean_MetaIO_monadIO(lean_object*); lean_object* l_Lean_MetaIO_monadIO___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_metaHasEvalOfHasEval___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MetaIO_monadIO___rarg___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_MetaHasEvalOfHasEval(lean_object*); +lean_object* l_Lean_MetaIO_metaHasEval___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MetaIO_getEnv___boxed(lean_object*, lean_object*); -lean_object* l_Lean_MetaHasEvalOfHasEval___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_MetaHasEvalOfHasEval___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_MetaIO_metaHasEval(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_metaHasEvalOfHasEval___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +lean_object* l_Lean_MetaIO_metaHasEval(lean_object*); lean_object* l_Lean_MetaIO_getOptions___boxed(lean_object*, lean_object*); lean_object* l_Lean_MetaIO_getEnv(lean_object*, lean_object*); -lean_object* l_Lean_MetaHasEvalOfHasEval___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l_Lean_metaHasEvalOfHasEval___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6) { _start: { -lean_object* x_6; -x_6 = lean_apply_2(x_1, x_4, x_5); -return x_6; +lean_object* x_7; lean_object* x_8; +x_7 = lean_box(x_5); +x_8 = lean_apply_3(x_1, x_4, x_7, x_6); +return x_8; } } -lean_object* l_Lean_MetaHasEvalOfHasEval(lean_object* x_1) { +lean_object* l_Lean_metaHasEvalOfHasEval(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l_Lean_MetaHasEvalOfHasEval___rarg___boxed), 5, 0); +x_2 = lean_alloc_closure((void*)(l_Lean_metaHasEvalOfHasEval___rarg___boxed), 6, 0); return x_2; } } -lean_object* l_Lean_MetaHasEvalOfHasEval___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l_Lean_metaHasEvalOfHasEval___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { _start: { -lean_object* x_6; -x_6 = l_Lean_MetaHasEvalOfHasEval___rarg(x_1, x_2, x_3, x_4, x_5); +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_5); +lean_dec(x_5); +x_8 = l_Lean_metaHasEvalOfHasEval___rarg(x_1, x_2, x_3, x_4, x_7, x_6); lean_dec(x_3); lean_dec(x_2); -return x_6; +return x_8; } } lean_object* l_Lean_MetaIO_getEnv(lean_object* x_1, lean_object* x_2) { @@ -92,15 +97,72 @@ lean_dec(x_1); return x_3; } } -lean_object* l_Lean_MetaIO_metaHasEval(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_Lean_MetaIO_metaHasEval___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6) { _start: { -lean_object* x_5; lean_object* x_6; -x_5 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_5, 0, x_1); -lean_ctor_set(x_5, 1, x_2); -x_6 = lean_apply_2(x_3, x_5, x_4); -return x_6; +lean_object* x_7; lean_object* x_8; +lean_inc(x_3); +lean_inc(x_2); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_2); +lean_ctor_set(x_7, 1, x_3); +x_8 = lean_apply_2(x_4, x_7, x_6); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_8, 1); +lean_inc(x_10); +lean_dec(x_8); +x_11 = 1; +x_12 = lean_box(x_11); +x_13 = lean_apply_5(x_1, x_2, x_3, x_9, x_12, x_10); +return x_13; +} +else +{ +uint8_t x_14; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_14 = !lean_is_exclusive(x_8); +if (x_14 == 0) +{ +return x_8; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_8, 0); +x_16 = lean_ctor_get(x_8, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_8); +x_17 = lean_alloc_ctor(1, 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_MetaIO_metaHasEval(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_MetaIO_metaHasEval___rarg___boxed), 6, 0); +return x_2; +} +} +lean_object* l_Lean_MetaIO_metaHasEval___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_5); +lean_dec(x_5); +x_8 = l_Lean_MetaIO_metaHasEval___rarg(x_1, x_2, x_3, x_4, x_7, x_6); +return x_8; } } lean_object* l_Lean_MetaIO_monadIO___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { diff --git a/stage0/stdlib/Init/Lean/Expr.c b/stage0/stdlib/Init/Lean/Expr.c index 38fdd49583..66f2ea172f 100644 --- a/stage0/stdlib/Init/Lean/Expr.c +++ b/stage0/stdlib/Init/Lean/Expr.c @@ -6264,14 +6264,14 @@ switch (lean_obj_tag(x_1)) { case 6: { lean_object* x_2; -x_2 = lean_ctor_get(x_1, 2); +x_2 = lean_ctor_get(x_1, 1); lean_inc(x_2); return x_2; } case 7: { lean_object* x_3; -x_3 = lean_ctor_get(x_1, 2); +x_3 = lean_ctor_get(x_1, 1); lean_inc(x_3); return x_3; } diff --git a/stage0/stdlib/Init/Lean/KeyedDeclsAttribute.c b/stage0/stdlib/Init/Lean/KeyedDeclsAttribute.c index 9f2eec2110..d56a692592 100644 --- a/stage0/stdlib/Init/Lean/KeyedDeclsAttribute.c +++ b/stage0/stdlib/Init/Lean/KeyedDeclsAttribute.c @@ -79,6 +79,7 @@ lean_object* l_Lean_KeyedDeclsAttribute_init(lean_object*); lean_object* l_Lean_SMap_empty___at_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___spec__1___closed__2; lean_object* l_Lean_SMap_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__9___rarg(lean_object*, lean_object*, lean_object*); size_t l_USize_shiftRight(size_t, size_t); +lean_object* l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__7; extern lean_object* l___private_Init_Lean_Environment_14__throwUnexpectedType___rarg___closed__3; lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_LocalContext_Inhabited___closed__1; @@ -118,7 +119,6 @@ lean_object* l_PersistentHashMap_insertAux___main___at_Lean_KeyedDeclsAttribute_ lean_object* l_Lean_KeyedDeclsAttribute_declareBuiltin___rarg___closed__6; lean_object* l_Lean_KeyedDeclsAttribute_ExtensionState_inhabited___closed__1; lean_object* l_Lean_Name_append___main(lean_object*, lean_object*); -extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__2; lean_object* l_Lean_KernelException_toMessageData(lean_object*, lean_object*); lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___closed__3; lean_object* l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited(lean_object*); @@ -182,6 +182,7 @@ extern lean_object* l_Lean_registerTagAttribute___lambda__4___closed__2; lean_object* l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5; lean_object* l_Lean_ParametricAttribute_setParam___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_PersistentHashMap_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__21___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_fix1___rarg___lambda__1___boxed(lean_object*, lean_object*); lean_object* l_HashMapImp_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__14(lean_object*); lean_object* l_Lean_SMap_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__9(lean_object*); lean_object* l_Lean_KeyedDeclsAttribute_declareBuiltin___rarg___closed__7; @@ -2874,11 +2875,19 @@ return x_4; lean_object* _init_l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5() { _start: { +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_fix1___rarg___lambda__1___boxed), 2, 0); +return x_1; +} +} +lean_object* _init_l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__6() { +_start: +{ 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; x_1 = l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__4; x_2 = lean_box(0); x_3 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__1; -x_4 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__2; +x_4 = l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5; x_5 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__3; x_6 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__4; x_7 = lean_alloc_ctor(0, 6, 0); @@ -2891,12 +2900,12 @@ lean_ctor_set(x_7, 5, x_6); return x_7; } } -lean_object* _init_l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__6() { +lean_object* _init_l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5; +x_2 = l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___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); @@ -2907,7 +2916,7 @@ lean_object* l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited(lean_objec _start: { lean_object* x_2; -x_2 = l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__6; +x_2 = l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__7; return x_2; } } @@ -5284,6 +5293,8 @@ l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5 = _init_l_L lean_mark_persistent(l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__5); l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__6 = _init_l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__6(); lean_mark_persistent(l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__6); +l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__7 = _init_l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__7(); +lean_mark_persistent(l_Lean_KeyedDeclsAttribute_KeyedDeclsAttribute_inhabited___closed__7); l_Lean_KeyedDeclsAttribute_declareBuiltin___rarg___closed__1 = _init_l_Lean_KeyedDeclsAttribute_declareBuiltin___rarg___closed__1(); lean_mark_persistent(l_Lean_KeyedDeclsAttribute_declareBuiltin___rarg___closed__1); l_Lean_KeyedDeclsAttribute_declareBuiltin___rarg___closed__2 = _init_l_Lean_KeyedDeclsAttribute_declareBuiltin___rarg___closed__2(); diff --git a/stage0/stdlib/Init/Lean/LocalContext.c b/stage0/stdlib/Init/Lean/LocalContext.c index c16f732e6a..11e86d0986 100644 --- a/stage0/stdlib/Init/Lean/LocalContext.c +++ b/stage0/stdlib/Init/Lean/LocalContext.c @@ -22,6 +22,7 @@ uint8_t lean_local_ctx_uses_user_name(lean_object*, lean_object*); lean_object* l_Lean_LocalContext_mkLambda___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_PersistentArray_anyMAux___main___at_Lean_LocalContext_anyM___spec__2___rarg(lean_object*, lean_object*, lean_object*); size_t l_USize_add(size_t, size_t); +lean_object* l_PersistentArray_foldlM___at_Lean_LocalContext_getFVarIds___spec__1(lean_object*, lean_object*); lean_object* l_Lean_Name_eraseMacroScopes(lean_object*); lean_object* l_Lean_LocalDecl_userName___boxed(lean_object*); lean_object* l_Array_findSomeRevMAux___main___at_Lean_LocalContext_findDeclRev_x3f___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*); @@ -35,6 +36,7 @@ lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_mkLocalDecl___spe lean_object* l_Lean_LocalDecl_userName(lean_object*); lean_object* l_Lean_LocalContext_findDeclRev_x3f___rarg___boxed(lean_object*, lean_object*); uint8_t l_Array_anyRangeMAux___main___at_Lean_LocalContext_any___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_PersistentArray_foldlMAux___main___at_Lean_LocalContext_getFVarIds___spec__2(lean_object*, lean_object*); lean_object* l_PersistentHashMap_findAux___main___at_Lean_LocalContext_find_x3f___spec__2(lean_object*, size_t, lean_object*); lean_object* l_PersistentArray_findSomeRevMAux___main___at_Lean_LocalContext_findDeclRev_x3f___spec__4___rarg___boxed(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_foldlFrom___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -60,6 +62,7 @@ lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_anyM___spec__4__ lean_object* l_Lean_LocalContext_Inhabited; lean_object* lean_local_ctx_erase(lean_object*, lean_object*); size_t l_USize_sub(size_t, size_t); +extern lean_object* l_Array_empty___closed__1; lean_object* l___private_Init_Util_1__mkPanicMessage(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_LocalContext_findDeclM_x3f(lean_object*); lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_allM___spec__4___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -68,6 +71,7 @@ lean_object* l_PersistentArray_foldlFromM___rarg(lean_object*, lean_object*, lea lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_foldlFrom___spec__8(lean_object*); lean_object* l_Array_findSomeMAux___main___at_Lean_LocalContext_findDecl_x3f___spec__4___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_anyM___spec__3___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(lean_object*, lean_object*); uint8_t l_Array_anyRangeMAux___main___at_Lean_LocalContext_any___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_LocalContext_get_x21(lean_object*, lean_object*); lean_object* l_Lean_LocalDecl_binderInfo___boxed(lean_object*); @@ -119,11 +123,13 @@ lean_object* l_Lean_LocalDecl_updateUserName(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_foldlFrom___spec__8___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_PersistentHashMap_containsAtAux___main___at_Lean_LocalContext_contains___spec__3(lean_object*, lean_object*, lean_object*); lean_object* l_PersistentArray_findSomeMAux___main___at_Lean_LocalContext_findDecl_x3f___spec__3___rarg(lean_object*, lean_object*); +lean_object* l_Lean_LocalContext_getFVars(lean_object*); lean_object* l_Array_findSomeMAux___main___at_Lean_LocalContext_findDecl_x3f___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_LocalContext_Inhabited___closed__2; lean_object* l_PersistentArray_foldlFromMAux___main___at_Lean_LocalContext_foldlFrom___spec__3(lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_foldlFrom___spec__9___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_PersistentArray_getAux___main___rarg___closed__1; +lean_object* lean_expr_lower_loose_bvars(lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_foldl___spec__5(lean_object*); lean_object* l_PersistentArray_anyMAux___main___at_Lean_LocalContext_allM___spec__2(lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_foldlFrom___spec__6(lean_object*); @@ -183,6 +189,7 @@ lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_allM___spec__4__ size_t l_Lean_Name_hash(lean_object*); lean_object* l_Lean_LocalContext_findDeclM_x3f___at_Lean_LocalContext_findDecl_x3f___spec__1(lean_object*); lean_object* l_Lean_LocalContext_foldlFrom___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Lean_LocalDecl_binderInfo(lean_object*); lean_object* l_Lean_LocalDecl_value___boxed(lean_object*); lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_allM___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -221,6 +228,7 @@ lean_object* l_Nat_foldRevAux___main___at_Lean_LocalContext_mkForall___spec__1__ lean_object* l_Array_findSomeRevMAux___main___at_Lean_LocalContext_findDeclRev_x3f___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_PersistentHashMap_contains___at_Lean_LocalContext_contains___spec__1(lean_object*, lean_object*); lean_object* lean_local_ctx_pop(lean_object*); +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_PersistentArray_anyMAux___main___at_Lean_LocalContext_allM___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_LocalContext_isSubPrefixOfAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_findSomeMAux___main___at_Lean_LocalContext_findDecl_x3f___spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*); @@ -228,6 +236,7 @@ lean_object* l_Lean_LocalDecl_toExpr(lean_object*); extern lean_object* l_PersistentHashMap_empty___rarg___closed__2; lean_object* l_Lean_mkLambda(lean_object*, uint8_t, lean_object*, lean_object*); size_t l_USize_mul(size_t, size_t); +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___spec__5(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_LocalDecl_toExpr___boxed(lean_object*); uint8_t l_Lean_LocalContext_all(lean_object*, lean_object*); lean_object* l_Lean_LocalContext_findFVar_x3f___boxed(lean_object*, lean_object*); @@ -258,6 +267,7 @@ lean_object* l_Lean_LocalDecl_type(lean_object*); lean_object* l_Lean_LocalDecl_value_x3f(lean_object*); lean_object* lean_local_ctx_mk_local_decl(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); lean_object* l_Lean_LocalContext_foldlFrom___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_PersistentArray_foldlM___at_Lean_LocalContext_getFVarIds___spec__1___boxed(lean_object*, lean_object*); lean_object* l_PersistentArray_foldlFromMAux___main___at_Lean_LocalContext_foldlFrom___spec__3___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*); lean_object* l_Array_findSomeMAux___main___at_Lean_LocalContext_findDecl_x3f___spec__5(lean_object*); lean_object* l_Lean_LocalContext_findDecl_x3f___rarg(lean_object*, lean_object*); @@ -277,6 +287,7 @@ lean_object* l_Lean_LocalContext_findDeclRevM_x3f___at_Lean_LocalContext_findDec lean_object* l_Lean_LocalDecl_fvarId___boxed(lean_object*); uint8_t lean_nat_dec_le(lean_object*, lean_object*); uint8_t l_USize_decLe(size_t, size_t); +lean_object* l_PersistentArray_foldlMAux___main___at_Lean_LocalContext_getFVarIds___spec__2___boxed(lean_object*, lean_object*); lean_object* l_Lean_mkLocalDeclEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_PersistentArray_foldlM___at_Lean_LocalContext_foldl___spec__2___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_PersistentArray_anyM___at_Lean_LocalContext_all___spec__1___boxed(lean_object*, lean_object*); @@ -297,9 +308,11 @@ lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_foldlFrom___spec_ lean_object* l_Lean_LocalContext_get_x21___closed__2; lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_anyM___spec__3(lean_object*); lean_object* l_Lean_LocalContext_addDecl(lean_object*, lean_object*); +lean_object* l_Lean_LocalContext_getFVarIds(lean_object*); lean_object* l_Lean_LocalContext_any___boxed(lean_object*, lean_object*); lean_object* l___private_Init_Lean_LocalContext_1__popTailNoneAux(lean_object*); lean_object* l_Lean_LocalContext_mkLambda(lean_object*, lean_object*, lean_object*); +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_findSomeRevMAux___main___at_Lean_LocalContext_findDeclRev_x3f___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_PersistentArray_anyMAux___main___at_Lean_LocalContext_all___spec__2(lean_object*, lean_object*); lean_object* l_Array_eraseIdx_x27___rarg(lean_object*, lean_object*); @@ -320,6 +333,7 @@ lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_allM___spec__5__ lean_object* l_PersistentHashMap_insert___at_Lean_LocalContext_mkLocalDecl___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l_PersistentHashMap_getCollisionNodeSize___rarg(lean_object*); lean_object* l_Lean_mkLet(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___spec__4(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Expr_Inhabited; lean_object* l_Array_findSomeRevMAux___main___at_Lean_LocalContext_findDeclRev_x3f___spec__6(lean_object*); lean_object* l_Lean_LocalContext_foldlM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -328,6 +342,7 @@ lean_object* l_Lean_LocalContext_getFVar_x21___boxed(lean_object*, lean_object*) lean_object* lean_expr_abstract(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_foldlFrom___spec__7(lean_object*); lean_object* l_PersistentArray_findSomeRevM_x3f___at_Lean_LocalContext_findDeclRev_x3f___spec__2(lean_object*); +lean_object* l_Lean_LocalContext_getFVars___boxed(lean_object*); lean_object* l_PersistentArray_findSomeM_x3f___at_Lean_LocalContext_findDecl_x3f___spec__2(lean_object*); lean_object* l_Lean_LocalContext_findDeclM_x3f___at_Lean_LocalContext_findDecl_x3f___spec__1___rarg(lean_object*, lean_object*); lean_object* l_PersistentArray_findSomeRevMAux___main___at_Lean_LocalContext_findDeclRev_x3f___spec__4(lean_object*); @@ -338,9 +353,12 @@ lean_object* l_PersistentHashMap_erase___at_Lean_LocalContext_erase___spec__1___ lean_object* l_Lean_LocalContext_isSubPrefixOf___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_LocalContext_mkBinding___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_findSomeMAux___main___at_Lean_LocalContext_findDecl_x3f___spec__6(lean_object*); +lean_object* l_Lean_LocalContext_getFVarIds___boxed(lean_object*); lean_object* l_PersistentArray_findSomeRevM_x3f___at_Lean_LocalContext_findFromUserName_x3f___spec__1___boxed(lean_object*, lean_object*); lean_object* l_PersistentArray_foldlFromM___at_Lean_LocalContext_foldlFrom___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___spec__3(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_findSomeRevMAux___main___at_Lean_LocalContext_findDeclRev_x3f___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_LocalContext_foldlFromM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_local_ctx_find(lean_object*, lean_object*); lean_object* l_Lean_LocalContext_allM(lean_object*); @@ -1960,6 +1978,265 @@ x_4 = lean_box(x_3); return x_4; } } +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___spec__3(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; +x_5 = lean_array_get_size(x_2); +x_6 = lean_nat_dec_lt(x_3, x_5); +lean_dec(x_5); +if (x_6 == 0) +{ +lean_dec(x_3); +return x_4; +} +else +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_7 = lean_array_fget(x_2, x_3); +x_8 = l_PersistentArray_foldlMAux___main___at_Lean_LocalContext_getFVarIds___spec__2(x_7, x_4); +lean_dec(x_7); +x_9 = lean_unsigned_to_nat(1u); +x_10 = lean_nat_add(x_3, x_9); +lean_dec(x_3); +x_3 = x_10; +x_4 = x_8; +goto _start; +} +} +} +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___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; +x_5 = lean_array_get_size(x_2); +x_6 = lean_nat_dec_lt(x_3, x_5); +lean_dec(x_5); +if (x_6 == 0) +{ +lean_dec(x_3); +return x_4; +} +else +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_array_fget(x_2, x_3); +x_8 = lean_unsigned_to_nat(1u); +x_9 = lean_nat_add(x_3, x_8); +lean_dec(x_3); +if (lean_obj_tag(x_7) == 0) +{ +x_3 = x_9; +goto _start; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_7, 0); +lean_inc(x_11); +lean_dec(x_7); +x_12 = l_Lean_LocalDecl_fvarId(x_11); +lean_dec(x_11); +x_13 = lean_array_push(x_4, x_12); +x_3 = x_9; +x_4 = x_13; +goto _start; +} +} +} +} +lean_object* l_PersistentArray_foldlMAux___main___at_Lean_LocalContext_getFVarIds___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +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_Lean_LocalContext_getFVarIds___spec__3(x_3, x_3, x_4, x_2); +return x_5; +} +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_Lean_LocalContext_getFVarIds___spec__4(x_6, x_6, x_7, x_2); +return x_8; +} +} +} +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___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; +x_5 = lean_array_get_size(x_2); +x_6 = lean_nat_dec_lt(x_3, x_5); +lean_dec(x_5); +if (x_6 == 0) +{ +lean_dec(x_3); +return x_4; +} +else +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_array_fget(x_2, x_3); +x_8 = lean_unsigned_to_nat(1u); +x_9 = lean_nat_add(x_3, x_8); +lean_dec(x_3); +if (lean_obj_tag(x_7) == 0) +{ +x_3 = x_9; +goto _start; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_7, 0); +lean_inc(x_11); +lean_dec(x_7); +x_12 = l_Lean_LocalDecl_fvarId(x_11); +lean_dec(x_11); +x_13 = lean_array_push(x_4, x_12); +x_3 = x_9; +x_4 = x_13; +goto _start; +} +} +} +} +lean_object* l_PersistentArray_foldlM___at_Lean_LocalContext_getFVarIds___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_PersistentArray_foldlMAux___main___at_Lean_LocalContext_getFVarIds___spec__2(x_3, x_2); +x_5 = lean_ctor_get(x_1, 1); +x_6 = lean_unsigned_to_nat(0u); +x_7 = l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___spec__5(x_1, x_5, x_6, x_4); +return x_7; +} +} +lean_object* l_Lean_LocalContext_getFVarIds(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_2 = lean_ctor_get(x_1, 1); +x_3 = l_Array_empty___closed__1; +x_4 = l_PersistentArray_foldlM___at_Lean_LocalContext_getFVarIds___spec__1(x_2, x_3); +return x_4; +} +} +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___spec__3___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_Lean_LocalContext_getFVarIds___spec__3(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_Lean_LocalContext_getFVarIds___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_Lean_LocalContext_getFVarIds___spec__4(x_1, x_2, x_3, x_4); +lean_dec(x_2); +lean_dec(x_1); +return x_5; +} +} +lean_object* l_PersistentArray_foldlMAux___main___at_Lean_LocalContext_getFVarIds___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_PersistentArray_foldlMAux___main___at_Lean_LocalContext_getFVarIds___spec__2(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_Array_iterateMAux___main___at_Lean_LocalContext_getFVarIds___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_Lean_LocalContext_getFVarIds___spec__5(x_1, x_2, x_3, x_4); +lean_dec(x_2); +lean_dec(x_1); +return x_5; +} +} +lean_object* l_PersistentArray_foldlM___at_Lean_LocalContext_getFVarIds___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_PersistentArray_foldlM___at_Lean_LocalContext_getFVarIds___spec__1(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_Lean_LocalContext_getFVarIds___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_LocalContext_getFVarIds(x_1); +lean_dec(x_1); +return x_2; +} +} +lean_object* l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_array_get_size(x_2); +x_4 = lean_nat_dec_lt(x_1, x_3); +lean_dec(x_3); +if (x_4 == 0) +{ +lean_dec(x_1); +return x_2; +} +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; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_5 = lean_array_fget(x_2, x_1); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_array_fset(x_2, x_1, x_6); +x_8 = x_5; +x_9 = l_Lean_mkFVar(x_8); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +x_12 = x_9; +x_13 = lean_array_fset(x_7, x_1, x_12); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_13; +goto _start; +} +} +} +lean_object* l_Lean_LocalContext_getFVars(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_2 = l_Lean_LocalContext_getFVarIds(x_1); +x_3 = x_2; +x_4 = lean_unsigned_to_nat(0u); +x_5 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_4, x_3); +x_6 = x_5; +return x_6; +} +} +lean_object* l_Lean_LocalContext_getFVars___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_LocalContext_getFVars(x_1); +lean_dec(x_1); +return x_2; +} +} lean_object* l_PersistentArray_getAux___main___at___private_Init_Lean_LocalContext_1__popTailNoneAux___main___spec__2(lean_object* x_1, size_t x_2, size_t x_3) { _start: { @@ -5310,7 +5587,7 @@ _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_LocalDecl_value___closed__1; -x_2 = lean_unsigned_to_nat(289u); +x_2 = lean_unsigned_to_nat(299u); x_3 = lean_unsigned_to_nat(12u); x_4 = l_Lean_LocalContext_get_x21___closed__1; x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4); @@ -5393,24 +5670,28 @@ lean_dec(x_16); x_28 = lean_expr_has_loose_bvar(x_5, x_6); if (x_28 == 0) { +lean_object* x_29; lean_dec(x_27); lean_dec(x_26); lean_dec(x_25); +x_29 = lean_expr_lower_loose_bvars(x_5, x_8, x_8); +lean_dec(x_5); x_4 = x_9; +x_5 = x_29; goto _start; } else { -lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; -x_30 = lean_expr_abstract_range(x_26, x_9, x_3); +lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; +x_31 = lean_expr_abstract_range(x_26, x_9, x_3); lean_dec(x_26); -x_31 = lean_expr_abstract_range(x_27, x_9, x_3); +x_32 = lean_expr_abstract_range(x_27, x_9, x_3); lean_dec(x_27); -x_32 = 0; -x_33 = l_Lean_mkLet(x_25, x_30, x_31, x_5, x_32); +x_33 = 0; +x_34 = l_Lean_mkLet(x_25, x_31, x_32, x_5, x_33); lean_dec(x_25); x_4 = x_9; -x_5 = x_33; +x_5 = x_34; goto _start; } } @@ -5520,24 +5801,28 @@ lean_dec(x_15); x_25 = lean_expr_has_loose_bvar(x_4, x_5); if (x_25 == 0) { +lean_object* x_26; lean_dec(x_24); lean_dec(x_23); lean_dec(x_22); +x_26 = lean_expr_lower_loose_bvars(x_4, x_7, x_7); +lean_dec(x_4); x_3 = x_8; +x_4 = x_26; goto _start; } else { -lean_object* x_27; lean_object* x_28; uint8_t x_29; lean_object* x_30; -x_27 = lean_expr_abstract_range(x_23, x_8, x_2); +lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; +x_28 = lean_expr_abstract_range(x_23, x_8, x_2); lean_dec(x_23); -x_28 = lean_expr_abstract_range(x_24, x_8, x_2); +x_29 = lean_expr_abstract_range(x_24, x_8, x_2); lean_dec(x_24); -x_29 = 0; -x_30 = l_Lean_mkLet(x_22, x_27, x_28, x_4, x_29); +x_30 = 0; +x_31 = l_Lean_mkLet(x_22, x_28, x_29, x_4, x_30); lean_dec(x_22); x_3 = x_8; -x_4 = x_30; +x_4 = x_31; goto _start; } } @@ -5643,24 +5928,28 @@ lean_dec(x_15); x_25 = lean_expr_has_loose_bvar(x_4, x_5); if (x_25 == 0) { +lean_object* x_26; lean_dec(x_24); lean_dec(x_23); lean_dec(x_22); +x_26 = lean_expr_lower_loose_bvars(x_4, x_7, x_7); +lean_dec(x_4); x_3 = x_8; +x_4 = x_26; goto _start; } else { -lean_object* x_27; lean_object* x_28; uint8_t x_29; lean_object* x_30; -x_27 = lean_expr_abstract_range(x_23, x_8, x_2); +lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; +x_28 = lean_expr_abstract_range(x_23, x_8, x_2); lean_dec(x_23); -x_28 = lean_expr_abstract_range(x_24, x_8, x_2); +x_29 = lean_expr_abstract_range(x_24, x_8, x_2); lean_dec(x_24); -x_29 = 0; -x_30 = l_Lean_mkLet(x_22, x_27, x_28, x_4, x_29); +x_30 = 0; +x_31 = l_Lean_mkLet(x_22, x_28, x_29, x_4, x_30); lean_dec(x_22); x_3 = x_8; -x_4 = x_30; +x_4 = x_31; goto _start; } } diff --git a/stage0/stdlib/Init/Lean/Message.c b/stage0/stdlib/Init/Lean/Message.c index 6a59684d7e..f855379191 100644 --- a/stage0/stdlib/Init/Lean/Message.c +++ b/stage0/stdlib/Init/Lean/Message.c @@ -14,14 +14,20 @@ extern "C" { #endif lean_object* l_List_reverse___rarg(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__32; +lean_object* l_Lean_KernelException_toMessageData___closed__10; lean_object* l_PersistentArray_forM___rarg(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Name_toString___closed__1; +lean_object* l_Lean_KernelException_toMessageData___closed__51; lean_object* l_PersistentArray_mapM___at_Lean_MessageLog_errorsToWarnings___spec__1(lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_MessageLog_toList___spec__5(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__19; extern lean_object* l_addParenHeuristic___closed__2; +lean_object* l_Lean_KernelException_toMessageData___closed__49; lean_object* l_Array_umapMAux___main___at_Lean_MessageLog_errorsToWarnings___spec__3(lean_object*, lean_object*); lean_object* l_PersistentArray_foldlM___at_Lean_MessageLog_toList___spec__1___boxed(lean_object*, lean_object*); lean_object* l_Lean_MessageData_ofList___closed__3; +lean_object* l_Lean_KernelException_toMessageData___closed__7; lean_object* l_Array_umapMAux___main___at_Lean_MessageLog_errorsToWarnings___spec__4(lean_object*, lean_object*); lean_object* l_Lean_MessageData_ofArray___boxed(lean_object*); lean_object* l_Lean_Message_toString___closed__3; @@ -31,6 +37,7 @@ lean_object* l_Lean_Format_pretty(lean_object*, lean_object*); lean_object* l_Lean_MessageLog_hasErrors___boxed(lean_object*); uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageLog_hasErrors___spec__4(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_stxMaxDepthOption___closed__4; +lean_object* l_Lean_KernelException_toMessageData___closed__24; lean_object* l_Lean_MessageData_sbracket(lean_object*); lean_object* l_Lean_MessageData_coeOfSyntax(lean_object*); extern lean_object* l_Lean_List_format___rarg___closed__1; @@ -46,8 +53,10 @@ lean_object* l_Lean_MessageData_Lean_HasFormat(lean_object*); lean_object* l_Lean_MessageData_coeOfFormat(lean_object*); lean_object* l_Lean_MessageData_arrayExpr_toMessageData___main___boxed(lean_object*, lean_object*, lean_object*); lean_object* lean_array_get_size(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__43; lean_object* lean_string_append(lean_object*, lean_object*); lean_object* l_Lean_MessageData_formatAux___main(lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__16; lean_object* l_Lean_MessageData_ofList(lean_object*); extern lean_object* l_Lean_formatKVMap___closed__1; lean_object* l_PersistentArray_push___rarg(lean_object*, lean_object*); @@ -56,77 +65,111 @@ lean_object* l_Lean_MessageData_stxMaxDepthOption(lean_object*); extern lean_object* l_List_repr___rarg___closed__3; lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageLog_hasErrors___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_joinSep(lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__20; +lean_object* l___private_Init_Lean_Message_1__mkCtx(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_fmt___at_Lean_Level_LevelToFormat_toResult___main___spec__1(lean_object*); lean_object* lean_nat_add(lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__22; uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageLog_hasErrors___spec__5(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__37; extern lean_object* l_Lean_Format_sbracket___closed__2; lean_object* lean_message_string(lean_object*); extern lean_object* l_EStateM_Result_toString___rarg___closed__2; +extern lean_object* l_Lean_LocalContext_Inhabited___closed__2; lean_object* l_Lean_MessageLog_toList(lean_object*); lean_object* l_PersistentArray_foldlMAux___main___at_Lean_MessageLog_toList___spec__2(lean_object*, lean_object*); lean_object* l_Lean_ppGoal(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_PersistentArray_anyM___at_Lean_MessageLog_hasErrors___spec__1___boxed(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__6; lean_object* lean_array_fget(lean_object*, lean_object*); lean_object* l_Lean_MessageLog_append(lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__46; uint8_t lean_nat_dec_eq(lean_object*, lean_object*); extern lean_object* l_Lean_Option_format___rarg___closed__1; lean_object* l_Lean_MessageData_coeOfName(lean_object*); lean_object* l_Lean_MessageData_coeOfOptExpr(lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_MessageData_formatAux___main___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_Inhabited; +lean_object* l_Lean_KernelException_toMessageData___closed__29; lean_object* l_Lean_fmt___at_Lean_MessageData_formatAux___main___spec__1(lean_object*); +lean_object* l_Lean_KernelException_toMessageData(lean_object*, lean_object*); lean_object* l_Lean_MessageData_stxMaxDepthOption___closed__1; lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageLog_errorsToWarnings(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__25; lean_object* l_PersistentArray_foldlM___at_Lean_MessageLog_toList___spec__1(lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__30; lean_object* l_Lean_Message_Inhabited; lean_object* l_Lean_Message_HasToString; lean_object* l_Lean_MessageLog_HasAppend; lean_object* l_Nat_repr(lean_object*); lean_object* l_Lean_MessageData_coeOfArrayExpr___closed__2; +lean_object* l_Lean_KernelException_toMessageData___closed__18; lean_object* l_Lean_Message_toString___closed__4; +lean_object* l_Lean_KernelException_toMessageData___closed__5; lean_object* l_PersistentArray_anyMAux___main___at_Lean_MessageLog_hasErrors___spec__2___boxed(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__33; lean_object* lean_name_mk_string(lean_object*, lean_object*); extern lean_object* l_List_repr___rarg___closed__2; +lean_object* l_Lean_KernelException_toMessageData___closed__14; +lean_object* l_Lean_KernelException_toMessageData___closed__28; extern lean_object* l_PersistentArray_empty___closed__3; lean_object* l_Array_iterateMAux___main___at_Lean_MessageData_formatAux___main___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Message_toString___closed__1; lean_object* l_Lean_Message_toString___closed__2; extern lean_object* l_Lean_Options_empty; lean_object* lean_expr_dbg_to_string(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__34; uint8_t l_PersistentArray_isEmpty___rarg(lean_object*); lean_object* l_Lean_MessageData_getSyntaxMaxDepth___boxed(lean_object*); lean_object* l_Lean_MessageData_coeOfArrayExpr(lean_object*); lean_object* l_Lean_ppExpr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_formatAux___main___closed__1; +lean_object* l_Lean_KernelException_toMessageData___closed__15; +lean_object* l_Lean_KernelException_toMessageData___closed__42; extern lean_object* l_String_Iterator_HasRepr___closed__2; lean_object* l_Array_iterateMAux___main___at_Lean_MessageLog_toList___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_ofList___closed__2; +lean_object* l_Lean_KernelException_toMessageData___closed__27; lean_object* l_Lean_Message_HasToString___closed__1; lean_object* l_Lean_MessageData_ofList___boxed(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__3; +lean_object* l_Lean_KernelException_toMessageData___closed__40; lean_object* l_Lean_MessageData_arrayExpr_toMessageData(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__9; lean_object* l_Lean_MessageData_joinSep___main(lean_object*, lean_object*); lean_object* l_Lean_KVMap_getNat(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageLog_toList___boxed(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__36; lean_object* l_PersistentArray_mapMAux___main___at_Lean_MessageLog_errorsToWarnings___spec__2(lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_MessageLog_toList___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t lean_message_severity(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__45; lean_object* l_Lean_MessageLog_HasAppend___closed__1; lean_object* l_Lean_MessageData_ofArray(lean_object*); extern lean_object* l_Lean_Format_sbracket___closed__3; lean_object* l_Lean_MessageLog_forM___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_PersistentArray_append___rarg(lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__1; lean_object* l_Lean_MessageData_formatAux___main___closed__2; extern lean_object* l_Option_HasRepr___rarg___closed__3; +lean_object* l_Lean_KernelException_toMessageData___closed__50; lean_object* l_Lean_MessageData_getSyntaxMaxDepth(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__8; lean_object* l_Lean_fmt___at_Lean_Message_toString___spec__1(lean_object*); lean_object* l_Lean_MessageLog_empty; +lean_object* l_Lean_KernelException_toMessageData___closed__4; lean_object* l_Array_iterateMAux___main___at_Lean_MessageLog_toList___spec__3(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__17; +lean_object* l_Lean_KernelException_toMessageData___closed__38; +lean_object* l_Lean_KernelException_toMessageData___closed__21; lean_object* l_Lean_mkErrorStringWithPos___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__47; lean_object* l_Lean_MessageData_coeOfArrayExpr___closed__1; extern lean_object* l_Lean_Format_sbracket___closed__1; lean_object* l_Lean_MessageData_HasAppend(lean_object*, lean_object*); extern lean_object* l___private_Init_Util_1__mkPanicMessage___closed__2; +lean_object* l_Lean_KernelException_toMessageData___closed__2; lean_object* lean_register_option(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_ofList___closed__4; lean_object* l_Lean_mkMessageEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -134,10 +177,17 @@ lean_object* l_Lean_MessageData_bracket(lean_object*, lean_object*, lean_object* lean_object* lean_format_group(lean_object*); lean_object* l_Lean_MessageData_joinSep___boxed(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_MessageLog_toList___spec__4(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__31; +lean_object* l_Lean_KernelException_toMessageData___closed__35; +lean_object* l_Lean_KernelException_toMessageData___closed__41; +lean_object* l_Lean_KernelException_toMessageData___closed__23; lean_object* l_Array_iterateMAux___main___at_Lean_MessageLog_toList___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageLog_hasErrors___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_joinSep___main___boxed(lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__48; +lean_object* l_Lean_KernelException_toMessageData___closed__12; lean_object* l_Array_toList___rarg(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__13; lean_object* l_Lean_MessageData_arrayExpr_toMessageData___main___closed__2; lean_object* l_Lean_MessageLog_forM(lean_object*); uint8_t l_Lean_MessageLog_hasErrors(lean_object*); @@ -146,10 +196,12 @@ lean_object* l_Lean_Message_Inhabited___closed__1; extern lean_object* l_Lean_List_format___rarg___closed__3; lean_object* l_Lean_Message_Inhabited___closed__2; lean_object* l_Lean_MessageData_coeOfOptExpr___boxed(lean_object*); +extern lean_object* l_Lean_MetavarContext_Inhabited___closed__1; lean_object* l_Lean_MessageData_coeOfOptExpr___closed__1; lean_object* l_PersistentArray_foldlMAux___main___at_Lean_MessageLog_toList___spec__2___boxed(lean_object*, lean_object*); uint8_t l_PersistentArray_anyM___at_Lean_MessageLog_hasErrors___spec__1(lean_object*); -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__44; lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_MessageData_formatAux___main___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*); @@ -158,10 +210,12 @@ lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageLog_hasErrors___spec__ lean_object* lean_message_pos(lean_object*); uint8_t l_Lean_MessageLog_isEmpty(lean_object*); lean_object* l_Lean_MessageData_coeOfExpr(lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__26; lean_object* l_Lean_Message_getSeverityEx___boxed(lean_object*); lean_object* l_Lean_MessageLog_append___boxed(lean_object*, lean_object*); lean_object* l_Lean_Message_toString(lean_object*); lean_object* l_Lean_MessageData_formatAux(lean_object*, lean_object*); +lean_object* l_Lean_indentExpr(lean_object*); lean_object* l_Lean_MessageData_paren(lean_object*); lean_object* l_Lean_Level_format(lean_object*); lean_object* l_Lean_MessageData_Inhabited___closed__1; @@ -170,6 +224,7 @@ lean_object* l_Lean_MessageData_stxMaxDepthOption___closed__5; lean_object* l_Array_iterateMAux___main___at_Lean_MessageData_formatAux___main___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_mkErrorStringWithPos(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_ofList___closed__1; +lean_object* l_Lean_KernelException_toMessageData___closed__11; lean_object* l_Lean_MessageLog_isEmpty___boxed(lean_object*); lean_object* l_Lean_MessageData_arrayExpr_toMessageData___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_coeOfArrayExpr___boxed(lean_object*); @@ -177,6 +232,7 @@ lean_object* lean_mk_message(lean_object*, lean_object*, lean_object*, uint8_t, uint8_t lean_string_dec_eq(lean_object*, lean_object*); uint8_t lean_nat_dec_lt(lean_object*, lean_object*); uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageLog_hasErrors___spec__3(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_KernelException_toMessageData___closed__39; lean_object* l_Lean_mkErrorStringWithPos(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { @@ -420,174 +476,175 @@ return x_3; } case 1: { -lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; x_4 = lean_ctor_get(x_2, 0); lean_inc(x_4); lean_dec(x_2); x_5 = lean_box(0); -x_6 = lean_unsigned_to_nat(0u); -x_7 = l_Lean_Syntax_formatStxAux___main(x_5, x_6, x_4); -return x_7; +x_6 = 0; +x_7 = lean_unsigned_to_nat(0u); +x_8 = l_Lean_Syntax_formatStxAux___main(x_5, x_6, x_7, x_4); +return x_8; } case 2: { -lean_object* x_8; lean_object* x_9; lean_object* x_10; -x_8 = lean_ctor_get(x_2, 0); -lean_inc(x_8); +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_2, 0); +lean_inc(x_9); lean_dec(x_2); -x_9 = lean_expr_dbg_to_string(x_8); -lean_dec(x_8); -x_10 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_10, 0, x_9); -return x_10; +x_10 = lean_expr_dbg_to_string(x_9); +lean_dec(x_9); +x_11 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_11, 0, x_10); +return x_11; } case 3: { -lean_object* x_11; lean_object* x_12; -x_11 = lean_ctor_get(x_2, 0); -lean_inc(x_11); +lean_object* x_12; lean_object* x_13; +x_12 = lean_ctor_get(x_2, 0); +lean_inc(x_12); lean_dec(x_2); -x_12 = l_Lean_Level_format(x_11); -return x_12; +x_13 = l_Lean_Level_format(x_12); +return x_13; } case 4: { -lean_object* x_13; lean_object* x_14; -x_13 = lean_ctor_get(x_2, 0); -lean_inc(x_13); +lean_object* x_14; lean_object* x_15; +x_14 = lean_ctor_get(x_2, 0); +lean_inc(x_14); lean_dec(x_2); -x_14 = l_Lean_fmt___at_Lean_Level_LevelToFormat_toResult___main___spec__1(x_13); -return x_14; +x_15 = l_Lean_fmt___at_Lean_Level_LevelToFormat_toResult___main___spec__1(x_14); +return x_15; } case 5: { -lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; -x_15 = lean_ctor_get(x_2, 0); -lean_inc(x_15); +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; +x_16 = lean_ctor_get(x_2, 0); +lean_inc(x_16); lean_dec(x_2); -x_16 = l_Lean_mkMVar(x_15); -x_17 = lean_expr_dbg_to_string(x_16); -lean_dec(x_16); -x_18 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_18, 0, x_17); -x_19 = 0; -x_20 = l_Lean_MessageData_formatAux___main___closed__2; -x_21 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_21, 0, x_20); -lean_ctor_set(x_21, 1, x_18); -lean_ctor_set_uint8(x_21, sizeof(void*)*2, x_19); -return x_21; +x_17 = l_Lean_mkMVar(x_16); +x_18 = lean_expr_dbg_to_string(x_17); +lean_dec(x_17); +x_19 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_19, 0, x_18); +x_20 = 0; +x_21 = l_Lean_MessageData_formatAux___main___closed__2; +x_22 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_19); +lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_20); +return x_22; } case 6: { -lean_object* x_22; lean_object* x_23; lean_object* x_24; -x_22 = lean_ctor_get(x_2, 0); -lean_inc(x_22); -x_23 = lean_ctor_get(x_2, 1); +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_2, 0); lean_inc(x_23); +x_24 = lean_ctor_get(x_2, 1); +lean_inc(x_24); lean_dec(x_2); -x_24 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_24, 0, x_22); -x_1 = x_24; -x_2 = x_23; +x_25 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_25, 0, x_23); +x_1 = x_25; +x_2 = x_24; goto _start; } case 7: { -lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -x_26 = lean_ctor_get(x_2, 0); -lean_inc(x_26); -x_27 = lean_ctor_get(x_2, 1); +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_27 = lean_ctor_get(x_2, 0); lean_inc(x_27); +x_28 = lean_ctor_get(x_2, 1); +lean_inc(x_28); lean_dec(x_2); -x_28 = l_Lean_MessageData_formatAux___main(x_1, x_27); -x_29 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_29, 0, x_26); -lean_ctor_set(x_29, 1, x_28); -return x_29; +x_29 = l_Lean_MessageData_formatAux___main(x_1, x_28); +x_30 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_30, 0, x_27); +lean_ctor_set(x_30, 1, x_29); +return x_30; } case 8: { -lean_object* x_30; lean_object* x_31; lean_object* x_32; -x_30 = lean_ctor_get(x_2, 0); -lean_inc(x_30); +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_2, 0); +lean_inc(x_31); lean_dec(x_2); -x_31 = l_Lean_MessageData_formatAux___main(x_1, x_30); -x_32 = lean_format_group(x_31); -return x_32; +x_32 = l_Lean_MessageData_formatAux___main(x_1, x_31); +x_33 = lean_format_group(x_32); +return x_33; } case 9: { -lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_object* x_38; -x_33 = lean_ctor_get(x_2, 0); -lean_inc(x_33); -x_34 = lean_ctor_get(x_2, 1); +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_2, 0); lean_inc(x_34); +x_35 = lean_ctor_get(x_2, 1); +lean_inc(x_35); lean_dec(x_2); -x_35 = l_Lean_MessageData_formatAux___main(x_1, x_33); x_36 = l_Lean_MessageData_formatAux___main(x_1, x_34); -x_37 = 0; -x_38 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_38, 0, x_35); -lean_ctor_set(x_38, 1, x_36); -lean_ctor_set_uint8(x_38, sizeof(void*)*2, x_37); -return x_38; +x_37 = l_Lean_MessageData_formatAux___main(x_1, x_35); +x_38 = 0; +x_39 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_39, 0, x_36); +lean_ctor_set(x_39, 1, x_37); +lean_ctor_set_uint8(x_39, sizeof(void*)*2, x_38); +return x_39; } case 10: { -lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_39 = lean_ctor_get(x_2, 0); -lean_inc(x_39); -x_40 = lean_ctor_get(x_2, 1); +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_40 = lean_ctor_get(x_2, 0); lean_inc(x_40); +x_41 = lean_ctor_get(x_2, 1); +lean_inc(x_41); lean_dec(x_2); -x_41 = l_Lean_Name_toString___closed__1; -x_42 = l_Lean_Name_toStringWithSep___main(x_41, x_39); -x_43 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_43, 0, x_42); -x_44 = 0; -x_45 = l_Lean_Format_sbracket___closed__2; -x_46 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_46, 0, x_45); -lean_ctor_set(x_46, 1, x_43); -lean_ctor_set_uint8(x_46, sizeof(void*)*2, x_44); -x_47 = l_Lean_Format_sbracket___closed__3; -x_48 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_48, 0, x_46); -lean_ctor_set(x_48, 1, x_47); -lean_ctor_set_uint8(x_48, sizeof(void*)*2, x_44); -x_49 = l_Lean_Format_sbracket___closed__1; -x_50 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_50, 0, x_49); -lean_ctor_set(x_50, 1, x_48); -x_51 = lean_format_group(x_50); -x_52 = l_Lean_Format_flatten___main___closed__1; -x_53 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_53, 0, x_51); -lean_ctor_set(x_53, 1, x_52); -lean_ctor_set_uint8(x_53, sizeof(void*)*2, x_44); -x_54 = l_Lean_MessageData_formatAux___main(x_1, x_40); -x_55 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_55, 0, x_53); -lean_ctor_set(x_55, 1, x_54); -lean_ctor_set_uint8(x_55, sizeof(void*)*2, x_44); -return x_55; +x_42 = l_Lean_Name_toString___closed__1; +x_43 = l_Lean_Name_toStringWithSep___main(x_42, x_40); +x_44 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_44, 0, x_43); +x_45 = 0; +x_46 = l_Lean_Format_sbracket___closed__2; +x_47 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_44); +lean_ctor_set_uint8(x_47, sizeof(void*)*2, x_45); +x_48 = l_Lean_Format_sbracket___closed__3; +x_49 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +lean_ctor_set_uint8(x_49, sizeof(void*)*2, x_45); +x_50 = l_Lean_Format_sbracket___closed__1; +x_51 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_format_group(x_51); +x_53 = l_Lean_Format_flatten___main___closed__1; +x_54 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set(x_54, 1, x_53); +lean_ctor_set_uint8(x_54, sizeof(void*)*2, x_45); +x_55 = l_Lean_MessageData_formatAux___main(x_1, x_41); +x_56 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set_uint8(x_56, sizeof(void*)*2, x_45); +return x_56; } default: { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; -x_56 = lean_ctor_get(x_2, 0); -lean_inc(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; +x_57 = lean_ctor_get(x_2, 0); +lean_inc(x_57); lean_dec(x_2); -x_57 = lean_unsigned_to_nat(0u); -x_58 = lean_box(0); -x_59 = l_Array_iterateMAux___main___at_Lean_MessageData_formatAux___main___spec__2(x_1, x_56, x_56, x_57, x_58); -lean_dec(x_56); -x_60 = lean_unsigned_to_nat(2u); -x_61 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_61, 0, x_60); -lean_ctor_set(x_61, 1, x_59); -return x_61; +x_58 = lean_unsigned_to_nat(0u); +x_59 = lean_box(0); +x_60 = l_Array_iterateMAux___main___at_Lean_MessageData_formatAux___main___spec__2(x_1, x_57, x_57, x_58, x_59); +lean_dec(x_57); +x_61 = lean_unsigned_to_nat(2u); +x_62 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_60); +return x_62; } } } @@ -596,248 +653,250 @@ else switch (lean_obj_tag(x_2)) { case 0: { -lean_object* x_62; +lean_object* x_63; lean_dec(x_1); -x_62 = lean_ctor_get(x_2, 0); -lean_inc(x_62); +x_63 = lean_ctor_get(x_2, 0); +lean_inc(x_63); lean_dec(x_2); -return x_62; +return x_63; } case 1: { -uint8_t x_63; -x_63 = !lean_is_exclusive(x_1); -if (x_63 == 0) +uint8_t x_64; +x_64 = !lean_is_exclusive(x_1); +if (x_64 == 0) { -lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; -x_64 = lean_ctor_get(x_1, 0); -x_65 = lean_ctor_get(x_2, 0); -lean_inc(x_65); -lean_dec(x_2); -x_66 = lean_ctor_get(x_64, 3); +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; lean_object* x_70; lean_object* x_71; +x_65 = lean_ctor_get(x_1, 0); +x_66 = lean_ctor_get(x_2, 0); lean_inc(x_66); -lean_dec(x_64); -x_67 = l_Lean_MessageData_getSyntaxMaxDepth(x_66); -lean_dec(x_66); -lean_ctor_set(x_1, 0, x_67); -x_68 = lean_unsigned_to_nat(0u); -x_69 = l_Lean_Syntax_formatStxAux___main(x_1, x_68, x_65); +lean_dec(x_2); +x_67 = lean_ctor_get(x_65, 3); +lean_inc(x_67); +lean_dec(x_65); +x_68 = l_Lean_MessageData_getSyntaxMaxDepth(x_67); +lean_dec(x_67); +lean_ctor_set(x_1, 0, x_68); +x_69 = 0; +x_70 = lean_unsigned_to_nat(0u); +x_71 = l_Lean_Syntax_formatStxAux___main(x_1, x_69, x_70, x_66); lean_dec(x_1); -return x_69; +return x_71; } else { -lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; -x_70 = lean_ctor_get(x_1, 0); -lean_inc(x_70); -lean_dec(x_1); -x_71 = lean_ctor_get(x_2, 0); -lean_inc(x_71); -lean_dec(x_2); -x_72 = lean_ctor_get(x_70, 3); +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; uint8_t x_77; lean_object* x_78; lean_object* x_79; +x_72 = lean_ctor_get(x_1, 0); lean_inc(x_72); -lean_dec(x_70); -x_73 = l_Lean_MessageData_getSyntaxMaxDepth(x_72); +lean_dec(x_1); +x_73 = lean_ctor_get(x_2, 0); +lean_inc(x_73); +lean_dec(x_2); +x_74 = lean_ctor_get(x_72, 3); +lean_inc(x_74); lean_dec(x_72); -x_74 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_74, 0, x_73); -x_75 = lean_unsigned_to_nat(0u); -x_76 = l_Lean_Syntax_formatStxAux___main(x_74, x_75, x_71); +x_75 = l_Lean_MessageData_getSyntaxMaxDepth(x_74); lean_dec(x_74); -return x_76; +x_76 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_76, 0, x_75); +x_77 = 0; +x_78 = lean_unsigned_to_nat(0u); +x_79 = l_Lean_Syntax_formatStxAux___main(x_76, x_77, x_78, x_73); +lean_dec(x_76); +return x_79; } } case 2: { -lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_77 = lean_ctor_get(x_1, 0); -lean_inc(x_77); -lean_dec(x_1); -x_78 = lean_ctor_get(x_2, 0); -lean_inc(x_78); -lean_dec(x_2); -x_79 = lean_ctor_get(x_77, 0); -lean_inc(x_79); -x_80 = lean_ctor_get(x_77, 1); +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_80 = lean_ctor_get(x_1, 0); lean_inc(x_80); -x_81 = lean_ctor_get(x_77, 2); +lean_dec(x_1); +x_81 = lean_ctor_get(x_2, 0); lean_inc(x_81); -x_82 = lean_ctor_get(x_77, 3); +lean_dec(x_2); +x_82 = lean_ctor_get(x_80, 0); lean_inc(x_82); -lean_dec(x_77); -x_83 = l_Lean_ppExpr(x_79, x_80, x_81, x_82, x_78); -return x_83; +x_83 = lean_ctor_get(x_80, 1); +lean_inc(x_83); +x_84 = lean_ctor_get(x_80, 2); +lean_inc(x_84); +x_85 = lean_ctor_get(x_80, 3); +lean_inc(x_85); +lean_dec(x_80); +x_86 = l_Lean_ppExpr(x_82, x_83, x_84, x_85, x_81); +return x_86; } case 3: { -lean_object* x_84; lean_object* x_85; +lean_object* x_87; lean_object* x_88; lean_dec(x_1); -x_84 = lean_ctor_get(x_2, 0); -lean_inc(x_84); +x_87 = lean_ctor_get(x_2, 0); +lean_inc(x_87); lean_dec(x_2); -x_85 = l_Lean_Level_format(x_84); -return x_85; +x_88 = l_Lean_Level_format(x_87); +return x_88; } case 4: { -lean_object* x_86; lean_object* x_87; -lean_dec(x_1); -x_86 = lean_ctor_get(x_2, 0); -lean_inc(x_86); -lean_dec(x_2); -x_87 = l_Lean_fmt___at_Lean_Level_LevelToFormat_toResult___main___spec__1(x_86); -return x_87; -} -case 5: -{ -lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; -x_88 = lean_ctor_get(x_1, 0); -lean_inc(x_88); +lean_object* x_89; lean_object* x_90; lean_dec(x_1); x_89 = lean_ctor_get(x_2, 0); lean_inc(x_89); lean_dec(x_2); -x_90 = lean_ctor_get(x_88, 0); -lean_inc(x_90); -x_91 = lean_ctor_get(x_88, 1); +x_90 = l_Lean_fmt___at_Lean_Level_LevelToFormat_toResult___main___spec__1(x_89); +return x_90; +} +case 5: +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_91 = lean_ctor_get(x_1, 0); lean_inc(x_91); -x_92 = lean_ctor_get(x_88, 3); +lean_dec(x_1); +x_92 = lean_ctor_get(x_2, 0); lean_inc(x_92); -lean_dec(x_88); -x_93 = l_Lean_ppGoal(x_90, x_91, x_92, x_89); -return x_93; +lean_dec(x_2); +x_93 = lean_ctor_get(x_91, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_91, 1); +lean_inc(x_94); +x_95 = lean_ctor_get(x_91, 3); +lean_inc(x_95); +lean_dec(x_91); +x_96 = l_Lean_ppGoal(x_93, x_94, x_95, x_92); +return x_96; } case 6: { -uint8_t x_94; -x_94 = !lean_is_exclusive(x_1); -if (x_94 == 0) +uint8_t x_97; +x_97 = !lean_is_exclusive(x_1); +if (x_97 == 0) { -lean_object* x_95; lean_object* x_96; lean_object* x_97; -x_95 = lean_ctor_get(x_1, 0); -lean_dec(x_95); -x_96 = lean_ctor_get(x_2, 0); -lean_inc(x_96); -x_97 = lean_ctor_get(x_2, 1); -lean_inc(x_97); -lean_dec(x_2); -lean_ctor_set(x_1, 0, x_96); -x_2 = x_97; -goto _start; -} -else -{ -lean_object* x_99; lean_object* x_100; lean_object* x_101; -lean_dec(x_1); +lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_98 = lean_ctor_get(x_1, 0); +lean_dec(x_98); x_99 = lean_ctor_get(x_2, 0); lean_inc(x_99); x_100 = lean_ctor_get(x_2, 1); lean_inc(x_100); lean_dec(x_2); -x_101 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_101, 0, x_99); -x_1 = x_101; +lean_ctor_set(x_1, 0, x_99); x_2 = x_100; goto _start; } +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +lean_dec(x_1); +x_102 = lean_ctor_get(x_2, 0); +lean_inc(x_102); +x_103 = lean_ctor_get(x_2, 1); +lean_inc(x_103); +lean_dec(x_2); +x_104 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_104, 0, x_102); +x_1 = x_104; +x_2 = x_103; +goto _start; +} } case 7: { -lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; -x_103 = lean_ctor_get(x_2, 0); -lean_inc(x_103); -x_104 = lean_ctor_get(x_2, 1); -lean_inc(x_104); -lean_dec(x_2); -x_105 = l_Lean_MessageData_formatAux___main(x_1, x_104); -x_106 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_106, 0, x_103); -lean_ctor_set(x_106, 1, x_105); -return x_106; -} -case 8: -{ -lean_object* x_107; lean_object* x_108; lean_object* x_109; -x_107 = lean_ctor_get(x_2, 0); +lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_106 = lean_ctor_get(x_2, 0); +lean_inc(x_106); +x_107 = lean_ctor_get(x_2, 1); lean_inc(x_107); lean_dec(x_2); x_108 = l_Lean_MessageData_formatAux___main(x_1, x_107); -x_109 = lean_format_group(x_108); +x_109 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_109, 0, x_106); +lean_ctor_set(x_109, 1, x_108); return x_109; } +case 8: +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_2, 0); +lean_inc(x_110); +lean_dec(x_2); +x_111 = l_Lean_MessageData_formatAux___main(x_1, x_110); +x_112 = lean_format_group(x_111); +return x_112; +} case 9: { -lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; uint8_t x_114; lean_object* x_115; -x_110 = lean_ctor_get(x_2, 0); -lean_inc(x_110); -x_111 = lean_ctor_get(x_2, 1); -lean_inc(x_111); +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint8_t x_117; lean_object* x_118; +x_113 = lean_ctor_get(x_2, 0); +lean_inc(x_113); +x_114 = lean_ctor_get(x_2, 1); +lean_inc(x_114); lean_dec(x_2); lean_inc(x_1); -x_112 = l_Lean_MessageData_formatAux___main(x_1, x_110); -x_113 = l_Lean_MessageData_formatAux___main(x_1, x_111); -x_114 = 0; -x_115 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_115, 0, x_112); -lean_ctor_set(x_115, 1, x_113); -lean_ctor_set_uint8(x_115, sizeof(void*)*2, x_114); -return x_115; +x_115 = l_Lean_MessageData_formatAux___main(x_1, x_113); +x_116 = l_Lean_MessageData_formatAux___main(x_1, x_114); +x_117 = 0; +x_118 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_118, 0, x_115); +lean_ctor_set(x_118, 1, x_116); +lean_ctor_set_uint8(x_118, sizeof(void*)*2, x_117); +return x_118; } case 10: { -lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; uint8_t x_121; lean_object* x_122; 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_130; lean_object* x_131; lean_object* x_132; -x_116 = lean_ctor_get(x_2, 0); -lean_inc(x_116); -x_117 = lean_ctor_get(x_2, 1); -lean_inc(x_117); +lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; +x_119 = lean_ctor_get(x_2, 0); +lean_inc(x_119); +x_120 = lean_ctor_get(x_2, 1); +lean_inc(x_120); lean_dec(x_2); -x_118 = l_Lean_Name_toString___closed__1; -x_119 = l_Lean_Name_toStringWithSep___main(x_118, x_116); -x_120 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_120, 0, x_119); -x_121 = 0; -x_122 = l_Lean_Format_sbracket___closed__2; -x_123 = lean_alloc_ctor(4, 2, 1); +x_121 = l_Lean_Name_toString___closed__1; +x_122 = l_Lean_Name_toStringWithSep___main(x_121, x_119); +x_123 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_123, 0, x_122); -lean_ctor_set(x_123, 1, x_120); -lean_ctor_set_uint8(x_123, sizeof(void*)*2, x_121); -x_124 = l_Lean_Format_sbracket___closed__3; -x_125 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_125, 0, x_123); -lean_ctor_set(x_125, 1, x_124); -lean_ctor_set_uint8(x_125, sizeof(void*)*2, x_121); -x_126 = l_Lean_Format_sbracket___closed__1; -x_127 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_127, 0, x_126); -lean_ctor_set(x_127, 1, x_125); -x_128 = lean_format_group(x_127); -x_129 = l_Lean_Format_flatten___main___closed__1; -x_130 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_130, 0, x_128); -lean_ctor_set(x_130, 1, x_129); -lean_ctor_set_uint8(x_130, sizeof(void*)*2, x_121); -x_131 = l_Lean_MessageData_formatAux___main(x_1, x_117); -x_132 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_132, 0, x_130); -lean_ctor_set(x_132, 1, x_131); -lean_ctor_set_uint8(x_132, sizeof(void*)*2, x_121); -return x_132; +x_124 = 0; +x_125 = l_Lean_Format_sbracket___closed__2; +x_126 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_126, 0, x_125); +lean_ctor_set(x_126, 1, x_123); +lean_ctor_set_uint8(x_126, sizeof(void*)*2, x_124); +x_127 = l_Lean_Format_sbracket___closed__3; +x_128 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +lean_ctor_set_uint8(x_128, sizeof(void*)*2, x_124); +x_129 = l_Lean_Format_sbracket___closed__1; +x_130 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_128); +x_131 = lean_format_group(x_130); +x_132 = l_Lean_Format_flatten___main___closed__1; +x_133 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_133, 0, x_131); +lean_ctor_set(x_133, 1, x_132); +lean_ctor_set_uint8(x_133, sizeof(void*)*2, x_124); +x_134 = l_Lean_MessageData_formatAux___main(x_1, x_120); +x_135 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_135, 0, x_133); +lean_ctor_set(x_135, 1, x_134); +lean_ctor_set_uint8(x_135, sizeof(void*)*2, x_124); +return x_135; } default: { -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_133 = lean_ctor_get(x_2, 0); -lean_inc(x_133); +lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +x_136 = lean_ctor_get(x_2, 0); +lean_inc(x_136); lean_dec(x_2); -x_134 = lean_unsigned_to_nat(0u); -x_135 = lean_box(0); -x_136 = l_Array_iterateMAux___main___at_Lean_MessageData_formatAux___main___spec__3(x_1, x_133, x_133, x_134, x_135); -lean_dec(x_133); -x_137 = lean_unsigned_to_nat(2u); -x_138 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_138, 0, x_137); -lean_ctor_set(x_138, 1, x_136); -return x_138; +x_137 = lean_unsigned_to_nat(0u); +x_138 = lean_box(0); +x_139 = l_Array_iterateMAux___main___at_Lean_MessageData_formatAux___main___spec__3(x_1, x_136, x_136, x_137, x_138); +lean_dec(x_136); +x_140 = lean_unsigned_to_nat(2u); +x_141 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_141, 0, x_140); +lean_ctor_set(x_141, 1, x_139); +return x_141; } } } @@ -2366,6 +2425,846 @@ lean_dec(x_1); return x_2; } } +lean_object* l_Lean_indentExpr(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = l_Lean_MessageData_ofList___closed__3; +x_3 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +x_4 = lean_unsigned_to_nat(2u); +x_5 = lean_alloc_ctor(7, 2, 0); +lean_ctor_set(x_5, 0, x_4); +lean_ctor_set(x_5, 1, x_3); +return x_5; +} +} +lean_object* l___private_Init_Lean_Message_1__mkCtx(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = l_Lean_MetavarContext_Inhabited___closed__1; +x_6 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set(x_6, 1, x_5); +lean_ctor_set(x_6, 2, x_2); +lean_ctor_set(x_6, 3, x_3); +x_7 = lean_alloc_ctor(6, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_4); +return x_7; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) unknown constant "); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__1; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__2; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) constant has already been declared "); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__4; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__5; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) declaration type mismatch "); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__7; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__8; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__10() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("has type"); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__10; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__11; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__13() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("but it is expected to have type"); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__14() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__13; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__15() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__14; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__16() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) declaration type mismatch"); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__17() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__16; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__18() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__17; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__19() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) declaration has metavariables "); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__20() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__19; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__21() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__20; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__22() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) declaration has free variables "); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__23() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__22; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__24() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__23; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__25() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) function expected"); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__26() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__25; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__27() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__26; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__28() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) type expected"); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__29() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__28; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__30() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__29; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__31() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) let-declaration type mismatch "); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__32() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__31; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__33() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__32; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__34() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) type mismatch at "); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__35() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__34; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__36() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__35; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__37() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("application type mismatch"); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__38() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__37; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__39() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__38; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__40() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("argument has type"); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__41() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__40; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__42() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__41; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__43() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("but function has type"); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__44() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__43; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__45() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__44; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__46() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) invalid projection"); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__47() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__46; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__48() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__47; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__49() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("(kernel) "); +return x_1; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__50() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__49; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* _init_l_Lean_KernelException_toMessageData___closed__51() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_KernelException_toMessageData___closed__50; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* l_Lean_KernelException_toMessageData(lean_object* x_1, lean_object* x_2) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 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; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_1, 1); +lean_inc(x_4); +lean_dec(x_1); +x_5 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_5, 0, x_4); +x_6 = l_Lean_KernelException_toMessageData___closed__3; +x_7 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +x_8 = l_Lean_LocalContext_Inhabited___closed__2; +x_9 = l___private_Init_Lean_Message_1__mkCtx(x_3, x_8, x_2, x_7); +return x_9; +} +case 1: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_10 = lean_ctor_get(x_1, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_1, 1); +lean_inc(x_11); +lean_dec(x_1); +x_12 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_12, 0, x_11); +x_13 = l_Lean_KernelException_toMessageData___closed__6; +x_14 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_12); +x_15 = l_Lean_LocalContext_Inhabited___closed__2; +x_16 = l___private_Init_Lean_Message_1__mkCtx(x_10, x_15, x_2, x_14); +return x_16; +} +case 2: +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_dec(x_2); +x_17 = lean_ctor_get(x_1, 1); +lean_inc(x_17); +x_18 = lean_ctor_get(x_1, 2); +lean_inc(x_18); +lean_dec(x_1); +switch (lean_obj_tag(x_17)) { +case 1: +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_38 = lean_ctor_get(x_17, 0); +lean_inc(x_38); +lean_dec(x_17); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +x_41 = lean_ctor_get(x_39, 2); +lean_inc(x_41); +lean_dec(x_39); +x_19 = x_40; +x_20 = x_41; +goto block_37; +} +case 2: +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_42 = lean_ctor_get(x_17, 0); +lean_inc(x_42); +lean_dec(x_17); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +x_45 = lean_ctor_get(x_43, 2); +lean_inc(x_45); +lean_dec(x_43); +x_19 = x_44; +x_20 = x_45; +goto block_37; +} +default: +{ +lean_object* x_46; +lean_dec(x_18); +lean_dec(x_17); +x_46 = l_Lean_KernelException_toMessageData___closed__18; +return x_46; +} +} +block_37: +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_21 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_21, 0, x_19); +x_22 = l_Lean_KernelException_toMessageData___closed__9; +x_23 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_21); +x_24 = l_Lean_MessageData_ofList___closed__3; +x_25 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = l_Lean_KernelException_toMessageData___closed__12; +x_27 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +x_28 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_28, 0, x_18); +x_29 = l_Lean_indentExpr(x_28); +x_30 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_30, 0, x_27); +lean_ctor_set(x_30, 1, x_29); +x_31 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_24); +x_32 = l_Lean_KernelException_toMessageData___closed__15; +x_33 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +x_34 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_34, 0, x_20); +x_35 = l_Lean_indentExpr(x_34); +x_36 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_36, 0, x_33); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +case 3: +{ +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_1, 1); +lean_inc(x_48); +lean_dec(x_1); +x_49 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_49, 0, x_48); +x_50 = l_Lean_KernelException_toMessageData___closed__21; +x_51 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_49); +x_52 = l_Lean_LocalContext_Inhabited___closed__2; +x_53 = l___private_Init_Lean_Message_1__mkCtx(x_47, x_52, x_2, x_51); +return x_53; +} +case 4: +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_54 = lean_ctor_get(x_1, 0); +lean_inc(x_54); +x_55 = lean_ctor_get(x_1, 1); +lean_inc(x_55); +lean_dec(x_1); +x_56 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_56, 0, x_55); +x_57 = l_Lean_KernelException_toMessageData___closed__24; +x_58 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_56); +x_59 = l_Lean_LocalContext_Inhabited___closed__2; +x_60 = l___private_Init_Lean_Message_1__mkCtx(x_54, x_59, x_2, x_58); +return x_60; +} +case 5: +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_61 = lean_ctor_get(x_1, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_1, 1); +lean_inc(x_62); +x_63 = lean_ctor_get(x_1, 2); +lean_inc(x_63); +lean_dec(x_1); +x_64 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = l_Lean_indentExpr(x_64); +x_66 = l_Lean_KernelException_toMessageData___closed__27; +x_67 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_67, 0, x_66); +lean_ctor_set(x_67, 1, x_65); +x_68 = l___private_Init_Lean_Message_1__mkCtx(x_61, x_62, x_2, x_67); +return x_68; +} +case 6: +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_69 = lean_ctor_get(x_1, 0); +lean_inc(x_69); +x_70 = lean_ctor_get(x_1, 1); +lean_inc(x_70); +x_71 = lean_ctor_get(x_1, 2); +lean_inc(x_71); +lean_dec(x_1); +x_72 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_72, 0, x_71); +x_73 = l_Lean_indentExpr(x_72); +x_74 = l_Lean_KernelException_toMessageData___closed__30; +x_75 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_73); +x_76 = l___private_Init_Lean_Message_1__mkCtx(x_69, x_70, x_2, x_75); +return x_76; +} +case 7: +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_77 = lean_ctor_get(x_1, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_1, 1); +lean_inc(x_78); +x_79 = lean_ctor_get(x_1, 2); +lean_inc(x_79); +lean_dec(x_1); +x_80 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_80, 0, x_79); +x_81 = l_Lean_KernelException_toMessageData___closed__33; +x_82 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_80); +x_83 = l___private_Init_Lean_Message_1__mkCtx(x_77, x_78, x_2, x_82); +return x_83; +} +case 8: +{ +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_object* x_90; lean_object* x_91; +x_84 = lean_ctor_get(x_1, 0); +lean_inc(x_84); +x_85 = lean_ctor_get(x_1, 1); +lean_inc(x_85); +x_86 = lean_ctor_get(x_1, 2); +lean_inc(x_86); +lean_dec(x_1); +x_87 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_87, 0, x_86); +x_88 = l_Lean_indentExpr(x_87); +x_89 = l_Lean_KernelException_toMessageData___closed__36; +x_90 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_88); +x_91 = l___private_Init_Lean_Message_1__mkCtx(x_84, x_85, x_2, x_90); +return x_91; +} +case 9: +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_92 = lean_ctor_get(x_1, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_1, 1); +lean_inc(x_93); +x_94 = lean_ctor_get(x_1, 2); +lean_inc(x_94); +x_95 = lean_ctor_get(x_1, 3); +lean_inc(x_95); +x_96 = lean_ctor_get(x_1, 4); +lean_inc(x_96); +lean_dec(x_1); +x_97 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_97, 0, x_94); +x_98 = l_Lean_indentExpr(x_97); +x_99 = l_Lean_KernelException_toMessageData___closed__39; +x_100 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_100, 0, x_99); +lean_ctor_set(x_100, 1, x_98); +x_101 = l_Lean_KernelException_toMessageData___closed__42; +x_102 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_102, 0, x_100); +lean_ctor_set(x_102, 1, x_101); +x_103 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_103, 0, x_96); +x_104 = l_Lean_indentExpr(x_103); +x_105 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_105, 0, x_102); +lean_ctor_set(x_105, 1, x_104); +x_106 = l_Lean_KernelException_toMessageData___closed__45; +x_107 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_107, 0, x_105); +lean_ctor_set(x_107, 1, x_106); +x_108 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_108, 0, x_95); +x_109 = l_Lean_indentExpr(x_108); +x_110 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_110, 0, x_107); +lean_ctor_set(x_110, 1, x_109); +x_111 = l___private_Init_Lean_Message_1__mkCtx(x_92, x_93, x_2, x_110); +return x_111; +} +case 10: +{ +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_object* x_118; lean_object* x_119; +x_112 = lean_ctor_get(x_1, 0); +lean_inc(x_112); +x_113 = lean_ctor_get(x_1, 1); +lean_inc(x_113); +x_114 = lean_ctor_get(x_1, 2); +lean_inc(x_114); +lean_dec(x_1); +x_115 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_115, 0, x_114); +x_116 = l_Lean_indentExpr(x_115); +x_117 = l_Lean_KernelException_toMessageData___closed__48; +x_118 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_116); +x_119 = l___private_Init_Lean_Message_1__mkCtx(x_112, x_113, x_2, x_118); +return x_119; +} +default: +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_2); +x_120 = lean_ctor_get(x_1, 0); +lean_inc(x_120); +lean_dec(x_1); +x_121 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_121, 0, x_120); +x_122 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_122, 0, x_121); +x_123 = l_Lean_KernelException_toMessageData___closed__51; +x_124 = lean_alloc_ctor(9, 2, 0); +lean_ctor_set(x_124, 0, x_123); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} lean_object* initialize_Init_Data_ToString(lean_object*); lean_object* initialize_Init_Lean_Data_Position(lean_object*); lean_object* initialize_Init_Lean_Syntax(lean_object*); @@ -2466,6 +3365,108 @@ l_Lean_MessageLog_HasAppend___closed__1 = _init_l_Lean_MessageLog_HasAppend___cl lean_mark_persistent(l_Lean_MessageLog_HasAppend___closed__1); l_Lean_MessageLog_HasAppend = _init_l_Lean_MessageLog_HasAppend(); lean_mark_persistent(l_Lean_MessageLog_HasAppend); +l_Lean_KernelException_toMessageData___closed__1 = _init_l_Lean_KernelException_toMessageData___closed__1(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__1); +l_Lean_KernelException_toMessageData___closed__2 = _init_l_Lean_KernelException_toMessageData___closed__2(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__2); +l_Lean_KernelException_toMessageData___closed__3 = _init_l_Lean_KernelException_toMessageData___closed__3(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__3); +l_Lean_KernelException_toMessageData___closed__4 = _init_l_Lean_KernelException_toMessageData___closed__4(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__4); +l_Lean_KernelException_toMessageData___closed__5 = _init_l_Lean_KernelException_toMessageData___closed__5(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__5); +l_Lean_KernelException_toMessageData___closed__6 = _init_l_Lean_KernelException_toMessageData___closed__6(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__6); +l_Lean_KernelException_toMessageData___closed__7 = _init_l_Lean_KernelException_toMessageData___closed__7(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__7); +l_Lean_KernelException_toMessageData___closed__8 = _init_l_Lean_KernelException_toMessageData___closed__8(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__8); +l_Lean_KernelException_toMessageData___closed__9 = _init_l_Lean_KernelException_toMessageData___closed__9(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__9); +l_Lean_KernelException_toMessageData___closed__10 = _init_l_Lean_KernelException_toMessageData___closed__10(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__10); +l_Lean_KernelException_toMessageData___closed__11 = _init_l_Lean_KernelException_toMessageData___closed__11(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__11); +l_Lean_KernelException_toMessageData___closed__12 = _init_l_Lean_KernelException_toMessageData___closed__12(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__12); +l_Lean_KernelException_toMessageData___closed__13 = _init_l_Lean_KernelException_toMessageData___closed__13(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__13); +l_Lean_KernelException_toMessageData___closed__14 = _init_l_Lean_KernelException_toMessageData___closed__14(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__14); +l_Lean_KernelException_toMessageData___closed__15 = _init_l_Lean_KernelException_toMessageData___closed__15(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__15); +l_Lean_KernelException_toMessageData___closed__16 = _init_l_Lean_KernelException_toMessageData___closed__16(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__16); +l_Lean_KernelException_toMessageData___closed__17 = _init_l_Lean_KernelException_toMessageData___closed__17(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__17); +l_Lean_KernelException_toMessageData___closed__18 = _init_l_Lean_KernelException_toMessageData___closed__18(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__18); +l_Lean_KernelException_toMessageData___closed__19 = _init_l_Lean_KernelException_toMessageData___closed__19(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__19); +l_Lean_KernelException_toMessageData___closed__20 = _init_l_Lean_KernelException_toMessageData___closed__20(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__20); +l_Lean_KernelException_toMessageData___closed__21 = _init_l_Lean_KernelException_toMessageData___closed__21(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__21); +l_Lean_KernelException_toMessageData___closed__22 = _init_l_Lean_KernelException_toMessageData___closed__22(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__22); +l_Lean_KernelException_toMessageData___closed__23 = _init_l_Lean_KernelException_toMessageData___closed__23(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__23); +l_Lean_KernelException_toMessageData___closed__24 = _init_l_Lean_KernelException_toMessageData___closed__24(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__24); +l_Lean_KernelException_toMessageData___closed__25 = _init_l_Lean_KernelException_toMessageData___closed__25(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__25); +l_Lean_KernelException_toMessageData___closed__26 = _init_l_Lean_KernelException_toMessageData___closed__26(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__26); +l_Lean_KernelException_toMessageData___closed__27 = _init_l_Lean_KernelException_toMessageData___closed__27(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__27); +l_Lean_KernelException_toMessageData___closed__28 = _init_l_Lean_KernelException_toMessageData___closed__28(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__28); +l_Lean_KernelException_toMessageData___closed__29 = _init_l_Lean_KernelException_toMessageData___closed__29(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__29); +l_Lean_KernelException_toMessageData___closed__30 = _init_l_Lean_KernelException_toMessageData___closed__30(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__30); +l_Lean_KernelException_toMessageData___closed__31 = _init_l_Lean_KernelException_toMessageData___closed__31(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__31); +l_Lean_KernelException_toMessageData___closed__32 = _init_l_Lean_KernelException_toMessageData___closed__32(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__32); +l_Lean_KernelException_toMessageData___closed__33 = _init_l_Lean_KernelException_toMessageData___closed__33(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__33); +l_Lean_KernelException_toMessageData___closed__34 = _init_l_Lean_KernelException_toMessageData___closed__34(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__34); +l_Lean_KernelException_toMessageData___closed__35 = _init_l_Lean_KernelException_toMessageData___closed__35(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__35); +l_Lean_KernelException_toMessageData___closed__36 = _init_l_Lean_KernelException_toMessageData___closed__36(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__36); +l_Lean_KernelException_toMessageData___closed__37 = _init_l_Lean_KernelException_toMessageData___closed__37(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__37); +l_Lean_KernelException_toMessageData___closed__38 = _init_l_Lean_KernelException_toMessageData___closed__38(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__38); +l_Lean_KernelException_toMessageData___closed__39 = _init_l_Lean_KernelException_toMessageData___closed__39(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__39); +l_Lean_KernelException_toMessageData___closed__40 = _init_l_Lean_KernelException_toMessageData___closed__40(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__40); +l_Lean_KernelException_toMessageData___closed__41 = _init_l_Lean_KernelException_toMessageData___closed__41(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__41); +l_Lean_KernelException_toMessageData___closed__42 = _init_l_Lean_KernelException_toMessageData___closed__42(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__42); +l_Lean_KernelException_toMessageData___closed__43 = _init_l_Lean_KernelException_toMessageData___closed__43(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__43); +l_Lean_KernelException_toMessageData___closed__44 = _init_l_Lean_KernelException_toMessageData___closed__44(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__44); +l_Lean_KernelException_toMessageData___closed__45 = _init_l_Lean_KernelException_toMessageData___closed__45(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__45); +l_Lean_KernelException_toMessageData___closed__46 = _init_l_Lean_KernelException_toMessageData___closed__46(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__46); +l_Lean_KernelException_toMessageData___closed__47 = _init_l_Lean_KernelException_toMessageData___closed__47(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__47); +l_Lean_KernelException_toMessageData___closed__48 = _init_l_Lean_KernelException_toMessageData___closed__48(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__48); +l_Lean_KernelException_toMessageData___closed__49 = _init_l_Lean_KernelException_toMessageData___closed__49(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__49); +l_Lean_KernelException_toMessageData___closed__50 = _init_l_Lean_KernelException_toMessageData___closed__50(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__50); +l_Lean_KernelException_toMessageData___closed__51 = _init_l_Lean_KernelException_toMessageData___closed__51(); +lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__51); return lean_mk_io_result(lean_box(0)); } #ifdef __cplusplus diff --git a/stage0/stdlib/Init/Lean/Meta/Basic.c b/stage0/stdlib/Init/Lean/Meta/Basic.c index 54426bdd5d..b76002b30d 100644 --- a/stage0/stdlib/Init/Lean/Meta/Basic.c +++ b/stage0/stdlib/Init/Lean/Meta/Basic.c @@ -1,6 +1,6 @@ // Lean compiler output // Module: Init.Lean.Meta.Basic -// Imports: Init.Control.Reader Init.Lean.Data.LOption Init.Lean.Environment Init.Lean.Class Init.Lean.ReducibilityAttrs Init.Lean.Util.Trace Init.Lean.Util.RecDepth Init.Lean.Meta.Exception Init.Lean.Meta.DiscrTreeTypes Init.Lean.Eval +// Imports: Init.Control.Reader Init.Lean.Data.LOption Init.Lean.Environment Init.Lean.Class Init.Lean.ReducibilityAttrs Init.Lean.Util.Trace Init.Lean.Util.RecDepth Init.Lean.Util.Closure Init.Lean.Meta.Exception Init.Lean.Meta.DiscrTreeTypes Init.Lean.Eval #include "runtime/lean.h" #if defined(__clang__) #pragma clang diagnostic ignored "-Wunused-parameter" @@ -24,6 +24,7 @@ lean_object* l_Lean_Meta_withLocalDecl(lean_object*); lean_object* l_Lean_Meta_withNewLocalInstances___main___at_Lean_Meta_isClassExpensive___main___spec__5___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_mkFreshLevelMVar(lean_object*); lean_object* l_Lean_Meta_mkFreshId___boxed(lean_object*); +lean_object* l_Lean_Meta_setEnv___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*); lean_object* l_Lean_Meta_withLetDecl(lean_object*); lean_object* l_Lean_Meta_MetaExtState_inhabited___closed__2; @@ -120,6 +121,7 @@ lean_object* l_Lean_Meta_isReadOnlyLevelMVar___boxed(lean_object*, lean_object*, lean_object* l___private_Init_Lean_Meta_Basic_6__lambdaTelescopeAux(lean_object*); lean_object* l___private_Init_Lean_Meta_Basic_9__withNewFVar___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Lean_isReducible(lean_object*, lean_object*); +lean_object* l_Lean_Meta_mkAuxDefinitionFor(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_InfoCacheKey_Hashable___boxed(lean_object*); lean_object* l_Lean_Meta_getConstNoEx(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_withMVarContext(lean_object*); @@ -131,6 +133,7 @@ lean_object* l_Lean_Meta_withLocalDeclD(lean_object*); lean_object* l_Lean_Meta_withNewLocalInstances___main___at_Lean_Meta_forallBoundedTelescope___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_getConst___boxed(lean_object*, lean_object*, lean_object*); lean_object* lean_nat_add(lean_object*, lean_object*); +lean_object* l_Lean_Meta_mkAuxDefinition(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_withTransparency___rarg(uint8_t, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_forallTelescopeReducing(lean_object*); lean_object* l_Lean_Meta_MetaM_inhabited___rarg(lean_object*); @@ -146,6 +149,7 @@ lean_object* l_Lean_Meta_isClass(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_withNewLocalInstances___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_withNewLocalInstance___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_run___rarg___closed__5; +lean_object* l_Lean_mkAuxDefinition(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_throwEx___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_dbgTrace___rarg___closed__1; lean_object* l_Lean_Meta_mkMetaExtension(lean_object*); @@ -178,6 +182,7 @@ lean_object* l_Lean_Meta_withMCtx___rarg(lean_object*, lean_object*, lean_object lean_object* l_Lean_Meta_isClassQuickConst___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_getConstNoEx___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_withNewMCtxDepth___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Expr_headBeta(lean_object*); lean_object* l___private_Init_Lean_Meta_Basic_5__forallTelescopeReducingAux___at_Lean_Meta_isClassExpensive___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_mkMetaExtension___closed__2; lean_object* l_Lean_Meta_mkMetaExtension___closed__1; @@ -350,6 +355,7 @@ lean_object* l_Lean_Meta_withReducible___rarg(lean_object*, lean_object*, lean_o lean_object* l_Lean_Meta_isExprMVarAssigned(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_tracer___lambda__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_mkFreshExprMVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Meta_setEnv(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_isReducible(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_Basic_4__forallTelescopeReducingAuxAux___main___at_Lean_Meta_forallTelescopeReducing___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_registerEnvExtensionUnsafe___rarg___closed__2; @@ -883,7 +889,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l_Lean_maxRecDepthErrorMessage; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } @@ -1106,6 +1112,61 @@ lean_dec(x_1); return x_2; } } +lean_object* l_Lean_Meta_setEnv(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_3, 0); +lean_dec(x_5); +lean_ctor_set(x_3, 0, x_1); +x_6 = lean_box(0); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +return x_7; +} +else +{ +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_8 = lean_ctor_get(x_3, 1); +x_9 = lean_ctor_get(x_3, 2); +x_10 = lean_ctor_get(x_3, 3); +x_11 = lean_ctor_get(x_3, 4); +x_12 = lean_ctor_get(x_3, 5); +lean_inc(x_12); +lean_inc(x_11); +lean_inc(x_10); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_3); +x_13 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_13, 0, x_1); +lean_ctor_set(x_13, 1, x_8); +lean_ctor_set(x_13, 2, x_9); +lean_ctor_set(x_13, 3, x_10); +lean_ctor_set(x_13, 4, x_11); +lean_ctor_set(x_13, 5, x_12); +x_14 = lean_box(0); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_13); +return x_15; +} +} +} +lean_object* l_Lean_Meta_setEnv___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Meta_setEnv(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} lean_object* _init_l_Lean_Meta_mkWHNFRef___lambda__1___closed__1() { _start: { @@ -1119,7 +1180,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l_Lean_Meta_mkWHNFRef___lambda__1___closed__1; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } @@ -1175,7 +1236,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l_Lean_Meta_mkInferTypeRef___lambda__1___closed__1; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } @@ -1231,7 +1292,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l_Lean_Meta_mkIsExprDefEqAuxRef___lambda__1___closed__1; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } @@ -2847,7 +2908,7 @@ lean_ctor_set(x_9, 0, x_4); lean_ctor_set(x_9, 1, x_5); lean_ctor_set(x_9, 2, x_6); lean_ctor_set(x_9, 3, x_8); -x_10 = lean_alloc_ctor(19, 2, 0); +x_10 = lean_alloc_ctor(20, 2, 0); lean_ctor_set(x_10, 0, x_1); lean_ctor_set(x_10, 1, x_9); x_11 = lean_alloc_ctor(1, 2, 0); @@ -49764,6 +49825,158 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Meta_withMCtx___rarg), 4, 0); return x_2; } } +lean_object* l_Lean_Meta_mkAuxDefinition(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +x_8 = lean_ctor_get(x_5, 2); +lean_inc(x_8); +x_9 = lean_ctor_get(x_5, 3); +lean_inc(x_9); +x_10 = lean_ctor_get(x_5, 4); +lean_inc(x_10); +x_11 = lean_ctor_get(x_5, 5); +lean_inc(x_11); +x_12 = lean_ctor_get(x_4, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +lean_dec(x_12); +x_14 = lean_ctor_get(x_4, 1); +lean_inc(x_14); +lean_dec(x_4); +lean_inc(x_7); +x_15 = l_Lean_mkAuxDefinition(x_6, x_13, x_7, x_14, x_1, x_2, x_3); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +lean_dec(x_15); +x_17 = lean_alloc_ctor(19, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_13); +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_5); +return x_18; +} +else +{ +uint8_t x_19; +lean_dec(x_13); +x_19 = !lean_is_exclusive(x_5); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_20 = lean_ctor_get(x_5, 5); +lean_dec(x_20); +x_21 = lean_ctor_get(x_5, 4); +lean_dec(x_21); +x_22 = lean_ctor_get(x_5, 3); +lean_dec(x_22); +x_23 = lean_ctor_get(x_5, 2); +lean_dec(x_23); +x_24 = lean_ctor_get(x_5, 1); +lean_dec(x_24); +x_25 = lean_ctor_get(x_5, 0); +lean_dec(x_25); +x_26 = lean_ctor_get(x_15, 0); +lean_inc(x_26); +lean_dec(x_15); +x_27 = lean_ctor_get(x_26, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_26, 1); +lean_inc(x_28); +lean_dec(x_26); +lean_ctor_set(x_5, 0, x_28); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_5); +return x_29; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_5); +x_30 = lean_ctor_get(x_15, 0); +lean_inc(x_30); +lean_dec(x_15); +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_7); +lean_ctor_set(x_33, 2, x_8); +lean_ctor_set(x_33, 3, x_9); +lean_ctor_set(x_33, 4, x_10); +lean_ctor_set(x_33, 5, x_11); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_31); +lean_ctor_set(x_34, 1, x_33); +return x_34; +} +} +} +} +lean_object* l_Lean_Meta_mkAuxDefinitionFor(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +lean_inc(x_3); +lean_inc(x_2); +x_5 = l_Lean_Meta_inferType(x_2, x_3, x_4); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +lean_dec(x_5); +x_8 = l_Lean_Expr_headBeta(x_6); +x_9 = l_Lean_Meta_mkAuxDefinition(x_1, x_8, x_2, x_3, x_7); +return x_9; +} +else +{ +uint8_t x_10; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_10 = !lean_is_exclusive(x_5); +if (x_10 == 0) +{ +return x_5; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_5, 0); +x_12 = lean_ctor_get(x_5, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_5); +x_13 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_12); +return x_13; +} +} +} +} lean_object* _init_l___private_Init_Lean_Meta_Basic_10__regTraceClasses___closed__1() { _start: { @@ -50094,6 +50307,7 @@ lean_object* initialize_Init_Lean_Class(lean_object*); lean_object* initialize_Init_Lean_ReducibilityAttrs(lean_object*); lean_object* initialize_Init_Lean_Util_Trace(lean_object*); lean_object* initialize_Init_Lean_Util_RecDepth(lean_object*); +lean_object* initialize_Init_Lean_Util_Closure(lean_object*); lean_object* initialize_Init_Lean_Meta_Exception(lean_object*); lean_object* initialize_Init_Lean_Meta_DiscrTreeTypes(lean_object*); lean_object* initialize_Init_Lean_Eval(lean_object*); @@ -50123,6 +50337,9 @@ lean_dec_ref(res); res = initialize_Init_Lean_Util_RecDepth(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); +res = initialize_Init_Lean_Util_Closure(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); res = initialize_Init_Lean_Meta_Exception(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); diff --git a/stage0/stdlib/Init/Lean/Meta/Exception.c b/stage0/stdlib/Init/Lean/Meta/Exception.c index e213d6192a..0aee8febf6 100644 --- a/stage0/stdlib/Init/Lean/Meta/Exception.c +++ b/stage0/stdlib/Init/Lean/Meta/Exception.c @@ -53,6 +53,7 @@ lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__62; lean_object* l_Lean_Meta_Exception_toStr___closed__2; lean_object* l_Lean_Meta_Exception_Inhabited; lean_object* l_Lean_Meta_Exception_toStr___closed__12; +extern lean_object* l_Lean_KernelException_toMessageData___closed__37; lean_object* l_Lean_Meta_Exception_HasToString; lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__68; lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__73; @@ -61,6 +62,7 @@ lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__10; lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__20; lean_object* l_Lean_mkProj(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__57; +lean_object* l_Lean_KernelException_toMessageData(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__17; lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__43; lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__79; @@ -155,7 +157,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l_String_splitAux___main___closed__1; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } @@ -366,7 +368,7 @@ lean_object* _init_l_Lean_Meta_Exception_toStr___closed__15() { _start: { lean_object* x_1; -x_1 = lean_mk_string("application type mismatch"); +x_1 = lean_mk_string("type class instance expected"); return x_1; } } @@ -374,7 +376,7 @@ lean_object* _init_l_Lean_Meta_Exception_toStr___closed__16() { _start: { lean_object* x_1; -x_1 = lean_mk_string("type class instance expected"); +x_1 = lean_mk_string("application builder failure"); return x_1; } } @@ -382,7 +384,7 @@ lean_object* _init_l_Lean_Meta_Exception_toStr___closed__17() { _start: { lean_object* x_1; -x_1 = lean_mk_string("application builder failure"); +x_1 = lean_mk_string("type class instance synthesis failed"); return x_1; } } @@ -390,7 +392,7 @@ lean_object* _init_l_Lean_Meta_Exception_toStr___closed__18() { _start: { lean_object* x_1; -x_1 = lean_mk_string("type class instance synthesis failed"); +x_1 = lean_mk_string("tactic '"); return x_1; } } @@ -398,7 +400,7 @@ lean_object* _init_l_Lean_Meta_Exception_toStr___closed__19() { _start: { lean_object* x_1; -x_1 = lean_mk_string("tactic '"); +x_1 = lean_mk_string("' failed"); return x_1; } } @@ -406,7 +408,7 @@ lean_object* _init_l_Lean_Meta_Exception_toStr___closed__20() { _start: { lean_object* x_1; -x_1 = lean_mk_string("' failed"); +x_1 = lean_mk_string("kernel exception"); return x_1; } } @@ -560,28 +562,28 @@ case 14: { lean_object* x_50; lean_dec(x_1); -x_50 = l_Lean_Meta_Exception_toStr___closed__15; +x_50 = l_Lean_KernelException_toMessageData___closed__37; return x_50; } case 15: { lean_object* x_51; lean_dec(x_1); -x_51 = l_Lean_Meta_Exception_toStr___closed__16; +x_51 = l_Lean_Meta_Exception_toStr___closed__15; return x_51; } case 16: { lean_object* x_52; lean_dec(x_1); -x_52 = l_Lean_Meta_Exception_toStr___closed__17; +x_52 = l_Lean_Meta_Exception_toStr___closed__16; return x_52; } case 17: { lean_object* x_53; lean_dec(x_1); -x_53 = l_Lean_Meta_Exception_toStr___closed__18; +x_53 = l_Lean_Meta_Exception_toStr___closed__17; return x_53; } case 18: @@ -592,10 +594,10 @@ lean_inc(x_54); lean_dec(x_1); x_55 = l_Lean_Name_toString___closed__1; x_56 = l_Lean_Name_toStringWithSep___main(x_55, x_54); -x_57 = l_Lean_Meta_Exception_toStr___closed__19; +x_57 = l_Lean_Meta_Exception_toStr___closed__18; x_58 = lean_string_append(x_57, x_56); lean_dec(x_56); -x_59 = l_Lean_Meta_Exception_toStr___closed__20; +x_59 = l_Lean_Meta_Exception_toStr___closed__19; x_60 = lean_string_append(x_58, x_59); return x_60; } @@ -603,23 +605,30 @@ case 19: { lean_object* x_61; lean_dec(x_1); -x_61 = l_Lean_Meta_Exception_toStr___closed__21; +x_61 = l_Lean_Meta_Exception_toStr___closed__20; return x_61; } case 20: { lean_object* x_62; -x_62 = lean_ctor_get(x_1, 0); -lean_inc(x_62); lean_dec(x_1); +x_62 = l_Lean_Meta_Exception_toStr___closed__21; return x_62; } +case 21: +{ +lean_object* x_63; +x_63 = lean_ctor_get(x_1, 0); +lean_inc(x_63); +lean_dec(x_1); +return x_63; +} default: { -lean_object* x_63; +lean_object* x_64; lean_dec(x_1); -x_63 = l_Lean_Meta_Exception_toStr___closed__13; -return x_63; +x_64 = l_Lean_Meta_Exception_toStr___closed__13; +return x_64; } } } @@ -1904,22 +1913,33 @@ return x_150; } case 19: { -lean_object* x_151; +lean_object* x_151; lean_object* x_152; lean_object* x_153; +x_151 = lean_ctor_get(x_1, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_1, 1); +lean_inc(x_152); lean_dec(x_1); -x_151 = l_Lean_Meta_Exception_toTraceMessageData___closed__82; -return x_151; +x_153 = l_Lean_KernelException_toMessageData(x_151, x_152); +return x_153; +} +case 20: +{ +lean_object* x_154; +lean_dec(x_1); +x_154 = l_Lean_Meta_Exception_toTraceMessageData___closed__82; +return x_154; } default: { -lean_object* x_152; lean_object* x_153; lean_object* x_154; -x_152 = lean_ctor_get(x_1, 0); -lean_inc(x_152); +lean_object* x_155; lean_object* x_156; lean_object* x_157; +x_155 = lean_ctor_get(x_1, 0); +lean_inc(x_155); lean_dec(x_1); -x_153 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_153, 0, x_152); -x_154 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_154, 0, x_153); -return x_154; +x_156 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_156, 0, x_155); +x_157 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_157, 0, x_156); +return x_157; } } } diff --git a/stage0/stdlib/Init/Lean/Meta/ExprDefEq.c b/stage0/stdlib/Init/Lean/Meta/ExprDefEq.c index e7c1a1858d..7ba9d55c3b 100644 --- a/stage0/stdlib/Init/Lean/Meta/ExprDefEq.c +++ b/stage0/stdlib/Init/Lean/Meta/ExprDefEq.c @@ -25,10 +25,11 @@ uint8_t l_Array_anyRangeMAux___main___at_Lean_Meta_CheckAssignmentQuick_check___ lean_object* l_Lean_Expr_mvarId_x21(lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__2; lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*); +lean_object* l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(lean_object*, lean_object*); lean_object* l_Array_anyRangeMAux___main___at___private_Init_Lean_Meta_ExprDefEq_5__isDefEqArgs___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_25__isDefEqLeftRight___closed__2; lean_object* l___private_Init_Lean_Meta_ExprDefEq_11__visit(lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_WHNF_toCtorIfLit___closed__7; +lean_object* l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_CheckAssignment_Lean_MonadCache___closed__2; lean_object* l_Lean_Meta_withNewLocalInstances___main___at_Lean_Meta_CheckAssignment_assignToConstFun___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__1; @@ -37,10 +38,7 @@ lean_object* l_unreachable_x21___rarg(lean_object*); lean_object* l_Lean_Meta_isClassExpensive___main(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_27__unfold(lean_object*); lean_object* l___private_Init_Lean_Meta_Basic_4__forallTelescopeReducingAuxAux___main___at_Lean_Meta_CheckAssignment_assignToConstFun___spec__2(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_HashMapImp_find_x3f___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__1___boxed(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_16__simpAssignmentArgAux(lean_object*, lean_object*, lean_object*); -lean_object* l_HashMapImp_find_x3f___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__1(lean_object*, lean_object*); -lean_object* lean_array_uget(lean_object*, size_t); lean_object* l_Lean_Meta_isDefEqStringLit(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Meta_CheckAssignment_check___main___spec__5(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_setIsExprDefEqAuxRef(lean_object*); @@ -56,10 +54,8 @@ uint8_t lean_name_eq(lean_object*, lean_object*); lean_object* l_Lean_Meta_withNewLocalInstances___main___at_Lean_Meta_CheckAssignment_assignToConstFun___spec__4___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_32__unfoldReducibeDefEq(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__4; -lean_object* l_Lean_Meta_checkAssignmentAux___closed__1; extern lean_object* l_Lean_Expr_updateMData_x21___closed__2; lean_object* l_Lean_Meta_checkAssignmentAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* lean_array_uset(lean_object*, size_t, lean_object*); lean_object* l_Array_back___at___private_Init_Lean_Meta_ExprDefEq_14__processAssignmentFOApproxAux___spec__1___boxed(lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_10__cache___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_CheckAssignment_checkFVar(lean_object*, lean_object*, lean_object*, lean_object*); @@ -81,6 +77,7 @@ lean_object* l___private_Init_Lean_Meta_ExprDefEq_6__isDefEqBindingAux___boxed(l lean_object* l___private_Init_Lean_Meta_ExprDefEq_15__processAssignmentFOApprox___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MessageData_arrayExpr_toMessageData___main(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_withNewLocalInstances___main___at_Lean_Meta_CheckAssignment_assignToConstFun___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Substring_HasQuote___closed__2; lean_object* l_Lean_Meta_CheckAssignment_checkFVar___at_Lean_Meta_CheckAssignment_check___main___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_CheckAssignment_Lean_MonadCache; uint8_t l_Array_anyRangeMAux___main___at___private_Init_Lean_Meta_ExprDefEq_19__processAssignmentAux___main___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -148,7 +145,6 @@ lean_object* l___private_Init_Lean_Meta_ExprDefEq_2__isDefEqArgsFirstPass___main lean_object* l___private_Init_Lean_Meta_ExprDefEq_23__isDefEqLeft___closed__1; lean_object* lean_expr_instantiate_rev_range(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t lean_nat_dec_eq(lean_object*, lean_object*); -lean_object* l_AssocList_find_x3f___main___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__2(lean_object*, lean_object*); lean_object* l_Array_anyRangeMAux___main___at___private_Init_Lean_Meta_ExprDefEq_19__processAssignmentAux___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_isDefEqBindingDomain(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_withNewLocalInstances___main___at_Lean_Meta_CheckAssignment_assignToConstFun___spec__4(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -197,28 +193,25 @@ lean_object* l___private_Init_Lean_Meta_ExprDefEq_33__unfoldNonProjFnDefEq(lean_ lean_object* l___private_Init_Lean_Meta_ExprDefEq_15__processAssignmentFOApprox___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_anyRangeMAux___main___at_Lean_Meta_CheckAssignment_check___main___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_Basic_4__forallTelescopeReducingAuxAux___main___at_Lean_Meta_CheckAssignment_assignToConstFun___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -size_t l_Lean_Expr_hash(lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__3; lean_object* lean_name_mk_string(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_30__unfoldComparingHeadsDefEq(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_CheckAssignment_checkMVar___at_Lean_Meta_CheckAssignment_check___main___spec__4(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_23__isDefEqLeft___closed__3; -lean_object* l_mkHashMap___at_Lean_Meta_checkAssignmentAux___spec__1(lean_object*); extern lean_object* l_PersistentArray_empty___closed__3; lean_object* l_Lean_Meta_CheckAssignment_checkMVar(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_CheckAssignment_mkAuxMVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_isEtaUnassignedMVar___boxed(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_43__isDefEqWHNF___at_Lean_Meta_isExprDefEqAuxImpl___spec__2(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MetavarContext_assignExpr(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Meta_isDefEqStringLit___closed__1; extern lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__4; lean_object* l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__5; -lean_object* l_HashMapImp_expand___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__3(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_7__isDefEqBinding(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_6__isDefEqBindingAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_commitWhen___at___private_Init_Lean_Meta_ExprDefEq_15__processAssignmentFOApprox___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Lean_Meta_TransparencyMode_beq(uint8_t, uint8_t); lean_object* l_Lean_Meta_commitWhen___at_Lean_Meta_isExprDefEqAuxImpl___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -size_t lean_usize_modn(size_t, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_37__isSynthetic(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_40__isLetFVar(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_6__isDefEqBindingAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -229,13 +222,10 @@ lean_object* l_Lean_Meta_mkFreshId___rarg(lean_object*); lean_object* l_Lean_Meta_whenUndefDo(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_withNewLocalInstances___main___at_Lean_Meta_CheckAssignment_assignToConstFun___spec__4___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_checkAssignment(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_mkHashMapImp___rarg(lean_object*); lean_object* l___private_Init_Lean_Expr_3__getAppArgsAux___main(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_isDefEqBindingDomain___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_expr_update_let(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Lean_Expr_isForall(lean_object*); -lean_object* l_AssocList_contains___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__2___boxed(lean_object*, lean_object*); -lean_object* l_AssocList_foldlM___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__5(lean_object*, lean_object*); lean_object* l_Lean_Meta_whnf(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_43__isDefEqWHNF(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__10; @@ -265,11 +255,9 @@ lean_object* l_Lean_Meta_isListLevelDefEqAux___main(lean_object*, lean_object*, uint8_t l_Array_anyRangeMAux___main___at_Lean_Meta_CheckAssignmentQuick_check___main___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_12__checkAssignmentFailure___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_LocalDecl_type(lean_object*); -uint8_t l_AssocList_contains___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__2(lean_object*, lean_object*); lean_object* l_Lean_LocalDecl_value_x3f(lean_object*); lean_object* lean_local_ctx_mk_local_decl(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); lean_object* l___private_Init_Lean_Meta_ExprDefEq_38__isAssignable(lean_object*, lean_object*, lean_object*); -lean_object* l_AssocList_replace___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__6(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_assignExprMVar(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_anyRangeMAux___main___at_Lean_Meta_CheckAssignmentQuick_check___main___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_15__processAssignmentFOApprox___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -283,7 +271,6 @@ lean_object* l_Lean_Meta_getLocalDecl(lean_object*, lean_object*, lean_object*); uint8_t lean_expr_eqv(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_12__checkAssignmentFailure___closed__5; uint8_t l_Lean_Expr_isMVar(lean_object*); -uint8_t lean_expr_equal(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_44__unstuckMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_withNewLocalInstances___main___at___private_Init_Lean_Meta_ExprDefEq_18__processConstApprox___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_getStuckMVar_x3f___main___at_Lean_Meta_getStuckMVar_x3f___spec__1(lean_object*, lean_object*, lean_object*); @@ -312,14 +299,12 @@ lean_object* l___private_Init_Lean_Meta_ExprDefEq_36__isDelayedAssignedHead___bo lean_object* l_Array_anyRangeMAux___main___at_Lean_Meta_CheckAssignment_check___main___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Meta_isExprDefEqAuxRef; lean_object* l___private_Init_Lean_Meta_ExprDefEq_2__isDefEqArgsFirstPass___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_HashMapImp_insert___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_CheckAssignmentQuick_check___main(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_CheckAssignment_liftMetaM(lean_object*); lean_object* l_Lean_Meta_commitWhen___at___private_Init_Lean_Meta_ExprDefEq_41__isDefEqQuick___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_CheckAssignment_check___main(lean_object*, lean_object*, lean_object*); uint8_t l___private_Init_Lean_Meta_ExprDefEq_29__sameHeadSymbol(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_41__isDefEqQuick___main___closed__2; -lean_object* lean_nat_mul(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_2__isDefEqArgsFirstPass___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_getFunInfoNArgs(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_metavar_ctx_find_decl(lean_object*, lean_object*); @@ -336,13 +321,13 @@ lean_object* l___private_Init_Lean_Meta_ExprDefEq_19__processAssignmentAux(lean_ lean_object* lean_expr_instantiate_rev(lean_object*, lean_object*); uint8_t l_Lean_Meta_TransparencyMode_lt(uint8_t, uint8_t); lean_object* l___private_Init_Lean_Meta_ExprDefEq_24__isDefEqRight(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_prodToExpr___rarg___lambda__1___closed__3; lean_object* l_Lean_Meta_isDelayedAssigned(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_25__isDefEqLeftRight(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Lean_Expr_hasLooseBVars(lean_object*); lean_object* l___private_Init_Lean_Meta_ExprDefEq_3__isDefEqArgsAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_mkLambda(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_getMVarDecl(lean_object*, lean_object*, lean_object*); -lean_object* l_HashMapImp_moveEntries___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__4(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Expr_Inhabited; uint8_t l_Lean_Expr_isStringLit(lean_object*); lean_object* l_Lean_Meta_instantiateMVars(lean_object*, lean_object*, lean_object*); @@ -381,8 +366,8 @@ lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_isDefEqBindingDomain___main___at___private_Init_Lean_Meta_ExprDefEq_6__isDefEqBindingAux___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_local_ctx_find(lean_object*, lean_object*); -lean_object* l_AssocList_find_x3f___main___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__2___boxed(lean_object*, lean_object*); lean_object* l_Lean_Meta_commitWhen___at___private_Init_Lean_Meta_ExprDefEq_1__isDefEqEta___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, uint64_t, lean_object*, lean_object*); +extern lean_object* l_HashMap_Inhabited___closed__1; lean_object* l_Lean_Meta_CheckAssignmentQuick_check___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_isProp(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Expr_HasBeq; @@ -1667,6 +1652,16 @@ return x_97; } } } +lean_object* _init_l_Lean_Meta_isDefEqStringLit___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Substring_HasQuote___closed__2; +x_2 = l_Lean_prodToExpr___rarg___lambda__1___closed__3; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} lean_object* l_Lean_Meta_isDefEqStringLit(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { @@ -1675,7 +1670,7 @@ x_5 = l_Lean_Expr_isStringLit(x_1); if (x_5 == 0) { lean_object* x_6; uint8_t x_7; -x_6 = l_Lean_WHNF_toCtorIfLit___closed__7; +x_6 = l_Lean_Meta_isDefEqStringLit___closed__1; x_7 = l_Lean_Expr_isAppOf(x_1, x_6); if (x_7 == 0) { @@ -1773,7 +1768,7 @@ return x_31; else { lean_object* x_32; uint8_t x_33; -x_32 = l_Lean_WHNF_toCtorIfLit___closed__7; +x_32 = l_Lean_Meta_isDefEqStringLit___closed__1; x_33 = l_Lean_Expr_isAppOf(x_2, x_32); if (x_33 == 0) { @@ -8922,60 +8917,13 @@ return x_496; } } } -lean_object* l_AssocList_find_x3f___main___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__2(lean_object* x_1, lean_object* x_2) { -_start: -{ -if (lean_obj_tag(x_2) == 0) -{ -lean_object* x_3; -x_3 = lean_box(0); -return x_3; -} -else -{ -lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; -x_4 = lean_ctor_get(x_2, 0); -x_5 = lean_ctor_get(x_2, 1); -x_6 = lean_ctor_get(x_2, 2); -x_7 = lean_expr_equal(x_4, x_1); -if (x_7 == 0) -{ -x_2 = x_6; -goto _start; -} -else -{ -lean_object* x_9; -lean_inc(x_5); -x_9 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_9, 0, x_5); -return x_9; -} -} -} -} -lean_object* l_HashMapImp_find_x3f___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__1(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; lean_object* x_4; size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_8; -x_3 = lean_ctor_get(x_1, 1); -x_4 = lean_array_get_size(x_3); -x_5 = l_Lean_Expr_hash(x_2); -x_6 = lean_usize_modn(x_5, x_4); -lean_dec(x_4); -x_7 = lean_array_uget(x_3, x_6); -x_8 = l_AssocList_find_x3f___main___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__2(x_2, x_7); -lean_dec(x_7); -return x_8; -} -} lean_object* l___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { lean_object* x_4; lean_object* x_5; lean_object* x_6; x_4 = lean_ctor_get(x_3, 1); lean_inc(x_4); -x_5 = l_HashMapImp_find_x3f___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__1(x_4, x_1); +x_5 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_4, x_1); lean_dec(x_4); x_6 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_6, 0, x_5); @@ -8983,26 +8931,6 @@ lean_ctor_set(x_6, 1, x_3); return x_6; } } -lean_object* l_AssocList_find_x3f___main___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__2___boxed(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; -x_3 = l_AssocList_find_x3f___main___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__2(x_1, x_2); -lean_dec(x_2); -lean_dec(x_1); -return x_3; -} -} -lean_object* l_HashMapImp_find_x3f___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; -x_3 = l_HashMapImp_find_x3f___at___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___spec__1(x_1, x_2); -lean_dec(x_2); -lean_dec(x_1); -return x_3; -} -} lean_object* l___private_Init_Lean_Meta_ExprDefEq_9__findCached_x3f___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { @@ -9013,316 +8941,6 @@ lean_dec(x_1); return x_4; } } -uint8_t l_AssocList_contains___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__2(lean_object* x_1, lean_object* x_2) { -_start: -{ -if (lean_obj_tag(x_2) == 0) -{ -uint8_t x_3; -x_3 = 0; -return x_3; -} -else -{ -lean_object* x_4; lean_object* x_5; uint8_t x_6; -x_4 = lean_ctor_get(x_2, 0); -x_5 = lean_ctor_get(x_2, 2); -x_6 = lean_expr_equal(x_4, x_1); -if (x_6 == 0) -{ -x_2 = x_5; -goto _start; -} -else -{ -uint8_t x_8; -x_8 = 1; -return x_8; -} -} -} -} -lean_object* l_AssocList_foldlM___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__5(lean_object* x_1, lean_object* x_2) { -_start: -{ -if (lean_obj_tag(x_2) == 0) -{ -return x_1; -} -else -{ -uint8_t x_3; -x_3 = !lean_is_exclusive(x_2); -if (x_3 == 0) -{ -lean_object* x_4; lean_object* x_5; lean_object* x_6; size_t x_7; size_t x_8; lean_object* x_9; lean_object* x_10; -x_4 = lean_ctor_get(x_2, 0); -x_5 = lean_ctor_get(x_2, 2); -x_6 = lean_array_get_size(x_1); -x_7 = l_Lean_Expr_hash(x_4); -x_8 = lean_usize_modn(x_7, x_6); -lean_dec(x_6); -x_9 = lean_array_uget(x_1, x_8); -lean_ctor_set(x_2, 2, x_9); -x_10 = lean_array_uset(x_1, x_8, x_2); -x_1 = x_10; -x_2 = x_5; -goto _start; -} -else -{ -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; size_t x_16; size_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; -x_12 = lean_ctor_get(x_2, 0); -x_13 = lean_ctor_get(x_2, 1); -x_14 = lean_ctor_get(x_2, 2); -lean_inc(x_14); -lean_inc(x_13); -lean_inc(x_12); -lean_dec(x_2); -x_15 = lean_array_get_size(x_1); -x_16 = l_Lean_Expr_hash(x_12); -x_17 = lean_usize_modn(x_16, x_15); -lean_dec(x_15); -x_18 = lean_array_uget(x_1, x_17); -x_19 = lean_alloc_ctor(1, 3, 0); -lean_ctor_set(x_19, 0, x_12); -lean_ctor_set(x_19, 1, x_13); -lean_ctor_set(x_19, 2, x_18); -x_20 = lean_array_uset(x_1, x_17, x_19); -x_1 = x_20; -x_2 = x_14; -goto _start; -} -} -} -} -lean_object* l_HashMapImp_moveEntries___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -lean_object* x_4; uint8_t x_5; -x_4 = lean_array_get_size(x_2); -x_5 = lean_nat_dec_lt(x_1, x_4); -lean_dec(x_4); -if (x_5 == 0) -{ -lean_dec(x_2); -lean_dec(x_1); -return x_3; -} -else -{ -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; -x_6 = lean_array_fget(x_2, x_1); -x_7 = lean_box(0); -x_8 = lean_array_fset(x_2, x_1, x_7); -x_9 = l_AssocList_foldlM___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__5(x_3, x_6); -x_10 = lean_unsigned_to_nat(1u); -x_11 = lean_nat_add(x_1, x_10); -lean_dec(x_1); -x_1 = x_11; -x_2 = x_8; -x_3 = x_9; -goto _start; -} -} -} -lean_object* l_HashMapImp_expand___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__3(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; -x_3 = lean_array_get_size(x_2); -x_4 = lean_unsigned_to_nat(2u); -x_5 = lean_nat_mul(x_3, x_4); -lean_dec(x_3); -x_6 = lean_box(0); -x_7 = lean_mk_array(x_5, x_6); -x_8 = lean_unsigned_to_nat(0u); -x_9 = l_HashMapImp_moveEntries___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__4(x_8, x_2, x_7); -x_10 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_10, 0, x_1); -lean_ctor_set(x_10, 1, x_9); -return x_10; -} -} -lean_object* l_AssocList_replace___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -if (lean_obj_tag(x_3) == 0) -{ -lean_dec(x_2); -lean_dec(x_1); -return x_3; -} -else -{ -uint8_t x_4; -x_4 = !lean_is_exclusive(x_3); -if (x_4 == 0) -{ -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_ctor_get(x_3, 1); -x_7 = lean_ctor_get(x_3, 2); -x_8 = lean_expr_equal(x_5, x_1); -if (x_8 == 0) -{ -lean_object* x_9; -x_9 = l_AssocList_replace___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__6(x_1, x_2, x_7); -lean_ctor_set(x_3, 2, x_9); -return x_3; -} -else -{ -lean_dec(x_6); -lean_dec(x_5); -lean_ctor_set(x_3, 1, x_2); -lean_ctor_set(x_3, 0, x_1); -return x_3; -} -} -else -{ -lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; -x_10 = lean_ctor_get(x_3, 0); -x_11 = lean_ctor_get(x_3, 1); -x_12 = lean_ctor_get(x_3, 2); -lean_inc(x_12); -lean_inc(x_11); -lean_inc(x_10); -lean_dec(x_3); -x_13 = lean_expr_equal(x_10, x_1); -if (x_13 == 0) -{ -lean_object* x_14; lean_object* x_15; -x_14 = l_AssocList_replace___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__6(x_1, x_2, x_12); -x_15 = lean_alloc_ctor(1, 3, 0); -lean_ctor_set(x_15, 0, x_10); -lean_ctor_set(x_15, 1, x_11); -lean_ctor_set(x_15, 2, x_14); -return x_15; -} -else -{ -lean_object* x_16; -lean_dec(x_11); -lean_dec(x_10); -x_16 = lean_alloc_ctor(1, 3, 0); -lean_ctor_set(x_16, 0, x_1); -lean_ctor_set(x_16, 1, x_2); -lean_ctor_set(x_16, 2, x_12); -return x_16; -} -} -} -} -} -lean_object* l_HashMapImp_insert___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: -{ -uint8_t x_4; -x_4 = !lean_is_exclusive(x_1); -if (x_4 == 0) -{ -lean_object* x_5; lean_object* x_6; lean_object* x_7; size_t x_8; size_t x_9; lean_object* x_10; uint8_t x_11; -x_5 = lean_ctor_get(x_1, 0); -x_6 = lean_ctor_get(x_1, 1); -x_7 = lean_array_get_size(x_6); -x_8 = l_Lean_Expr_hash(x_2); -x_9 = lean_usize_modn(x_8, x_7); -x_10 = lean_array_uget(x_6, x_9); -x_11 = l_AssocList_contains___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__2(x_2, x_10); -if (x_11 == 0) -{ -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; -x_12 = lean_unsigned_to_nat(1u); -x_13 = lean_nat_add(x_5, x_12); -lean_dec(x_5); -x_14 = lean_alloc_ctor(1, 3, 0); -lean_ctor_set(x_14, 0, x_2); -lean_ctor_set(x_14, 1, x_3); -lean_ctor_set(x_14, 2, x_10); -x_15 = lean_array_uset(x_6, x_9, x_14); -x_16 = lean_nat_dec_le(x_13, x_7); -lean_dec(x_7); -if (x_16 == 0) -{ -lean_object* x_17; -lean_free_object(x_1); -x_17 = l_HashMapImp_expand___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__3(x_13, x_15); -return x_17; -} -else -{ -lean_ctor_set(x_1, 1, x_15); -lean_ctor_set(x_1, 0, x_13); -return x_1; -} -} -else -{ -lean_object* x_18; lean_object* x_19; -lean_dec(x_7); -x_18 = l_AssocList_replace___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__6(x_2, x_3, x_10); -x_19 = lean_array_uset(x_6, x_9, x_18); -lean_ctor_set(x_1, 1, x_19); -return x_1; -} -} -else -{ -lean_object* x_20; lean_object* x_21; lean_object* x_22; size_t x_23; size_t x_24; lean_object* x_25; uint8_t x_26; -x_20 = lean_ctor_get(x_1, 0); -x_21 = lean_ctor_get(x_1, 1); -lean_inc(x_21); -lean_inc(x_20); -lean_dec(x_1); -x_22 = lean_array_get_size(x_21); -x_23 = l_Lean_Expr_hash(x_2); -x_24 = lean_usize_modn(x_23, x_22); -x_25 = lean_array_uget(x_21, x_24); -x_26 = l_AssocList_contains___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__2(x_2, x_25); -if (x_26 == 0) -{ -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; -x_27 = lean_unsigned_to_nat(1u); -x_28 = lean_nat_add(x_20, x_27); -lean_dec(x_20); -x_29 = lean_alloc_ctor(1, 3, 0); -lean_ctor_set(x_29, 0, x_2); -lean_ctor_set(x_29, 1, x_3); -lean_ctor_set(x_29, 2, x_25); -x_30 = lean_array_uset(x_21, x_24, x_29); -x_31 = lean_nat_dec_le(x_28, x_22); -lean_dec(x_22); -if (x_31 == 0) -{ -lean_object* x_32; -x_32 = l_HashMapImp_expand___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__3(x_28, x_30); -return x_32; -} -else -{ -lean_object* x_33; -x_33 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_33, 0, x_28); -lean_ctor_set(x_33, 1, x_30); -return x_33; -} -} -else -{ -lean_object* x_34; lean_object* x_35; lean_object* x_36; -lean_dec(x_22); -x_34 = l_AssocList_replace___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__6(x_2, x_3, x_25); -x_35 = lean_array_uset(x_21, x_24, x_34); -x_36 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_36, 0, x_20); -lean_ctor_set(x_36, 1, x_35); -return x_36; -} -} -} -} lean_object* l___private_Init_Lean_Meta_ExprDefEq_10__cache(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { @@ -9332,7 +8950,7 @@ if (x_5 == 0) { lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; x_6 = lean_ctor_get(x_4, 1); -x_7 = l_HashMapImp_insert___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__1(x_6, x_1, x_2); +x_7 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_6, x_1, x_2); lean_ctor_set(x_4, 1, x_7); x_8 = lean_box(0); x_9 = lean_alloc_ctor(0, 2, 0); @@ -9348,7 +8966,7 @@ x_11 = lean_ctor_get(x_4, 1); lean_inc(x_11); lean_inc(x_10); lean_dec(x_4); -x_12 = l_HashMapImp_insert___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__1(x_11, x_1, x_2); +x_12 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_11, x_1, x_2); x_13 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_13, 0, x_10); lean_ctor_set(x_13, 1, x_12); @@ -9360,17 +8978,6 @@ return x_15; } } } -lean_object* l_AssocList_contains___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__2___boxed(lean_object* x_1, lean_object* x_2) { -_start: -{ -uint8_t x_3; lean_object* x_4; -x_3 = l_AssocList_contains___main___at___private_Init_Lean_Meta_ExprDefEq_10__cache___spec__2(x_1, x_2); -lean_dec(x_2); -lean_dec(x_1); -x_4 = lean_box(x_3); -return x_4; -} -} lean_object* l___private_Init_Lean_Meta_ExprDefEq_10__cache___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { @@ -30634,23 +30241,6 @@ lean_dec(x_6); return x_11; } } -lean_object* l_mkHashMap___at_Lean_Meta_checkAssignmentAux___spec__1(lean_object* x_1) { -_start: -{ -lean_object* x_2; -x_2 = l_mkHashMapImp___rarg(x_1); -return x_2; -} -} -lean_object* _init_l_Lean_Meta_checkAssignmentAux___closed__1() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = lean_unsigned_to_nat(8u); -x_2 = l_mkHashMapImp___rarg(x_1); -return x_2; -} -} lean_object* l_Lean_Meta_checkAssignmentAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { _start: { @@ -30667,7 +30257,7 @@ lean_ctor_set(x_10, 1, x_1); lean_ctor_set(x_10, 2, x_9); lean_ctor_set(x_10, 3, x_3); lean_ctor_set_uint8(x_10, sizeof(void*)*4, x_4); -x_11 = l_Lean_Meta_checkAssignmentAux___closed__1; +x_11 = l_HashMap_Inhabited___closed__1; x_12 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_12, 0, x_7); lean_ctor_set(x_12, 1, x_11); @@ -58953,6 +58543,8 @@ if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); l_Lean_Meta_commitWhen___at___private_Init_Lean_Meta_ExprDefEq_1__isDefEqEta___spec__1___closed__1 = _init_l_Lean_Meta_commitWhen___at___private_Init_Lean_Meta_ExprDefEq_1__isDefEqEta___spec__1___closed__1(); lean_mark_persistent(l_Lean_Meta_commitWhen___at___private_Init_Lean_Meta_ExprDefEq_1__isDefEqEta___spec__1___closed__1); +l_Lean_Meta_isDefEqStringLit___closed__1 = _init_l_Lean_Meta_isDefEqStringLit___closed__1(); +lean_mark_persistent(l_Lean_Meta_isDefEqStringLit___closed__1); l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__1 = _init_l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__1(); lean_mark_persistent(l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__1); l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__2 = _init_l___private_Init_Lean_Meta_ExprDefEq_8__checkTypesAndAssign___closed__2(); @@ -58999,8 +58591,6 @@ l___private_Init_Lean_Meta_ExprDefEq_12__checkAssignmentFailure___closed__8 = _i lean_mark_persistent(l___private_Init_Lean_Meta_ExprDefEq_12__checkAssignmentFailure___closed__8); l___private_Init_Lean_Meta_ExprDefEq_12__checkAssignmentFailure___closed__9 = _init_l___private_Init_Lean_Meta_ExprDefEq_12__checkAssignmentFailure___closed__9(); lean_mark_persistent(l___private_Init_Lean_Meta_ExprDefEq_12__checkAssignmentFailure___closed__9); -l_Lean_Meta_checkAssignmentAux___closed__1 = _init_l_Lean_Meta_checkAssignmentAux___closed__1(); -lean_mark_persistent(l_Lean_Meta_checkAssignmentAux___closed__1); l___private_Init_Lean_Meta_ExprDefEq_15__processAssignmentFOApprox___main___closed__1 = _init_l___private_Init_Lean_Meta_ExprDefEq_15__processAssignmentFOApprox___main___closed__1(); lean_mark_persistent(l___private_Init_Lean_Meta_ExprDefEq_15__processAssignmentFOApprox___main___closed__1); l___private_Init_Lean_Meta_ExprDefEq_15__processAssignmentFOApprox___main___closed__2 = _init_l___private_Init_Lean_Meta_ExprDefEq_15__processAssignmentFOApprox___main___closed__2(); diff --git a/stage0/stdlib/Init/Lean/Meta/Message.c b/stage0/stdlib/Init/Lean/Meta/Message.c index bda28f3ce5..85c5cb9647 100644 --- a/stage0/stdlib/Init/Lean/Meta/Message.c +++ b/stage0/stdlib/Init/Lean/Meta/Message.c @@ -13,24 +13,18 @@ #ifdef __cplusplus extern "C" { #endif -lean_object* l_Lean_KernelException_toMessageData___closed__32; -lean_object* l_Lean_KernelException_toMessageData___closed__10; extern lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__51; -lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__10; lean_object* l_Lean_Meta_Exception_toMessageData___closed__12; lean_object* l___private_Init_Lean_Meta_Message_1__run_x3f(lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__19; lean_object* l_unreachable_x21___rarg(lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__51; lean_object* l___private_Init_Lean_Meta_Message_3__inferDomain_x3f___boxed(lean_object*, lean_object*); lean_object* lean_io_prim_put_str(lean_object*, lean_object*); extern lean_object* l_Lean_MessageData_ofList___closed__3; lean_object* l___private_Init_Lean_Meta_Message_3__inferDomain_x3f___lambda__1(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__7; lean_object* l_Lean_Format_pretty(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__39; lean_object* l_Lean_Meta_Exception_toMessageData___closed__35; -lean_object* l_Lean_KernelException_toMessageData___closed__24; lean_object* l_PersistentArray_forM___at_Lean_Meta_MetaHasEval___spec__3___boxed(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__36; lean_object* l_Lean_Meta_Exception_toMessageData(lean_object*); @@ -45,29 +39,22 @@ lean_object* l_Lean_Meta_Exception_toMessageData___closed__43; extern lean_object* l_Lean_Meta_Exception_toTraceMessageData___closed__82; lean_object* l___private_Init_Lean_Meta_Message_3__inferDomain_x3f(lean_object*, lean_object*); lean_object* l_Lean_Meta_MetaHasEval(lean_object*); -lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__7; lean_object* lean_array_get_size(lean_object*); lean_object* l_Lean_MessageData_formatAux___main(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__26; -lean_object* l_Lean_KernelException_toMessageData___closed__16; lean_object* l_IO_print___at_Lean_Meta_MetaHasEval___spec__2(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage(lean_object*, lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__20; lean_object* l_Array_forMAux___main___at_Lean_Meta_MetaHasEval___spec__5___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Array_forMAux___main___at_Lean_Meta_MetaHasEval___spec__6___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__40; lean_object* lean_nat_add(lean_object*, lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__22; lean_object* l_Lean_Meta_Exception_toMessageData___closed__9; -lean_object* l_Lean_KernelException_toMessageData___closed__37; lean_object* l_Lean_Meta_Exception_toMessageData___closed__27; lean_object* l_Lean_Meta_Exception_toMessageData___closed__45; extern lean_object* l_Lean_LocalContext_Inhabited___closed__2; -lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__11; lean_object* l___private_Init_Lean_Meta_Message_4__whnf_x3f(lean_object*, lean_object*); extern lean_object* l_Lean_Meta_run___rarg___closed__5; lean_object* l_Lean_Meta_Exception_toMessageData___closed__8; -lean_object* l_Lean_KernelException_toMessageData___closed__6; lean_object* l_Lean_Meta_Exception_toMessageData___closed__17; lean_object* l_Lean_Meta_Exception_toMessageData___closed__23; lean_object* lean_array_fget(lean_object*, lean_object*); @@ -75,31 +62,21 @@ lean_object* l_Lean_Meta_Exception_toMessageData___closed__4; lean_object* l_Lean_mkProj(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__1; lean_object* l_Lean_Meta_Exception_toMessageData___closed__48; -lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__9; lean_object* l_Lean_Meta_Exception_toMessageData___closed__34; extern lean_object* l_Lean_MessageData_Inhabited; lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__2; -lean_object* l_Lean_KernelException_toMessageData___closed__29; lean_object* l_Lean_KernelException_toMessageData(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__9; lean_object* l_Lean_Meta_Exception_toMessageData___closed__11; -lean_object* l_Lean_Meta_MetaHasEval___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__25; -lean_object* l_Lean_KernelException_toMessageData___closed__30; +lean_object* l_Lean_Meta_MetaHasEval___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__8; -extern lean_object* l_Lean_Meta_Exception_toStr___closed__19; lean_object* l_Lean_Meta_Exception_toMessageData___closed__19; extern lean_object* l_Lean_MessageData_coeOfArrayExpr___closed__2; lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__4; -lean_object* l_Lean_KernelException_toMessageData___closed__18; lean_object* l_Array_forMAux___main___at_Lean_Meta_MetaHasEval___spec__5(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__5; lean_object* l_Lean_Meta_Exception_toMessageData___closed__44; lean_object* l_Lean_Meta_Exception_toMessageData___closed__1; -lean_object* l_Lean_KernelException_toMessageData___closed__33; lean_object* lean_name_mk_string(lean_object*, lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__14; -lean_object* l_Lean_KernelException_toMessageData___closed__28; extern lean_object* l_IO_println___rarg___closed__1; extern lean_object* l_PersistentArray_empty___closed__3; extern lean_object* l_Lean_Meta_Exception_toStr___closed__11; @@ -108,44 +85,29 @@ lean_object* l_Lean_Meta_Exception_toMessageData___closed__2; lean_object* l_Lean_Meta_Exception_toMessageData___closed__47; extern lean_object* l_Lean_Options_empty; lean_object* l_Lean_Meta_Exception_toMessageData___closed__33; -lean_object* l_Lean_KernelException_toMessageData___closed__34; lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__5; -lean_object* l_Lean_KernelException_toMessageData___closed__15; lean_object* l_Lean_Meta_Exception_toMessageData___closed__46; -lean_object* l_Lean_KernelException_toMessageData___closed__42; lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__6; lean_object* l___private_Init_Lean_Meta_Message_1__run_x3f___rarg___closed__3; lean_object* l_Lean_Meta_Exception_toMessageData___closed__6; -lean_object* l_Lean_KernelException_toMessageData___closed__27; lean_object* l_Lean_Meta_Exception_toMessageData___closed__25; lean_object* l_Lean_Meta_whnf(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_Message_4__whnf_x3f___boxed(lean_object*, lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__3; -lean_object* l_Lean_KernelException_toMessageData___closed__40; -lean_object* l_Lean_KernelException_toMessageData___closed__9; lean_object* l_Lean_Meta_Exception_toMessageData___closed__3; lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__3; -lean_object* l_Lean_KernelException_toMessageData___closed__36; lean_object* l_Lean_Meta_Exception_toMessageData___closed__37; lean_object* l___private_Init_Lean_Meta_Message_1__run_x3f___rarg___closed__1; lean_object* l_Lean_Meta_Exception_toMessageData___closed__42; lean_object* l_IO_println___at_Lean_Meta_MetaHasEval___spec__1(lean_object*, lean_object*); -lean_object* l___private_Init_Lean_Meta_Message_5__mkCtx(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__1; lean_object* l___private_Init_Lean_Meta_Message_1__run_x3f___rarg___closed__2; -lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8; lean_object* l_Lean_Meta_Exception_toMessageData___closed__22; lean_object* l_Lean_Meta_Exception_toMessageData___closed__50; -lean_object* l_Lean_KernelException_toMessageData___closed__8; -lean_object* l_Lean_KernelException_toMessageData___closed__4; +lean_object* l_Lean_Meta_MetaHasEval___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__38; lean_object* l_Lean_Meta_Exception_toMessageData___closed__21; lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__1; -lean_object* l_Lean_KernelException_toMessageData___closed__17; lean_object* l___private_Init_Lean_Meta_Message_3__inferDomain_x3f___closed__1; lean_object* l_Lean_Meta_Exception_toMessageData___closed__41; -lean_object* l_Lean_KernelException_toMessageData___closed__38; -lean_object* l_Lean_KernelException_toMessageData___closed__21; lean_object* l_Lean_mkApp(lean_object*, lean_object*); lean_object* l_Lean_getMaxRecDepth(lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__13; @@ -153,14 +115,9 @@ lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__2; lean_object* l_PersistentArray_forMAux___main___at_Lean_Meta_MetaHasEval___spec__4___boxed(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__4; lean_object* l_Lean_Meta_Exception_toMessageData___closed__29; -lean_object* l_Lean_KernelException_toMessageData___closed__2; extern lean_object* l_Lean_Meta_Exception_toStr___closed__10; lean_object* l_Lean_Meta_Exception_toMessageData___closed__10; lean_object* l_Lean_Meta_Exception_toMessageData___closed__32; -lean_object* l_Lean_KernelException_toMessageData___closed__31; -lean_object* l_Lean_KernelException_toMessageData___closed__35; -lean_object* l_Lean_KernelException_toMessageData___closed__41; -lean_object* l_Lean_KernelException_toMessageData___closed__23; lean_object* l_Lean_Meta_Exception_toMessageData___closed__7; lean_object* l_Lean_Meta_Exception_toMessageData___closed__49; lean_object* l_PersistentArray_forM___at_Lean_Meta_MetaHasEval___spec__3(lean_object*, lean_object*); @@ -171,19 +128,17 @@ lean_object* l___private_Init_Lean_Meta_Message_3__inferDomain_x3f___lambda__1__ lean_object* l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__7; lean_object* l___private_Init_Lean_Meta_Message_2__inferType_x3f___boxed(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__24; -lean_object* l_Lean_KernelException_toMessageData___closed__12; -lean_object* l_Lean_KernelException_toMessageData___closed__13; +extern lean_object* l_Lean_KernelException_toMessageData___closed__12; lean_object* l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__3; lean_object* l___private_Init_Lean_Meta_Message_1__run_x3f___rarg(lean_object*, lean_object*); extern lean_object* l_Lean_MetavarContext_Inhabited___closed__1; extern lean_object* l_Lean_Meta_run___rarg___closed__1; -extern lean_object* l_Lean_Meta_Exception_toStr___closed__15; +extern lean_object* l_Lean_Meta_Exception_toStr___closed__18; lean_object* l_Lean_Meta_Exception_toMessageData___closed__18; lean_object* l_Lean_Meta_Exception_toMessageData___closed__30; lean_object* lean_local_ctx_find(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_Message_1__run_x3f___rarg___boxed(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__5; -lean_object* l_Lean_KernelException_toMessageData___closed__26; lean_object* l_Lean_Meta_Exception_toMessageData___closed__14; lean_object* l_Lean_Meta_Exception_toMessageData___closed__28; lean_object* l_Lean_indentExpr(lean_object*); @@ -194,27 +149,11 @@ lean_object* l_Lean_mkConst(lean_object*, lean_object*); lean_object* l_PersistentArray_forMAux___main___at_Lean_Meta_MetaHasEval___spec__4(lean_object*, lean_object*); lean_object* l_Lean_Meta_Exception_toMessageData___closed__15; lean_object* l_Lean_Meta_Exception_toMessageData___closed__16; -lean_object* l_Lean_KernelException_toMessageData___closed__11; extern lean_object* l_Lean_NameGenerator_Inhabited___closed__3; lean_object* l_Lean_Meta_Exception_toMessageData___closed__20; uint8_t lean_nat_dec_lt(lean_object*, lean_object*); lean_object* l_Array_forMAux___main___at_Lean_Meta_MetaHasEval___spec__6(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_KernelException_toMessageData___closed__39; -lean_object* l_Lean_indentExpr(lean_object* x_1) { -_start: -{ -lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; -x_2 = l_Lean_MessageData_ofList___closed__3; -x_3 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_3, 0, x_2); -lean_ctor_set(x_3, 1, x_1); -x_4 = lean_unsigned_to_nat(2u); -x_5 = lean_alloc_ctor(7, 2, 0); -lean_ctor_set(x_5, 0, x_4); -lean_ctor_set(x_5, 1, x_3); -return x_5; -} -} +extern lean_object* l_Lean_KernelException_toMessageData___closed__39; lean_object* _init_l___private_Init_Lean_Meta_Message_1__run_x3f___rarg___closed__1() { _start: { @@ -346,7 +285,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l___private_Init_Lean_Meta_Message_3__inferDomain_x3f___lambda__1___closed__1; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } @@ -497,11 +436,9 @@ return x_3; lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Meta_Exception_toStr___closed__15; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; +lean_object* x_1; +x_1 = lean_mk_string("argument"); +return x_1; } } lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__2() { @@ -509,7 +446,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__1; -x_2 = lean_alloc_ctor(0, 1, 0); +x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } @@ -517,82 +454,36 @@ return x_2; lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__3() { _start: { -lean_object* x_1; -x_1 = lean_mk_string("argument"); -return x_1; +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__2; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; } } lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__4() { _start: { -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__3; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__5() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__4; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__6() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("has type"); -return x_1; -} -} -lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__7() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__6; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__7; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__9() { -_start: -{ lean_object* x_1; x_1 = lean_mk_string("but is expected to have type"); return x_1; } } -lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__10() { +lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__5() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__9; +x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__4; x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__11() { +lean_object* _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__6() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__10; +x_1 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__5; x_2 = lean_alloc_ctor(0, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; @@ -641,7 +532,7 @@ lean_dec(x_15); x_18 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_18, 0, x_4); x_19 = l_Lean_indentExpr(x_18); -x_20 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__2; +x_20 = l_Lean_KernelException_toMessageData___closed__39; x_21 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_21, 0, x_20); lean_ctor_set(x_21, 1, x_19); @@ -649,7 +540,7 @@ x_22 = l_Lean_MessageData_ofList___closed__3; x_23 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_23, 0, x_21); lean_ctor_set(x_23, 1, x_22); -x_24 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__5; +x_24 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__3; x_25 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_25, 0, x_23); lean_ctor_set(x_25, 1, x_24); @@ -662,7 +553,7 @@ lean_ctor_set(x_28, 1, x_27); x_29 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_29, 0, x_28); lean_ctor_set(x_29, 1, x_22); -x_30 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8; +x_30 = l_Lean_KernelException_toMessageData___closed__12; x_31 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_31, 0, x_29); lean_ctor_set(x_31, 1, x_30); @@ -675,7 +566,7 @@ lean_ctor_set(x_34, 1, x_33); x_35 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_35, 0, x_34); lean_ctor_set(x_35, 1, x_22); -x_36 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__11; +x_36 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__6; x_37 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_37, 0, x_35); lean_ctor_set(x_37, 1, x_36); @@ -698,7 +589,7 @@ lean_dec(x_5); x_6 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_6, 0, x_4); x_7 = l_Lean_indentExpr(x_6); -x_8 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__2; +x_8 = l_Lean_KernelException_toMessageData___closed__39; x_9 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_9, 0, x_8); lean_ctor_set(x_9, 1, x_7); @@ -886,7 +777,7 @@ lean_ctor_set(x_31, 1, x_30); x_32 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_32, 0, x_31); lean_ctor_set(x_32, 1, x_25); -x_33 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__11; +x_33 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__6; x_34 = lean_alloc_ctor(9, 2, 0); lean_ctor_set(x_34, 0, x_32); lean_ctor_set(x_34, 1, x_33); @@ -1341,7 +1232,7 @@ lean_object* _init_l_Lean_Meta_Exception_toMessageData___closed__47() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Meta_Exception_toStr___closed__19; +x_1 = l_Lean_Meta_Exception_toStr___closed__18; x_2 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; @@ -1808,22 +1699,33 @@ return x_147; } case 19: { -lean_object* x_148; +lean_object* x_148; lean_object* x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_1, 0); +lean_inc(x_148); +x_149 = lean_ctor_get(x_1, 1); +lean_inc(x_149); lean_dec(x_1); -x_148 = l_Lean_Meta_Exception_toTraceMessageData___closed__82; -return x_148; +x_150 = l_Lean_KernelException_toMessageData(x_148, x_149); +return x_150; +} +case 20: +{ +lean_object* x_151; +lean_dec(x_1); +x_151 = l_Lean_Meta_Exception_toTraceMessageData___closed__82; +return x_151; } default: { -lean_object* x_149; lean_object* x_150; lean_object* x_151; -x_149 = lean_ctor_get(x_1, 0); -lean_inc(x_149); +lean_object* x_152; lean_object* x_153; lean_object* x_154; +x_152 = lean_ctor_get(x_1, 0); +lean_inc(x_152); lean_dec(x_1); -x_150 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_150, 0, x_149); -x_151 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_151, 0, x_150); -return x_151; +x_153 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_153, 0, x_152); +x_154 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_154, 0, x_153); +return x_154; } } } @@ -2065,177 +1967,179 @@ return x_12; } } } -lean_object* l_Lean_Meta_MetaHasEval___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +lean_object* l_Lean_Meta_MetaHasEval___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6) { _start: { -uint8_t x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; -x_6 = 0; -x_7 = 1; +uint8_t x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_7 = 0; +x_8 = 1; lean_inc(x_3); -x_8 = lean_alloc_ctor(0, 1, 7); -lean_ctor_set(x_8, 0, x_3); -lean_ctor_set_uint8(x_8, sizeof(void*)*1, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 1, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 2, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 3, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 4, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 5, x_6); -lean_ctor_set_uint8(x_8, sizeof(void*)*1 + 6, x_7); -x_9 = l_Lean_getMaxRecDepth(x_3); -x_10 = l_Lean_LocalContext_Inhabited___closed__2; -x_11 = l_Array_empty___closed__1; -x_12 = lean_unsigned_to_nat(0u); -x_13 = lean_alloc_ctor(0, 5, 0); -lean_ctor_set(x_13, 0, x_8); -lean_ctor_set(x_13, 1, x_10); -lean_ctor_set(x_13, 2, x_11); -lean_ctor_set(x_13, 3, x_12); -lean_ctor_set(x_13, 4, x_9); -x_14 = l_Lean_MetavarContext_Inhabited___closed__1; -x_15 = l_Lean_Meta_run___rarg___closed__5; -x_16 = l_Lean_NameGenerator_Inhabited___closed__3; -x_17 = l_Lean_TraceState_Inhabited___closed__1; -x_18 = l_PersistentArray_empty___closed__3; -x_19 = lean_alloc_ctor(0, 6, 0); -lean_ctor_set(x_19, 0, x_2); -lean_ctor_set(x_19, 1, x_14); -lean_ctor_set(x_19, 2, x_15); -lean_ctor_set(x_19, 3, x_16); -lean_ctor_set(x_19, 4, x_17); -lean_ctor_set(x_19, 5, x_18); -x_20 = lean_apply_2(x_4, x_13, x_19); -if (lean_obj_tag(x_20) == 0) +x_9 = lean_alloc_ctor(0, 1, 7); +lean_ctor_set(x_9, 0, x_3); +lean_ctor_set_uint8(x_9, sizeof(void*)*1, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 1, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 2, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 3, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 4, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 5, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1 + 6, x_8); +x_10 = l_Lean_getMaxRecDepth(x_3); +x_11 = l_Lean_LocalContext_Inhabited___closed__2; +x_12 = l_Array_empty___closed__1; +x_13 = lean_unsigned_to_nat(0u); +x_14 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_14, 0, x_9); +lean_ctor_set(x_14, 1, x_11); +lean_ctor_set(x_14, 2, x_12); +lean_ctor_set(x_14, 3, x_13); +lean_ctor_set(x_14, 4, x_10); +x_15 = l_Lean_MetavarContext_Inhabited___closed__1; +x_16 = l_Lean_Meta_run___rarg___closed__5; +x_17 = l_Lean_NameGenerator_Inhabited___closed__3; +x_18 = l_Lean_TraceState_Inhabited___closed__1; +x_19 = l_PersistentArray_empty___closed__3; +x_20 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_20, 0, x_2); +lean_ctor_set(x_20, 1, x_15); +lean_ctor_set(x_20, 2, x_16); +lean_ctor_set(x_20, 3, x_17); +lean_ctor_set(x_20, 4, x_18); +lean_ctor_set(x_20, 5, x_19); +x_21 = lean_apply_2(x_4, x_14, x_20); +if (lean_obj_tag(x_21) == 0) { -lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; -x_21 = lean_ctor_get(x_20, 0); -lean_inc(x_21); -x_22 = lean_ctor_get(x_20, 1); +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_21, 0); lean_inc(x_22); -lean_dec(x_20); -x_23 = lean_ctor_get(x_22, 4); +x_23 = lean_ctor_get(x_21, 1); lean_inc(x_23); -x_24 = lean_ctor_get(x_23, 0); -lean_inc(x_24); -lean_dec(x_23); -x_25 = l_PersistentArray_forM___at_Lean_Meta_MetaHasEval___spec__3(x_24, x_5); -lean_dec(x_24); -if (lean_obj_tag(x_25) == 0) -{ -lean_object* x_26; lean_object* x_27; lean_object* x_28; -x_26 = lean_ctor_get(x_25, 1); -lean_inc(x_26); -lean_dec(x_25); -x_27 = lean_ctor_get(x_22, 0); -lean_inc(x_27); -lean_dec(x_22); -x_28 = lean_apply_4(x_1, x_27, x_3, x_21, x_26); -return x_28; -} -else -{ -uint8_t x_29; -lean_dec(x_22); lean_dec(x_21); -lean_dec(x_3); -lean_dec(x_1); -x_29 = !lean_is_exclusive(x_25); -if (x_29 == 0) -{ -return x_25; -} -else -{ -lean_object* x_30; lean_object* x_31; lean_object* x_32; -x_30 = lean_ctor_get(x_25, 0); -x_31 = lean_ctor_get(x_25, 1); -lean_inc(x_31); -lean_inc(x_30); +x_24 = lean_ctor_get(x_23, 4); +lean_inc(x_24); +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +lean_dec(x_24); +x_26 = l_PersistentArray_forM___at_Lean_Meta_MetaHasEval___spec__3(x_25, x_6); lean_dec(x_25); -x_32 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_32, 0, x_30); -lean_ctor_set(x_32, 1, x_31); -return x_32; -} -} +if (lean_obj_tag(x_26) == 0) +{ +lean_object* x_27; lean_object* x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; +x_27 = lean_ctor_get(x_26, 1); +lean_inc(x_27); +lean_dec(x_26); +x_28 = lean_ctor_get(x_23, 0); +lean_inc(x_28); +lean_dec(x_23); +x_29 = 1; +x_30 = lean_box(x_29); +x_31 = lean_apply_5(x_1, x_28, x_3, x_22, x_30, x_27); +return x_31; } else { -lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +uint8_t x_32; +lean_dec(x_23); +lean_dec(x_22); lean_dec(x_3); lean_dec(x_1); -x_33 = lean_ctor_get(x_20, 0); -lean_inc(x_33); -x_34 = lean_ctor_get(x_20, 1); +x_32 = !lean_is_exclusive(x_26); +if (x_32 == 0) +{ +return x_26; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_26, 0); +x_34 = lean_ctor_get(x_26, 1); lean_inc(x_34); -lean_dec(x_20); -x_35 = lean_ctor_get(x_34, 4); -lean_inc(x_35); -lean_dec(x_34); -x_36 = lean_ctor_get(x_35, 0); +lean_inc(x_33); +lean_dec(x_26); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +return x_35; +} +} +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +lean_dec(x_3); +lean_dec(x_1); +x_36 = lean_ctor_get(x_21, 0); lean_inc(x_36); -lean_dec(x_35); -x_37 = l_PersistentArray_forM___at_Lean_Meta_MetaHasEval___spec__3(x_36, x_5); -lean_dec(x_36); -if (lean_obj_tag(x_37) == 0) -{ -uint8_t x_38; -x_38 = !lean_is_exclusive(x_37); -if (x_38 == 0) -{ -lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; -x_39 = lean_ctor_get(x_37, 0); +x_37 = lean_ctor_get(x_21, 1); +lean_inc(x_37); +lean_dec(x_21); +x_38 = lean_ctor_get(x_37, 4); +lean_inc(x_38); +lean_dec(x_37); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_PersistentArray_forM___at_Lean_Meta_MetaHasEval___spec__3(x_39, x_6); lean_dec(x_39); -x_40 = l_Lean_Meta_Exception_toMessageData(x_33); -x_41 = lean_box(0); -x_42 = l_Lean_MessageData_formatAux___main(x_41, x_40); -x_43 = l_Lean_Options_empty; -x_44 = l_Lean_Format_pretty(x_42, x_43); -x_45 = lean_alloc_ctor(18, 1, 0); -lean_ctor_set(x_45, 0, x_44); -lean_ctor_set_tag(x_37, 1); -lean_ctor_set(x_37, 0, x_45); -return x_37; +if (lean_obj_tag(x_40) == 0) +{ +uint8_t x_41; +x_41 = !lean_is_exclusive(x_40); +if (x_41 == 0) +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_42 = lean_ctor_get(x_40, 0); +lean_dec(x_42); +x_43 = l_Lean_Meta_Exception_toMessageData(x_36); +x_44 = lean_box(0); +x_45 = l_Lean_MessageData_formatAux___main(x_44, x_43); +x_46 = l_Lean_Options_empty; +x_47 = l_Lean_Format_pretty(x_45, x_46); +x_48 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set_tag(x_40, 1); +lean_ctor_set(x_40, 0, x_48); +return x_40; } else { -lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; -x_46 = lean_ctor_get(x_37, 1); -lean_inc(x_46); -lean_dec(x_37); -x_47 = l_Lean_Meta_Exception_toMessageData(x_33); -x_48 = lean_box(0); -x_49 = l_Lean_MessageData_formatAux___main(x_48, x_47); -x_50 = l_Lean_Options_empty; -x_51 = l_Lean_Format_pretty(x_49, x_50); -x_52 = lean_alloc_ctor(18, 1, 0); -lean_ctor_set(x_52, 0, x_51); -x_53 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_53, 0, x_52); -lean_ctor_set(x_53, 1, x_46); -return x_53; +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_49 = lean_ctor_get(x_40, 1); +lean_inc(x_49); +lean_dec(x_40); +x_50 = l_Lean_Meta_Exception_toMessageData(x_36); +x_51 = lean_box(0); +x_52 = l_Lean_MessageData_formatAux___main(x_51, x_50); +x_53 = l_Lean_Options_empty; +x_54 = l_Lean_Format_pretty(x_52, x_53); +x_55 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_55, 0, x_54); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_49); +return x_56; } } else { -uint8_t x_54; -lean_dec(x_33); -x_54 = !lean_is_exclusive(x_37); -if (x_54 == 0) +uint8_t x_57; +lean_dec(x_36); +x_57 = !lean_is_exclusive(x_40); +if (x_57 == 0) { -return x_37; +return x_40; } else { -lean_object* x_55; lean_object* x_56; lean_object* x_57; -x_55 = lean_ctor_get(x_37, 0); -x_56 = lean_ctor_get(x_37, 1); -lean_inc(x_56); -lean_inc(x_55); -lean_dec(x_37); -x_57 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_57, 0, x_55); -lean_ctor_set(x_57, 1, x_56); -return x_57; +lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_58 = lean_ctor_get(x_40, 0); +x_59 = lean_ctor_get(x_40, 1); +lean_inc(x_59); +lean_inc(x_58); +lean_dec(x_40); +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set(x_60, 1, x_59); +return x_60; } } } @@ -2245,7 +2149,7 @@ lean_object* l_Lean_Meta_MetaHasEval(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l_Lean_Meta_MetaHasEval___rarg), 5, 0); +x_2 = lean_alloc_closure((void*)(l_Lean_Meta_MetaHasEval___rarg___boxed), 6, 0); return x_2; } } @@ -2285,756 +2189,14 @@ lean_dec(x_1); return x_3; } } -lean_object* l___private_Init_Lean_Meta_Message_5__mkCtx(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +lean_object* l_Lean_Meta_MetaHasEval___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { _start: { -lean_object* x_5; lean_object* x_6; lean_object* x_7; -x_5 = l_Lean_MetavarContext_Inhabited___closed__1; -x_6 = lean_alloc_ctor(0, 4, 0); -lean_ctor_set(x_6, 0, x_1); -lean_ctor_set(x_6, 1, x_5); -lean_ctor_set(x_6, 2, x_2); -lean_ctor_set(x_6, 3, x_3); -x_7 = lean_alloc_ctor(6, 2, 0); -lean_ctor_set(x_7, 0, x_6); -lean_ctor_set(x_7, 1, x_4); -return x_7; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__1() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) unknown constant "); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__2() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__1; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__3() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__2; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__4() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) constant has already been declared "); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__5() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__4; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__6() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__5; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__7() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) declaration type mismatch "); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__8() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__7; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__9() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__8; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__10() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("but it is expected to have type"); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__11() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__10; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__12() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__11; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__13() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) declaration type mismatch"); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__14() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__13; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__15() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__14; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__16() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) declaration has metavariables "); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__17() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__16; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__18() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__17; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__19() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) declaration has free variables "); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__20() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__19; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__21() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__20; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__22() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) function expected"); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__23() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__22; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__24() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__23; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__25() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) type expected"); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__26() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__25; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__27() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__26; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__28() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) let-declaration type mismatch "); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__29() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__28; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__30() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__29; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__31() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) type mismatch at "); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__32() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__31; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__33() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__32; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__34() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) application type mismatch at"); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__35() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__34; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__36() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__35; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__37() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) "); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__38() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__37; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__39() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__38; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__40() { -_start: -{ -lean_object* x_1; -x_1 = lean_mk_string("(kernel) invalid projection"); -return x_1; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__41() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__40; -x_2 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* _init_l_Lean_KernelException_toMessageData___closed__42() { -_start: -{ -lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_KernelException_toMessageData___closed__41; -x_2 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_2, 0, x_1); -return x_2; -} -} -lean_object* l_Lean_KernelException_toMessageData(lean_object* x_1, lean_object* x_2) { -_start: -{ -switch (lean_obj_tag(x_1)) { -case 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; -x_3 = lean_ctor_get(x_1, 0); -lean_inc(x_3); -x_4 = lean_ctor_get(x_1, 1); -lean_inc(x_4); -lean_dec(x_1); -x_5 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_5, 0, x_4); -x_6 = l_Lean_KernelException_toMessageData___closed__3; -x_7 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_7, 0, x_6); -lean_ctor_set(x_7, 1, x_5); -x_8 = l_Lean_LocalContext_Inhabited___closed__2; -x_9 = l___private_Init_Lean_Meta_Message_5__mkCtx(x_3, x_8, x_2, x_7); -return x_9; -} -case 1: -{ -lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; -x_10 = lean_ctor_get(x_1, 0); -lean_inc(x_10); -x_11 = lean_ctor_get(x_1, 1); -lean_inc(x_11); -lean_dec(x_1); -x_12 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_12, 0, x_11); -x_13 = l_Lean_KernelException_toMessageData___closed__6; -x_14 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_14, 0, x_13); -lean_ctor_set(x_14, 1, x_12); -x_15 = l_Lean_LocalContext_Inhabited___closed__2; -x_16 = l___private_Init_Lean_Meta_Message_5__mkCtx(x_10, x_15, x_2, x_14); -return x_16; -} -case 2: -{ -lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; -lean_dec(x_2); -x_17 = lean_ctor_get(x_1, 1); -lean_inc(x_17); -x_18 = lean_ctor_get(x_1, 2); -lean_inc(x_18); -lean_dec(x_1); -switch (lean_obj_tag(x_17)) { -case 1: -{ -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; -x_38 = lean_ctor_get(x_17, 0); -lean_inc(x_38); -lean_dec(x_17); -x_39 = lean_ctor_get(x_38, 0); -lean_inc(x_39); -lean_dec(x_38); -x_40 = lean_ctor_get(x_39, 0); -lean_inc(x_40); -x_41 = lean_ctor_get(x_39, 2); -lean_inc(x_41); -lean_dec(x_39); -x_19 = x_40; -x_20 = x_41; -goto block_37; -} -case 2: -{ -lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; -x_42 = lean_ctor_get(x_17, 0); -lean_inc(x_42); -lean_dec(x_17); -x_43 = lean_ctor_get(x_42, 0); -lean_inc(x_43); -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 2); -lean_inc(x_45); -lean_dec(x_43); -x_19 = x_44; -x_20 = x_45; -goto block_37; -} -default: -{ -lean_object* x_46; -lean_dec(x_18); -lean_dec(x_17); -x_46 = l_Lean_KernelException_toMessageData___closed__15; -return x_46; -} -} -block_37: -{ -lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_21 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_21, 0, x_19); -x_22 = l_Lean_KernelException_toMessageData___closed__9; -x_23 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_23, 0, x_22); -lean_ctor_set(x_23, 1, x_21); -x_24 = l_Lean_MessageData_ofList___closed__3; -x_25 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_25, 0, x_23); -lean_ctor_set(x_25, 1, x_24); -x_26 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8; -x_27 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_27, 0, x_25); -lean_ctor_set(x_27, 1, x_26); -x_28 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_28, 0, x_18); -x_29 = l_Lean_indentExpr(x_28); -x_30 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_30, 0, x_27); -lean_ctor_set(x_30, 1, x_29); -x_31 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_31, 0, x_30); -lean_ctor_set(x_31, 1, x_24); -x_32 = l_Lean_KernelException_toMessageData___closed__12; -x_33 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_33, 0, x_31); -lean_ctor_set(x_33, 1, x_32); -x_34 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_34, 0, x_20); -x_35 = l_Lean_indentExpr(x_34); -x_36 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_36, 0, x_33); -lean_ctor_set(x_36, 1, x_35); -return x_36; -} -} -case 3: -{ -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_1, 1); -lean_inc(x_48); -lean_dec(x_1); -x_49 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_49, 0, x_48); -x_50 = l_Lean_KernelException_toMessageData___closed__18; -x_51 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_51, 0, x_50); -lean_ctor_set(x_51, 1, x_49); -x_52 = l_Lean_LocalContext_Inhabited___closed__2; -x_53 = l___private_Init_Lean_Meta_Message_5__mkCtx(x_47, x_52, x_2, x_51); -return x_53; -} -case 4: -{ -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; -x_54 = lean_ctor_get(x_1, 0); -lean_inc(x_54); -x_55 = lean_ctor_get(x_1, 1); -lean_inc(x_55); -lean_dec(x_1); -x_56 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = l_Lean_KernelException_toMessageData___closed__21; -x_58 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_58, 0, x_57); -lean_ctor_set(x_58, 1, x_56); -x_59 = l_Lean_LocalContext_Inhabited___closed__2; -x_60 = l___private_Init_Lean_Meta_Message_5__mkCtx(x_54, x_59, x_2, x_58); -return x_60; -} -case 5: -{ -lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; -x_61 = lean_ctor_get(x_1, 0); -lean_inc(x_61); -x_62 = lean_ctor_get(x_1, 1); -lean_inc(x_62); -x_63 = lean_ctor_get(x_1, 2); -lean_inc(x_63); -lean_dec(x_1); -x_64 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_64, 0, x_63); -x_65 = l_Lean_indentExpr(x_64); -x_66 = l_Lean_KernelException_toMessageData___closed__24; -x_67 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_67, 0, x_66); -lean_ctor_set(x_67, 1, x_65); -x_68 = l___private_Init_Lean_Meta_Message_5__mkCtx(x_61, x_62, x_2, x_67); -return x_68; -} -case 6: -{ -lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; -x_69 = lean_ctor_get(x_1, 0); -lean_inc(x_69); -x_70 = lean_ctor_get(x_1, 1); -lean_inc(x_70); -x_71 = lean_ctor_get(x_1, 2); -lean_inc(x_71); -lean_dec(x_1); -x_72 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_72, 0, x_71); -x_73 = l_Lean_indentExpr(x_72); -x_74 = l_Lean_KernelException_toMessageData___closed__27; -x_75 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_75, 0, x_74); -lean_ctor_set(x_75, 1, x_73); -x_76 = l___private_Init_Lean_Meta_Message_5__mkCtx(x_69, x_70, x_2, x_75); -return x_76; -} -case 7: -{ -lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_77 = lean_ctor_get(x_1, 0); -lean_inc(x_77); -x_78 = lean_ctor_get(x_1, 1); -lean_inc(x_78); -x_79 = lean_ctor_get(x_1, 2); -lean_inc(x_79); -lean_dec(x_1); -x_80 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_80, 0, x_79); -x_81 = l_Lean_KernelException_toMessageData___closed__30; -x_82 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_82, 0, x_81); -lean_ctor_set(x_82, 1, x_80); -x_83 = l___private_Init_Lean_Meta_Message_5__mkCtx(x_77, x_78, x_2, x_82); -return x_83; -} -case 8: -{ -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_object* x_90; lean_object* x_91; -x_84 = lean_ctor_get(x_1, 0); -lean_inc(x_84); -x_85 = lean_ctor_get(x_1, 1); -lean_inc(x_85); -x_86 = lean_ctor_get(x_1, 2); -lean_inc(x_86); -lean_dec(x_1); -x_87 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_87, 0, x_86); -x_88 = l_Lean_indentExpr(x_87); -x_89 = l_Lean_KernelException_toMessageData___closed__33; -x_90 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_90, 0, x_89); -lean_ctor_set(x_90, 1, x_88); -x_91 = l___private_Init_Lean_Meta_Message_5__mkCtx(x_84, x_85, x_2, x_90); -return x_91; -} -case 9: -{ -lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; -x_92 = lean_ctor_get(x_1, 0); -lean_inc(x_92); -x_93 = lean_ctor_get(x_1, 1); -lean_inc(x_93); -x_94 = lean_ctor_get(x_1, 2); -lean_inc(x_94); -lean_dec(x_1); -if (lean_obj_tag(x_94) == 5) -{ -lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; -x_101 = lean_ctor_get(x_94, 0); -lean_inc(x_101); -x_102 = lean_ctor_get(x_94, 1); -lean_inc(x_102); -lean_dec(x_94); -x_103 = l_Lean_MetavarContext_Inhabited___closed__1; -x_104 = lean_alloc_ctor(0, 4, 0); -lean_ctor_set(x_104, 0, x_92); -lean_ctor_set(x_104, 1, x_103); -lean_ctor_set(x_104, 2, x_93); -lean_ctor_set(x_104, 3, x_2); -x_105 = l_Lean_Meta_Exception_mkAppTypeMismatchMessage(x_101, x_102, x_104); -x_106 = l_Lean_KernelException_toMessageData___closed__39; -x_107 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_107, 0, x_106); -lean_ctor_set(x_107, 1, x_105); -return x_107; -} -else -{ -lean_object* x_108; -lean_dec(x_93); -lean_dec(x_92); -lean_dec(x_2); -x_108 = lean_box(0); -x_95 = x_108; -goto block_100; -} -block_100: -{ -lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; -lean_dec(x_95); -x_96 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_96, 0, x_94); -x_97 = l_Lean_indentExpr(x_96); -x_98 = l_Lean_KernelException_toMessageData___closed__36; -x_99 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_99, 0, x_98); -lean_ctor_set(x_99, 1, x_97); -return x_99; -} -} -case 10: -{ -lean_object* x_109; lean_object* x_110; 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_109 = lean_ctor_get(x_1, 0); -lean_inc(x_109); -x_110 = lean_ctor_get(x_1, 1); -lean_inc(x_110); -x_111 = lean_ctor_get(x_1, 2); -lean_inc(x_111); -lean_dec(x_1); -x_112 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_112, 0, x_111); -x_113 = l_Lean_indentExpr(x_112); -x_114 = l_Lean_KernelException_toMessageData___closed__42; -x_115 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_115, 0, x_114); -lean_ctor_set(x_115, 1, x_113); -x_116 = l___private_Init_Lean_Meta_Message_5__mkCtx(x_109, x_110, x_2, x_115); -return x_116; -} -default: -{ -lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; -lean_dec(x_2); -x_117 = lean_ctor_get(x_1, 0); -lean_inc(x_117); -lean_dec(x_1); -x_118 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_118, 0, x_117); -x_119 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_119, 0, x_118); -x_120 = l_Lean_KernelException_toMessageData___closed__39; -x_121 = lean_alloc_ctor(9, 2, 0); -lean_ctor_set(x_121, 0, x_120); -lean_ctor_set(x_121, 1, x_119); -return x_121; -} -} +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_5); +lean_dec(x_5); +x_8 = l_Lean_Meta_MetaHasEval___rarg(x_1, x_2, x_3, x_4, x_7, x_6); +return x_8; } } lean_object* initialize_Init_Lean_Meta_Basic(lean_object*); @@ -3070,16 +2232,6 @@ l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__5 = _init_l_Lean_Meta_E lean_mark_persistent(l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__5); l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__6 = _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__6(); lean_mark_persistent(l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__6); -l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__7 = _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__7(); -lean_mark_persistent(l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__7); -l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8 = _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8(); -lean_mark_persistent(l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__8); -l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__9 = _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__9(); -lean_mark_persistent(l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__9); -l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__10 = _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__10(); -lean_mark_persistent(l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__10); -l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__11 = _init_l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__11(); -lean_mark_persistent(l_Lean_Meta_Exception_mkAppTypeMismatchMessage___closed__11); l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__1 = _init_l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__1(); lean_mark_persistent(l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__1); l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__2 = _init_l_Lean_Meta_Exception_mkLetTypeMismatchMessage___closed__2(); @@ -3200,90 +2352,6 @@ l_Lean_Meta_Exception_toMessageData___closed__50 = _init_l_Lean_Meta_Exception_t lean_mark_persistent(l_Lean_Meta_Exception_toMessageData___closed__50); l_Lean_Meta_Exception_toMessageData___closed__51 = _init_l_Lean_Meta_Exception_toMessageData___closed__51(); lean_mark_persistent(l_Lean_Meta_Exception_toMessageData___closed__51); -l_Lean_KernelException_toMessageData___closed__1 = _init_l_Lean_KernelException_toMessageData___closed__1(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__1); -l_Lean_KernelException_toMessageData___closed__2 = _init_l_Lean_KernelException_toMessageData___closed__2(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__2); -l_Lean_KernelException_toMessageData___closed__3 = _init_l_Lean_KernelException_toMessageData___closed__3(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__3); -l_Lean_KernelException_toMessageData___closed__4 = _init_l_Lean_KernelException_toMessageData___closed__4(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__4); -l_Lean_KernelException_toMessageData___closed__5 = _init_l_Lean_KernelException_toMessageData___closed__5(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__5); -l_Lean_KernelException_toMessageData___closed__6 = _init_l_Lean_KernelException_toMessageData___closed__6(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__6); -l_Lean_KernelException_toMessageData___closed__7 = _init_l_Lean_KernelException_toMessageData___closed__7(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__7); -l_Lean_KernelException_toMessageData___closed__8 = _init_l_Lean_KernelException_toMessageData___closed__8(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__8); -l_Lean_KernelException_toMessageData___closed__9 = _init_l_Lean_KernelException_toMessageData___closed__9(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__9); -l_Lean_KernelException_toMessageData___closed__10 = _init_l_Lean_KernelException_toMessageData___closed__10(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__10); -l_Lean_KernelException_toMessageData___closed__11 = _init_l_Lean_KernelException_toMessageData___closed__11(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__11); -l_Lean_KernelException_toMessageData___closed__12 = _init_l_Lean_KernelException_toMessageData___closed__12(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__12); -l_Lean_KernelException_toMessageData___closed__13 = _init_l_Lean_KernelException_toMessageData___closed__13(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__13); -l_Lean_KernelException_toMessageData___closed__14 = _init_l_Lean_KernelException_toMessageData___closed__14(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__14); -l_Lean_KernelException_toMessageData___closed__15 = _init_l_Lean_KernelException_toMessageData___closed__15(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__15); -l_Lean_KernelException_toMessageData___closed__16 = _init_l_Lean_KernelException_toMessageData___closed__16(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__16); -l_Lean_KernelException_toMessageData___closed__17 = _init_l_Lean_KernelException_toMessageData___closed__17(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__17); -l_Lean_KernelException_toMessageData___closed__18 = _init_l_Lean_KernelException_toMessageData___closed__18(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__18); -l_Lean_KernelException_toMessageData___closed__19 = _init_l_Lean_KernelException_toMessageData___closed__19(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__19); -l_Lean_KernelException_toMessageData___closed__20 = _init_l_Lean_KernelException_toMessageData___closed__20(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__20); -l_Lean_KernelException_toMessageData___closed__21 = _init_l_Lean_KernelException_toMessageData___closed__21(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__21); -l_Lean_KernelException_toMessageData___closed__22 = _init_l_Lean_KernelException_toMessageData___closed__22(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__22); -l_Lean_KernelException_toMessageData___closed__23 = _init_l_Lean_KernelException_toMessageData___closed__23(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__23); -l_Lean_KernelException_toMessageData___closed__24 = _init_l_Lean_KernelException_toMessageData___closed__24(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__24); -l_Lean_KernelException_toMessageData___closed__25 = _init_l_Lean_KernelException_toMessageData___closed__25(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__25); -l_Lean_KernelException_toMessageData___closed__26 = _init_l_Lean_KernelException_toMessageData___closed__26(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__26); -l_Lean_KernelException_toMessageData___closed__27 = _init_l_Lean_KernelException_toMessageData___closed__27(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__27); -l_Lean_KernelException_toMessageData___closed__28 = _init_l_Lean_KernelException_toMessageData___closed__28(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__28); -l_Lean_KernelException_toMessageData___closed__29 = _init_l_Lean_KernelException_toMessageData___closed__29(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__29); -l_Lean_KernelException_toMessageData___closed__30 = _init_l_Lean_KernelException_toMessageData___closed__30(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__30); -l_Lean_KernelException_toMessageData___closed__31 = _init_l_Lean_KernelException_toMessageData___closed__31(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__31); -l_Lean_KernelException_toMessageData___closed__32 = _init_l_Lean_KernelException_toMessageData___closed__32(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__32); -l_Lean_KernelException_toMessageData___closed__33 = _init_l_Lean_KernelException_toMessageData___closed__33(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__33); -l_Lean_KernelException_toMessageData___closed__34 = _init_l_Lean_KernelException_toMessageData___closed__34(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__34); -l_Lean_KernelException_toMessageData___closed__35 = _init_l_Lean_KernelException_toMessageData___closed__35(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__35); -l_Lean_KernelException_toMessageData___closed__36 = _init_l_Lean_KernelException_toMessageData___closed__36(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__36); -l_Lean_KernelException_toMessageData___closed__37 = _init_l_Lean_KernelException_toMessageData___closed__37(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__37); -l_Lean_KernelException_toMessageData___closed__38 = _init_l_Lean_KernelException_toMessageData___closed__38(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__38); -l_Lean_KernelException_toMessageData___closed__39 = _init_l_Lean_KernelException_toMessageData___closed__39(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__39); -l_Lean_KernelException_toMessageData___closed__40 = _init_l_Lean_KernelException_toMessageData___closed__40(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__40); -l_Lean_KernelException_toMessageData___closed__41 = _init_l_Lean_KernelException_toMessageData___closed__41(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__41); -l_Lean_KernelException_toMessageData___closed__42 = _init_l_Lean_KernelException_toMessageData___closed__42(); -lean_mark_persistent(l_Lean_KernelException_toMessageData___closed__42); return lean_mk_io_result(lean_box(0)); } #ifdef __cplusplus diff --git a/stage0/stdlib/Init/Lean/Meta/RecursorInfo.c b/stage0/stdlib/Init/Lean/Meta/RecursorInfo.c index 8cb6145e27..6f1bf09a14 100644 --- a/stage0/stdlib/Init/Lean/Meta/RecursorInfo.c +++ b/stage0/stdlib/Init/Lean/Meta/RecursorInfo.c @@ -80,6 +80,7 @@ lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_HasToString__ lean_object* l___private_Init_Lean_Meta_RecursorInfo_1__mkRecursorInfoForKernelRec___closed__1; lean_object* l_RBNode_find___main___at_Lean_Meta_getMajorPos_x3f___spec__2___boxed(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_2__getMajorPosIfAuxRecursor_x3f___closed__2; +lean_object* l_Lean_Meta_recursorAttribute___closed__3; lean_object* l___private_Init_Lean_Meta_RecursorInfo_1__mkRecursorInfoForKernelRec___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_anyRangeMAux___main___at___private_Init_Lean_Meta_RecursorInfo_10__getProduceMotiveAndRecursive___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_auxRecExt; @@ -89,16 +90,17 @@ lean_object* l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_Recurso uint8_t l_Array_anyRangeMAux___main___at___private_Init_Lean_Meta_RecursorInfo_3__checkMotive___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_3__checkMotive___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_2__getMajorPosIfAuxRecursor_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_AttributeImpl_inhabited___closed__2; lean_object* lean_nat_add(lean_object*, lean_object*); lean_object* l_Lean_Meta_RecursorInfo_HasToString___closed__2; lean_object* l___private_Init_Lean_Meta_RecursorInfo_4__getNumParams___main___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux(lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_ParametricAttribute_Inhabited___closed__3; lean_object* l_Lean_Meta_RecursorInfo_HasToString___closed__6; lean_object* l_Lean_Meta_RecursorInfo_HasToString___closed__8; lean_object* l___private_Init_Lean_Meta_RecursorInfo_2__getMajorPosIfAuxRecursor_x3f___closed__1; +extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__1; lean_object* l_Lean_Meta_RecursorInfo_HasToString___closed__4; lean_object* l___private_Init_Lean_Meta_RecursorInfo_10__getProduceMotiveAndRecursive(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_getAppNumArgsAux___main(lean_object*, lean_object*); @@ -110,6 +112,7 @@ lean_object* l___private_Init_Lean_Meta_RecursorInfo_3__checkMotive___closed__2; lean_object* l___private_Init_Lean_Meta_RecursorInfo_5__getMajorPosDepElim___closed__7; lean_object* l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; lean_object* l_Array_binSearchAux___main___at_Lean_Meta_getMajorPos_x3f___spec__3(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Meta_recursorAttribute___closed__2; lean_object* l_Lean_Meta_RecursorInfo_HasToString___closed__13; lean_object* l_Lean_RecursorVal_getMajorIdx(lean_object*); lean_object* l_Lean_Meta_brecOnSuffix; @@ -137,6 +140,7 @@ lean_object* l_Lean_Meta_RecursorUnivLevelPos_hasToString(lean_object*); lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_HasToString___spec__2(uint8_t, lean_object*); lean_object* l_Array_anyRangeMAux___main___at_Lean_Meta_mkRecursorAttr___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_RBNode_fold___main___at_Lean_Meta_mkRecursorAttr___spec__2___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Meta_recursorAttribute___closed__1; lean_object* l_Nat_foldMAux___main___at___private_Init_Lean_Meta_RecursorInfo_10__getProduceMotiveAndRecursive___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Nat_foldMAux___main___at___private_Init_Lean_Meta_RecursorInfo_6__getParamsPos___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); @@ -197,10 +201,12 @@ lean_object* l___private_Init_Lean_Meta_RecursorInfo_7__getIndicesPos(lean_objec extern lean_object* l_Lean_registerParametricAttribute___rarg___closed__4; lean_object* l_Lean_Meta_getMajorPos_x3f___boxed(lean_object*, lean_object*); lean_object* l_Lean_Meta_RecursorInfo_numIndices(lean_object*); +extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__3; lean_object* l_Lean_ConstantInfo_type(lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_13__syntaxToMajorPos(lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_5__getMajorPosDepElim___closed__5; lean_object* l_Array_qsortAux___main___at_Lean_Meta_mkRecursorAttr___spec__3(lean_object*, lean_object*, lean_object*); +lean_object* l_fix1___rarg___lambda__1___boxed(lean_object*, lean_object*); lean_object* l_Lean_Meta_mkRecursorInfo(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_11__checkMotiveResultType___closed__1; lean_object* l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Meta_mkRecursorAttr___spec__4___closed__1; @@ -274,6 +280,7 @@ lean_object* l_Nat_foldMAux___main___at___private_Init_Lean_Meta_RecursorInfo_7_ lean_object* l___private_Init_Lean_Meta_RecursorInfo_6__getParamsPos(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_RecursorInfo_HasToString___closed__10; lean_object* l___private_Init_Lean_Meta_RecursorInfo_4__getNumParams___boxed(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_ParametricAttribute_Inhabited___closed__1; lean_object* l_Lean_ParametricAttribute_getParam___at_Lean_Meta_getMajorPos_x3f___spec__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_11__checkMotiveResultType___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_13__syntaxToMajorPos___closed__2; @@ -295,6 +302,7 @@ lean_object* l_Array_anyRangeMAux___main___at___private_Init_Lean_Meta_RecursorI lean_object* l_Array_findIdxMAux___main___at___private_Init_Lean_Meta_RecursorInfo_7__getIndicesPos___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Meta_RecursorInfo_13__syntaxToMajorPos___closed__1; lean_object* l_Lean_Meta_mkRecursorAttr___closed__2; +extern lean_object* l_Lean_PersistentEnvExtension_inhabited___rarg___closed__4; lean_object* l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__1___lambda__1___boxed(lean_object**); uint8_t l_Array_anyRangeMAux___main___at_Lean_Meta_mkRecursorAttr___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_recOnSuffix___closed__1; @@ -1491,7 +1499,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l___private_Init_Lean_Meta_RecursorInfo_1__mkRecursorInfoForKernelRec___closed__1; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } @@ -1812,7 +1820,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l___private_Init_Lean_Meta_RecursorInfo_2__getMajorPosIfAuxRecursor_x3f___closed__1; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } @@ -2171,7 +2179,7 @@ x_11 = l___private_Init_Lean_Meta_RecursorInfo_3__checkMotive___closed__2; x_12 = lean_string_append(x_10, x_11); x_13 = l___private_Init_Lean_Meta_RecursorInfo_3__checkMotive___closed__3; x_14 = lean_string_append(x_12, x_13); -x_15 = lean_alloc_ctor(20, 1, 0); +x_15 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_15, 0, x_14); x_16 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_16, 0, x_15); @@ -2207,7 +2215,7 @@ x_26 = l___private_Init_Lean_Meta_RecursorInfo_3__checkMotive___closed__2; x_27 = lean_string_append(x_25, x_26); x_28 = l___private_Init_Lean_Meta_RecursorInfo_3__checkMotive___closed__3; x_29 = lean_string_append(x_27, x_28); -x_30 = lean_alloc_ctor(20, 1, 0); +x_30 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_30, 0, x_29); x_31 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_31, 0, x_30); @@ -2429,7 +2437,7 @@ x_15 = lean_string_append(x_14, x_13); lean_dec(x_13); x_16 = l_Char_HasRepr___closed__1; x_17 = lean_string_append(x_15, x_16); -x_18 = lean_alloc_ctor(20, 1, 0); +x_18 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_18, 0, x_17); x_19 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_19, 0, x_18); @@ -2471,7 +2479,7 @@ x_32 = l___private_Init_Lean_Meta_RecursorInfo_5__getMajorPosDepElim___closed__4 x_33 = lean_string_append(x_31, x_32); x_34 = l___private_Init_Lean_Meta_RecursorInfo_5__getMajorPosDepElim___closed__5; x_35 = lean_string_append(x_33, x_34); -x_36 = lean_alloc_ctor(20, 1, 0); +x_36 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_36, 0, x_35); x_37 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_37, 0, x_36); @@ -2495,7 +2503,7 @@ x_43 = lean_string_append(x_42, x_41); lean_dec(x_41); x_44 = l___private_Init_Lean_Meta_RecursorInfo_5__getMajorPosDepElim___closed__7; x_45 = lean_string_append(x_43, x_44); -x_46 = lean_alloc_ctor(20, 1, 0); +x_46 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_46, 0, x_45); x_47 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_47, 0, x_46); @@ -2731,7 +2739,7 @@ x_30 = lean_string_append(x_29, x_28); lean_dec(x_28); x_31 = l_Nat_foldMAux___main___at___private_Init_Lean_Meta_RecursorInfo_6__getParamsPos___spec__2___closed__1; x_32 = lean_string_append(x_30, x_31); -x_33 = lean_alloc_ctor(20, 1, 0); +x_33 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_33, 0, x_32); lean_ctor_set_tag(x_21, 1); lean_ctor_set(x_21, 0, x_33); @@ -2772,7 +2780,7 @@ x_43 = lean_string_append(x_42, x_41); lean_dec(x_41); x_44 = l_Nat_foldMAux___main___at___private_Init_Lean_Meta_RecursorInfo_6__getParamsPos___spec__2___closed__1; x_45 = lean_string_append(x_43, x_44); -x_46 = lean_alloc_ctor(20, 1, 0); +x_46 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_46, 0, x_45); x_47 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_47, 0, x_46); @@ -3124,7 +3132,7 @@ x_28 = lean_string_append(x_27, x_26); lean_dec(x_26); x_29 = l_Nat_foldMAux___main___at___private_Init_Lean_Meta_RecursorInfo_7__getIndicesPos___spec__2___closed__1; x_30 = lean_string_append(x_28, x_29); -x_31 = lean_alloc_ctor(20, 1, 0); +x_31 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_31, 0, x_30); lean_ctor_set_tag(x_21, 1); lean_ctor_set(x_21, 0, x_31); @@ -3143,7 +3151,7 @@ x_36 = lean_string_append(x_35, x_34); lean_dec(x_34); x_37 = l_Nat_foldMAux___main___at___private_Init_Lean_Meta_RecursorInfo_7__getIndicesPos___spec__2___closed__1; x_38 = lean_string_append(x_36, x_37); -x_39 = lean_alloc_ctor(20, 1, 0); +x_39 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_39, 0, x_38); x_40 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_40, 0, x_39); @@ -3365,7 +3373,7 @@ x_9 = lean_string_append(x_8, x_7); lean_dec(x_7); x_10 = l___private_Init_Lean_Meta_RecursorInfo_8__getMotiveLevel___closed__1; x_11 = lean_string_append(x_9, x_10); -x_12 = lean_alloc_ctor(20, 1, 0); +x_12 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_12, 0, x_11); x_13 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_13, 0, x_12); @@ -3477,7 +3485,7 @@ x_22 = lean_string_append(x_20, x_21); lean_dec(x_21); x_23 = l_Char_HasRepr___closed__1; x_24 = lean_string_append(x_22, x_23); -x_25 = lean_alloc_ctor(20, 1, 0); +x_25 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_25, 0, x_24); x_26 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_26, 0, x_25); @@ -4719,7 +4727,7 @@ x_14 = l___private_Init_Lean_Meta_RecursorInfo_11__checkMotiveResultType___close x_15 = lean_string_append(x_13, x_14); x_16 = l___private_Init_Lean_Meta_RecursorInfo_11__checkMotiveResultType___closed__3; x_17 = lean_string_append(x_15, x_16); -x_18 = lean_alloc_ctor(20, 1, 0); +x_18 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_18, 0, x_17); x_19 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_19, 0, x_18); @@ -4748,7 +4756,7 @@ x_29 = l___private_Init_Lean_Meta_RecursorInfo_11__checkMotiveResultType___close x_30 = lean_string_append(x_28, x_29); x_31 = l___private_Init_Lean_Meta_RecursorInfo_11__checkMotiveResultType___closed__3; x_32 = lean_string_append(x_30, x_31); -x_33 = lean_alloc_ctor(20, 1, 0); +x_33 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_33, 0, x_32); x_34 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_34, 0, x_33); @@ -5219,7 +5227,7 @@ x_50 = lean_string_append(x_49, x_48); lean_dec(x_48); x_51 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__1___closed__1; x_52 = lean_string_append(x_50, x_51); -x_53 = lean_alloc_ctor(20, 1, 0); +x_53 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_53, 0, x_52); x_54 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_54, 0, x_53); @@ -5383,7 +5391,7 @@ x_41 = lean_string_append(x_40, x_39); lean_dec(x_39); x_42 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_43 = lean_string_append(x_41, x_42); -x_44 = lean_alloc_ctor(20, 1, 0); +x_44 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_44, 0, x_43); if (lean_is_scalar(x_18)) { x_45 = lean_alloc_ctor(1, 2, 0); @@ -5598,7 +5606,7 @@ x_91 = lean_string_append(x_90, x_89); lean_dec(x_89); x_92 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_93 = lean_string_append(x_91, x_92); -x_94 = lean_alloc_ctor(20, 1, 0); +x_94 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_94, 0, x_93); if (lean_is_scalar(x_68)) { x_95 = lean_alloc_ctor(1, 2, 0); @@ -5813,7 +5821,7 @@ x_141 = lean_string_append(x_140, x_139); lean_dec(x_139); x_142 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_143 = lean_string_append(x_141, x_142); -x_144 = lean_alloc_ctor(20, 1, 0); +x_144 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_144, 0, x_143); if (lean_is_scalar(x_118)) { x_145 = lean_alloc_ctor(1, 2, 0); @@ -6028,7 +6036,7 @@ x_191 = lean_string_append(x_190, x_189); lean_dec(x_189); x_192 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_193 = lean_string_append(x_191, x_192); -x_194 = lean_alloc_ctor(20, 1, 0); +x_194 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_194, 0, x_193); if (lean_is_scalar(x_168)) { x_195 = lean_alloc_ctor(1, 2, 0); @@ -6243,7 +6251,7 @@ x_241 = lean_string_append(x_240, x_239); lean_dec(x_239); x_242 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_243 = lean_string_append(x_241, x_242); -x_244 = lean_alloc_ctor(20, 1, 0); +x_244 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_244, 0, x_243); if (lean_is_scalar(x_218)) { x_245 = lean_alloc_ctor(1, 2, 0); @@ -6475,7 +6483,7 @@ x_297 = lean_string_append(x_296, x_295); lean_dec(x_295); x_298 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_299 = lean_string_append(x_297, x_298); -x_300 = lean_alloc_ctor(20, 1, 0); +x_300 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_300, 0, x_299); if (lean_is_scalar(x_274)) { x_301 = lean_alloc_ctor(1, 2, 0); @@ -6690,7 +6698,7 @@ x_347 = lean_string_append(x_346, x_345); lean_dec(x_345); x_348 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_349 = lean_string_append(x_347, x_348); -x_350 = lean_alloc_ctor(20, 1, 0); +x_350 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_350, 0, x_349); if (lean_is_scalar(x_324)) { x_351 = lean_alloc_ctor(1, 2, 0); @@ -6905,7 +6913,7 @@ x_397 = lean_string_append(x_396, x_395); lean_dec(x_395); x_398 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_399 = lean_string_append(x_397, x_398); -x_400 = lean_alloc_ctor(20, 1, 0); +x_400 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_400, 0, x_399); if (lean_is_scalar(x_374)) { x_401 = lean_alloc_ctor(1, 2, 0); @@ -7120,7 +7128,7 @@ x_447 = lean_string_append(x_446, x_445); lean_dec(x_445); x_448 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_449 = lean_string_append(x_447, x_448); -x_450 = lean_alloc_ctor(20, 1, 0); +x_450 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_450, 0, x_449); if (lean_is_scalar(x_424)) { x_451 = lean_alloc_ctor(1, 2, 0); @@ -7335,7 +7343,7 @@ x_497 = lean_string_append(x_496, x_495); lean_dec(x_495); x_498 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_499 = lean_string_append(x_497, x_498); -x_500 = lean_alloc_ctor(20, 1, 0); +x_500 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_500, 0, x_499); if (lean_is_scalar(x_474)) { x_501 = lean_alloc_ctor(1, 2, 0); @@ -7550,7 +7558,7 @@ x_547 = lean_string_append(x_546, x_545); lean_dec(x_545); x_548 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_549 = lean_string_append(x_547, x_548); -x_550 = lean_alloc_ctor(20, 1, 0); +x_550 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_550, 0, x_549); if (lean_is_scalar(x_524)) { x_551 = lean_alloc_ctor(1, 2, 0); @@ -7765,7 +7773,7 @@ x_597 = lean_string_append(x_596, x_595); lean_dec(x_595); x_598 = l_Lean_Expr_withAppAux___main___at___private_Init_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__2___closed__1; x_599 = lean_string_append(x_597, x_598); -x_600 = lean_alloc_ctor(20, 1, 0); +x_600 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_600, 0, x_599); if (lean_is_scalar(x_574)) { x_601 = lean_alloc_ctor(1, 2, 0); @@ -9472,6 +9480,46 @@ lean_dec(x_1); return x_4; } } +lean_object* _init_l_Lean_Meta_recursorAttribute___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_fix1___rarg___lambda__1___boxed), 2, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Meta_recursorAttribute___closed__2() { +_start: +{ +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; +x_1 = l_Lean_ParametricAttribute_Inhabited___closed__1; +x_2 = lean_box(0); +x_3 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__1; +x_4 = l_Lean_Meta_recursorAttribute___closed__1; +x_5 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__3; +x_6 = l_Lean_PersistentEnvExtension_inhabited___rarg___closed__4; +x_7 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_7, 0, x_1); +lean_ctor_set(x_7, 1, x_2); +lean_ctor_set(x_7, 2, x_3); +lean_ctor_set(x_7, 3, x_4); +lean_ctor_set(x_7, 4, x_5); +lean_ctor_set(x_7, 5, x_6); +return x_7; +} +} +lean_object* _init_l_Lean_Meta_recursorAttribute___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_AttributeImpl_inhabited___closed__2; +x_2 = l_Lean_Meta_recursorAttribute___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} lean_object* l_RBNode_find___main___at_Lean_Meta_getMajorPos_x3f___spec__2(lean_object* x_1, lean_object* x_2) { _start: { @@ -9947,6 +9995,12 @@ l_Lean_Meta_mkRecursorAttr___closed__4 = _init_l_Lean_Meta_mkRecursorAttr___clos lean_mark_persistent(l_Lean_Meta_mkRecursorAttr___closed__4); l_Lean_Meta_mkRecursorAttr___closed__5 = _init_l_Lean_Meta_mkRecursorAttr___closed__5(); lean_mark_persistent(l_Lean_Meta_mkRecursorAttr___closed__5); +l_Lean_Meta_recursorAttribute___closed__1 = _init_l_Lean_Meta_recursorAttribute___closed__1(); +lean_mark_persistent(l_Lean_Meta_recursorAttribute___closed__1); +l_Lean_Meta_recursorAttribute___closed__2 = _init_l_Lean_Meta_recursorAttribute___closed__2(); +lean_mark_persistent(l_Lean_Meta_recursorAttribute___closed__2); +l_Lean_Meta_recursorAttribute___closed__3 = _init_l_Lean_Meta_recursorAttribute___closed__3(); +lean_mark_persistent(l_Lean_Meta_recursorAttribute___closed__3); res = l_Lean_Meta_mkRecursorAttr(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; l_Lean_Meta_recursorAttribute = lean_io_result_get_value(res); diff --git a/stage0/stdlib/Init/Lean/Meta/SynthInstance.c b/stage0/stdlib/Init/Lean/Meta/SynthInstance.c index 2a3f95590f..077411e3d9 100644 --- a/stage0/stdlib/Init/Lean/Meta/SynthInstance.c +++ b/stage0/stdlib/Init/Lean/Meta/SynthInstance.c @@ -20069,7 +20069,7 @@ _start: { lean_object* x_1; lean_object* x_2; x_1 = l___private_Init_Lean_Meta_SynthInstance_4__preprocessArgs___main___closed__1; -x_2 = lean_alloc_ctor(20, 1, 0); +x_2 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } diff --git a/stage0/stdlib/Init/Lean/Meta/Tactic/Induction.c b/stage0/stdlib/Init/Lean/Meta/Tactic/Induction.c index 2e9eb8b3c6..b6894307c1 100644 --- a/stage0/stdlib/Init/Lean/Meta/Tactic/Induction.c +++ b/stage0/stdlib/Init/Lean/Meta/Tactic/Induction.c @@ -14,7 +14,6 @@ extern "C" { #endif lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Meta_Tactic_Induction_4__finalizeAux___main___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(lean_object*, lean_object*); lean_object* l_Lean_Meta_induction___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_array_set(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_mvarId_x21(lean_object*); @@ -34,6 +33,7 @@ lean_object* l___private_Init_Lean_Meta_Tactic_Induction_2__addRecParams___main_ extern lean_object* l_Array_empty___closed__1; lean_object* l_Lean_Meta_getMVarTag(lean_object*, lean_object*, lean_object*); lean_object* l_ReaderT_bind___at_Lean_Meta_isClassExpensive___main___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(lean_object*, lean_object*); lean_object* lean_expr_instantiate1(lean_object*, lean_object*); uint8_t l_List_elem___main___at_Lean_Meta_induction___spec__2(lean_object*, lean_object*); lean_object* lean_array_push(lean_object*, lean_object*); @@ -4066,7 +4066,7 @@ x_57 = lean_box(0); x_58 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_27, x_50, x_27, x_23, x_57); lean_dec(x_27); x_59 = x_50; -x_60 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_23, x_59); +x_60 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_23, x_59); x_61 = x_60; lean_inc(x_55); x_62 = l_Lean_mkFVar(x_55); @@ -4512,7 +4512,7 @@ x_157 = lean_box(0); x_158 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_127, x_150, x_127, x_123, x_157); lean_dec(x_127); x_159 = x_150; -x_160 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_123, x_159); +x_160 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_123, x_159); x_161 = x_160; lean_inc(x_155); x_162 = l_Lean_mkFVar(x_155); @@ -4958,7 +4958,7 @@ x_257 = lean_box(0); x_258 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_227, x_250, x_227, x_223, x_257); lean_dec(x_227); x_259 = x_250; -x_260 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_223, x_259); +x_260 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_223, x_259); x_261 = x_260; lean_inc(x_255); x_262 = l_Lean_mkFVar(x_255); @@ -5404,7 +5404,7 @@ x_357 = lean_box(0); x_358 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_327, x_350, x_327, x_323, x_357); lean_dec(x_327); x_359 = x_350; -x_360 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_323, x_359); +x_360 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_323, x_359); x_361 = x_360; lean_inc(x_355); x_362 = l_Lean_mkFVar(x_355); @@ -5850,7 +5850,7 @@ x_457 = lean_box(0); x_458 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_427, x_450, x_427, x_423, x_457); lean_dec(x_427); x_459 = x_450; -x_460 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_423, x_459); +x_460 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_423, x_459); x_461 = x_460; lean_inc(x_455); x_462 = l_Lean_mkFVar(x_455); @@ -6313,7 +6313,7 @@ x_563 = lean_box(0); x_564 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_533, x_556, x_533, x_529, x_563); lean_dec(x_533); x_565 = x_556; -x_566 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_529, x_565); +x_566 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_529, x_565); x_567 = x_566; lean_inc(x_561); x_568 = l_Lean_mkFVar(x_561); @@ -6759,7 +6759,7 @@ x_663 = lean_box(0); x_664 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_633, x_656, x_633, x_629, x_663); lean_dec(x_633); x_665 = x_656; -x_666 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_629, x_665); +x_666 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_629, x_665); x_667 = x_666; lean_inc(x_661); x_668 = l_Lean_mkFVar(x_661); @@ -7205,7 +7205,7 @@ x_763 = lean_box(0); x_764 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_733, x_756, x_733, x_729, x_763); lean_dec(x_733); x_765 = x_756; -x_766 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_729, x_765); +x_766 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_729, x_765); x_767 = x_766; lean_inc(x_761); x_768 = l_Lean_mkFVar(x_761); @@ -7651,7 +7651,7 @@ x_863 = lean_box(0); x_864 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_833, x_856, x_833, x_829, x_863); lean_dec(x_833); x_865 = x_856; -x_866 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_829, x_865); +x_866 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_829, x_865); x_867 = x_866; lean_inc(x_861); x_868 = l_Lean_mkFVar(x_861); @@ -8097,7 +8097,7 @@ x_963 = lean_box(0); x_964 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_933, x_956, x_933, x_929, x_963); lean_dec(x_933); x_965 = x_956; -x_966 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_929, x_965); +x_966 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_929, x_965); x_967 = x_966; lean_inc(x_961); x_968 = l_Lean_mkFVar(x_961); @@ -8543,7 +8543,7 @@ x_1063 = lean_box(0); x_1064 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_1033, x_1056, x_1033, x_1029, x_1063); lean_dec(x_1033); x_1065 = x_1056; -x_1066 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_1029, x_1065); +x_1066 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_1029, x_1065); x_1067 = x_1066; lean_inc(x_1061); x_1068 = l_Lean_mkFVar(x_1061); @@ -8989,7 +8989,7 @@ x_1163 = lean_box(0); x_1164 = l_Array_iterateMAux___main___at_Lean_Meta_induction___spec__5(x_1133, x_1156, x_1133, x_1129, x_1163); lean_dec(x_1133); x_1165 = x_1156; -x_1166 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_1129, x_1165); +x_1166 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_1129, x_1165); x_1167 = x_1166; lean_inc(x_1161); x_1168 = l_Lean_mkFVar(x_1161); diff --git a/stage0/stdlib/Init/Lean/Meta/Tactic/Revert.c b/stage0/stdlib/Init/Lean/Meta/Tactic/Revert.c index 60ffe793af..f5d24f0eb2 100644 --- a/stage0/stdlib/Init/Lean/Meta/Tactic/Revert.c +++ b/stage0/stdlib/Init/Lean/Meta/Tactic/Revert.c @@ -20,7 +20,9 @@ lean_object* l_Lean_Meta_withLocalContext___rarg(lean_object*, lean_object*, lea lean_object* l_Lean_mkMVar(lean_object*); lean_object* l_Lean_Meta_elimMVarDeps(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_ReaderT_bind___at_Lean_Meta_isClassExpensive___main___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(lean_object*, lean_object*); lean_object* lean_array_get_size(lean_object*); +lean_object* l_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Expr_getAppArgs___closed__1; lean_object* lean_nat_add(lean_object*, lean_object*); lean_object* l_Lean_Expr_getAppNumArgsAux___main(lean_object*, lean_object*); @@ -28,25 +30,22 @@ lean_object* lean_array_fget(lean_object*, lean_object*); lean_object* lean_nat_sub(lean_object*, lean_object*); lean_object* l_Lean_Expr_fvarId_x21(lean_object*); lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); -lean_object* l_Array_umapMAux___main___at_Lean_Meta_revert___spec__2(lean_object*, lean_object*); lean_object* lean_name_mk_string(lean_object*, lean_object*); lean_object* l_Lean_Meta_revert(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Meta_revert___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_setMVarKind(lean_object*, uint8_t, lean_object*, lean_object*); -lean_object* l_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Array_isEmpty___rarg(lean_object*); lean_object* l_Lean_Meta_revert___lambda__1(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_mkFVar(lean_object*); lean_object* l_Lean_Meta_revert___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_revert___lambda__1___closed__2; lean_object* l_Lean_Meta_revert___lambda__1___closed__1; -lean_object* l_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_checkNotAssigned(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_getMVarDecl(lean_object*, lean_object*, lean_object*); lean_object* lean_mk_array(lean_object*, lean_object*); lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_getMVarTag___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_setMVarTag(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t lean_nat_dec_lt(lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(lean_object* x_1, lean_object* x_2) { _start: @@ -67,37 +66,6 @@ x_5 = lean_array_fget(x_2, x_1); x_6 = lean_unsigned_to_nat(0u); x_7 = lean_array_fset(x_2, x_1, x_6); x_8 = x_5; -x_9 = l_Lean_mkFVar(x_8); -x_10 = lean_unsigned_to_nat(1u); -x_11 = lean_nat_add(x_1, x_10); -x_12 = x_9; -x_13 = lean_array_fset(x_7, x_1, x_12); -lean_dec(x_1); -x_1 = x_11; -x_2 = x_13; -goto _start; -} -} -} -lean_object* l_Array_umapMAux___main___at_Lean_Meta_revert___spec__2(lean_object* x_1, lean_object* x_2) { -_start: -{ -lean_object* x_3; uint8_t x_4; -x_3 = lean_array_get_size(x_2); -x_4 = lean_nat_dec_lt(x_1, x_3); -lean_dec(x_3); -if (x_4 == 0) -{ -lean_dec(x_1); -return x_2; -} -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; lean_object* x_11; lean_object* x_12; lean_object* x_13; -x_5 = lean_array_fget(x_2, x_1); -x_6 = lean_unsigned_to_nat(0u); -x_7 = lean_array_fset(x_2, x_1, x_6); -x_8 = x_5; x_9 = l_Lean_Expr_fvarId_x21(x_8); lean_dec(x_8); x_10 = lean_unsigned_to_nat(1u); @@ -111,7 +79,7 @@ goto _start; } } } -lean_object* l_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___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_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___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: { if (lean_obj_tag(x_2) == 5) @@ -147,7 +115,7 @@ x_16 = lean_ctor_get(x_14, 0); lean_dec(x_16); x_17 = x_3; x_18 = lean_unsigned_to_nat(0u); -x_19 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__2(x_18, x_17); +x_19 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_18, x_17); x_20 = x_19; x_21 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_21, 0, x_20); @@ -163,7 +131,7 @@ lean_inc(x_22); lean_dec(x_14); x_23 = x_3; x_24 = lean_unsigned_to_nat(0u); -x_25 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__2(x_24, x_23); +x_25 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_24, x_23); x_26 = x_25; x_27 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_27, 0, x_26); @@ -215,7 +183,7 @@ lean_inc(x_12); lean_dec(x_11); x_13 = x_2; x_14 = lean_unsigned_to_nat(0u); -x_15 = l_Array_umapMAux___main___at_Lean_Meta_revert___spec__1(x_14, x_13); +x_15 = l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(x_14, x_13); x_16 = x_15; lean_inc(x_1); x_17 = l_Lean_mkMVar(x_1); @@ -240,7 +208,7 @@ x_26 = lean_mk_array(x_24, x_25); x_27 = lean_unsigned_to_nat(1u); x_28 = lean_nat_sub(x_24, x_27); lean_dec(x_24); -x_29 = l_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___spec__3(x_4, x_19, x_26, x_28, x_5, x_23); +x_29 = l_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___spec__2(x_4, x_19, x_26, x_28, x_5, x_23); return x_29; } else @@ -378,11 +346,11 @@ return x_22; } } } -lean_object* l_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___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_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___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_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___spec__3(x_1, x_2, x_3, x_4, x_5, x_6); +x_7 = l_Lean_Expr_withAppAux___main___at_Lean_Meta_revert___spec__2(x_1, x_2, x_3, x_4, x_5, x_6); lean_dec(x_5); return x_7; } diff --git a/stage0/stdlib/Init/Lean/Meta/WHNF.c b/stage0/stdlib/Init/Lean/Meta/WHNF.c index ad75eb6b92..0ec3ba68bf 100644 --- a/stage0/stdlib/Init/Lean/Meta/WHNF.c +++ b/stage0/stdlib/Init/Lean/Meta/WHNF.c @@ -11076,7 +11076,7 @@ lean_object* x_7; lean_object* x_8; lean_object* x_9; x_7 = lean_ctor_get(x_6, 0); lean_inc(x_7); lean_dec(x_6); -x_8 = lean_alloc_ctor(20, 1, 0); +x_8 = lean_alloc_ctor(21, 1, 0); lean_ctor_set(x_8, 0, x_7); x_9 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_9, 0, x_8); diff --git a/stage0/stdlib/Init/Lean/Parser/Level.c b/stage0/stdlib/Init/Lean/Parser/Level.c index 0e38431dfe..cbfca4ccf2 100644 --- a/stage0/stdlib/Init/Lean/Parser/Level.c +++ b/stage0/stdlib/Init/Lean/Parser/Level.c @@ -28,7 +28,6 @@ extern lean_object* l_Lean_identKind___closed__1; lean_object* l_Lean_Parser_Level_num___closed__4; lean_object* l_Lean_Parser_Level_max___elambda__1___closed__6; lean_object* l_Lean_Parser_regBuiltinLevelParserAttr(lean_object*); -lean_object* l_Lean_Parser_Level_num___elambda__1___closed__4; lean_object* l_Lean_Parser_Level_hole___closed__5; lean_object* l_Lean_Parser_Level_hole___closed__3; lean_object* l_Lean_Parser_regBuiltinLevelParserAttr___closed__2; @@ -72,6 +71,7 @@ lean_object* l_Lean_Parser_Level_ident___closed__3; lean_object* l___regBuiltinParser_Lean_Parser_Level_paren(lean_object*); uint8_t lean_nat_dec_eq(lean_object*, lean_object*); lean_object* l_Lean_Parser_nonReservedSymbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*); +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_imax___elambda__1___closed__2; @@ -1984,37 +1984,29 @@ return x_6; lean_object* _init_l_Lean_Parser_Level_num___elambda__1___closed__1() { _start: { -lean_object* x_1; -x_1 = lean_mk_string("num"); -return x_1; +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Parser_Level_paren___elambda__1___closed__2; +x_2 = l_Lean_Nat_HasQuote___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; } } lean_object* _init_l_Lean_Parser_Level_num___elambda__1___closed__2() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Parser_Level_paren___elambda__1___closed__2; -x_2 = l_Lean_Parser_Level_num___elambda__1___closed__1; -x_3 = lean_name_mk_string(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_Level_num___elambda__1___closed__3() { -_start: -{ lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_Level_num___elambda__1___closed__2; +x_1 = l_Lean_Parser_Level_num___elambda__1___closed__1; x_2 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l_Lean_Parser_Level_num___elambda__1___closed__4() { +lean_object* _init_l_Lean_Parser_Level_num___elambda__1___closed__3() { _start: { lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Level_num___elambda__1___closed__1; -x_2 = l_Lean_Parser_Level_num___elambda__1___closed__3; +x_1 = l_Lean_Nat_HasQuote___closed__1; +x_2 = l_Lean_Parser_Level_num___elambda__1___closed__2; x_3 = 1; x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3); return x_4; @@ -2024,7 +2016,7 @@ lean_object* l_Lean_Parser_Level_num___elambda__1(lean_object* x_1, lean_object* _start: { lean_object* x_3; lean_object* x_4; uint8_t x_5; -x_3 = l_Lean_Parser_Level_num___elambda__1___closed__4; +x_3 = l_Lean_Parser_Level_num___elambda__1___closed__3; x_4 = lean_ctor_get(x_3, 1); lean_inc(x_4); lean_inc(x_2); @@ -2039,7 +2031,7 @@ 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__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; } @@ -2092,7 +2084,7 @@ lean_inc(x_20); x_21 = lean_array_get_size(x_20); 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__2; +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); @@ -2109,7 +2101,7 @@ 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_num___elambda__1___closed__2; +x_3 = l_Lean_Parser_Level_num___elambda__1___closed__1; x_4 = l_Lean_Parser_nodeInfo(x_3, x_2); return x_4; } @@ -2118,7 +2110,7 @@ lean_object* _init_l_Lean_Parser_Level_num___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Level_num___elambda__1___closed__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; @@ -2159,7 +2151,7 @@ _start: { lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; x_2 = l_Lean_Parser_regBuiltinLevelParserAttr___closed__4; -x_3 = l_Lean_Parser_Level_num___elambda__1___closed__2; +x_3 = l_Lean_Parser_Level_num___elambda__1___closed__1; x_4 = 1; x_5 = l_Lean_Parser_Level_num; x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1); @@ -2729,8 +2721,6 @@ l_Lean_Parser_Level_num___elambda__1___closed__2 = _init_l_Lean_Parser_Level_num lean_mark_persistent(l_Lean_Parser_Level_num___elambda__1___closed__2); l_Lean_Parser_Level_num___elambda__1___closed__3 = _init_l_Lean_Parser_Level_num___elambda__1___closed__3(); lean_mark_persistent(l_Lean_Parser_Level_num___elambda__1___closed__3); -l_Lean_Parser_Level_num___elambda__1___closed__4 = _init_l_Lean_Parser_Level_num___elambda__1___closed__4(); -lean_mark_persistent(l_Lean_Parser_Level_num___elambda__1___closed__4); l_Lean_Parser_Level_num___closed__1 = _init_l_Lean_Parser_Level_num___closed__1(); lean_mark_persistent(l_Lean_Parser_Level_num___closed__1); l_Lean_Parser_Level_num___closed__2 = _init_l_Lean_Parser_Level_num___closed__2(); diff --git a/stage0/stdlib/Init/Lean/Parser/Module.c b/stage0/stdlib/Init/Lean/Parser/Module.c index 054e9c7f77..9e7a571b00 100644 --- a/stage0/stdlib/Init/Lean/Parser/Module.c +++ b/stage0/stdlib/Init/Lean/Parser/Module.c @@ -165,7 +165,7 @@ extern lean_object* l_Lean_mkOptionalNode___closed__2; lean_object* l_Lean_Parser_Module_import___elambda__1___closed__10; uint8_t l_PersistentArray_anyM___at_Lean_MessageLog_hasErrors___spec__1(lean_object*); lean_object* l_Lean_Parser_Module_prelude___elambda__1___closed__3; -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, lean_object*, lean_object*); +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; lean_object* l_Array_forMAux___main___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__10(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Parser_Module_1__mkErrorMessage___boxed(lean_object*, lean_object*, lean_object*); @@ -1950,7 +1950,6 @@ _start: { lean_object* x_4; x_4 = l___private_Init_Lean_Parser_Module_1__mkErrorMessage(x_1, x_2, x_3); -lean_dec(x_2); lean_dec(x_1); return x_4; } @@ -2007,6 +2006,7 @@ x_20 = lean_ctor_get(x_9, 1); lean_inc(x_20); lean_dec(x_9); x_21 = l_Lean_Parser_Error_toString(x_19); +lean_inc(x_20); x_22 = l___private_Init_Lean_Parser_Module_1__mkErrorMessage(x_4, x_20, x_21); lean_dec(x_4); x_23 = 1; @@ -2220,6 +2220,7 @@ x_28 = lean_ctor_get(x_19, 1); lean_inc(x_28); lean_dec(x_19); x_29 = l_Lean_Parser_Error_toString(x_27); +lean_inc(x_28); x_30 = l___private_Init_Lean_Parser_Module_1__mkErrorMessage(x_11, x_28, x_29); x_31 = l_PersistentArray_push___rarg(x_4, x_30); x_32 = l___private_Init_Lean_Parser_Module_3__consumeInput(x_11, x_28); @@ -2304,6 +2305,7 @@ x_57 = lean_ctor_get(x_47, 1); lean_inc(x_57); lean_dec(x_47); x_58 = l_Lean_Parser_Error_toString(x_56); +lean_inc(x_57); x_59 = l___private_Init_Lean_Parser_Module_1__mkErrorMessage(x_39, x_57, x_58); x_60 = l_PersistentArray_push___rarg(x_4, x_59); x_61 = l___private_Init_Lean_Parser_Module_3__consumeInput(x_39, x_57); @@ -2361,15 +2363,16 @@ return x_5; lean_object* l_IO_print___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__2(lean_object* x_1, lean_object* x_2) { _start: { -lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; x_3 = lean_box(0); -x_4 = lean_unsigned_to_nat(0u); -x_5 = l_Lean_Syntax_formatStxAux___main(x_3, x_4, x_1); -x_6 = l_Lean_Options_empty; -x_7 = l_Lean_Format_pretty(x_5, x_6); -x_8 = lean_io_prim_put_str(x_7, x_2); -lean_dec(x_7); -return x_8; +x_4 = 0; +x_5 = lean_unsigned_to_nat(0u); +x_6 = l_Lean_Syntax_formatStxAux___main(x_3, x_4, x_5, x_1); +x_7 = l_Lean_Options_empty; +x_8 = l_Lean_Format_pretty(x_6, x_7); +x_9 = lean_io_prim_put_str(x_8, x_2); +lean_dec(x_8); +return x_9; } } lean_object* l_IO_println___at___private_Init_Lean_Parser_Module_4__testModuleParserAux___main___spec__1(lean_object* x_1, lean_object* x_2) { diff --git a/stage0/stdlib/Init/Lean/Parser/Parser.c b/stage0/stdlib/Init/Lean/Parser/Parser.c index e13aa0569f..49f3c128b0 100644 --- a/stage0/stdlib/Init/Lean/Parser/Parser.c +++ b/stage0/stdlib/Init/Lean/Parser/Parser.c @@ -78,6 +78,7 @@ lean_object* lean_mk_empty_array_with_capacity(lean_object*); lean_object* l_Lean_Parser_sepByInfo(lean_object*, lean_object*); lean_object* l_Lean_Parser_ParserState_shrinkStack___boxed(lean_object*, lean_object*); lean_object* l_Lean_registerEnvExtensionUnsafe___at_Lean_Parser_mkCategoryParserFnExtension___spec__1___lambda__1(lean_object*, lean_object*, lean_object*); +lean_object* lean_nat_div(lean_object*, lean_object*); lean_object* l_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg___boxed(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Parser_Parser_18__ParserExtension_mkInitial(lean_object*); lean_object* l_Lean_Parser_decimalNumberFn___boxed(lean_object*, lean_object*, lean_object*); @@ -90,6 +91,7 @@ lean_object* l_Lean_Parser_strLitNoAntiquot; lean_object* l_Lean_Parser_octalNumberFn___closed__1; lean_object* l_Lean_Parser_many1___boxed(lean_object*, lean_object*); lean_object* l_Lean_Parser_many(lean_object*); +lean_object* l_List_eraseRepsAux___main___at_Lean_Parser_Error_toString___spec__5(lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_identKind___closed__1; lean_object* l_Lean_Parser_FirstTokens_toStr(lean_object*); lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepBy___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -164,6 +166,7 @@ extern lean_object* l_Array_empty___closed__1; lean_object* l_Lean_Parser_regTermParserAttribute(lean_object*); lean_object* l_PersistentHashMap_containsAux___main___at_Lean_Parser_isValidSyntaxNodeKind___spec__2___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_PersistentHashMap_findAtAux___main___at_Lean_Parser_addLeadingParser___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_List_eraseReps___at_Lean_Parser_Error_toString___spec__4(lean_object*); lean_object* l_Lean_Parser_ParserState_pushSyntax(lean_object*, lean_object*); lean_object* l_Lean_Parser_mkAntiquot___closed__17; lean_object* l_Lean_Syntax_foldSepArgsM(lean_object*, lean_object*); @@ -294,6 +297,7 @@ lean_object* l_Lean_Parser_unquotedSymbol___closed__2; extern lean_object* l_Lean_LocalContext_Inhabited___closed__1; lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_binNumberFn___spec__3___boxed(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at___private_Init_Lean_Parser_Parser_24__ParserExtension_addImported___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Parser_Error_toString___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_anyRangeMAux___main___at_Lean_Parser_mkParserExtension___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_mkCategoryAntiquotParser(lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Parser_Parser_28__registerParserAttributeImplBuilder___lambda__1___closed__1; @@ -449,6 +453,7 @@ lean_object* l_Lean_Parser_checkNoWsBefore(lean_object*); lean_object* l_Lean_Parser_noFirstTokenInfo(lean_object*); lean_object* l___private_Init_Lean_Parser_Parser_26__BuiltinParserAttribute_add___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); 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_Lean_Syntax_forArgsM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -542,6 +547,7 @@ size_t l_Lean_Name_hash(lean_object*); lean_object* l___private_Init_Lean_Parser_Parser_15__throwParserCategoryAlreadyDefined___rarg(lean_object*); lean_object* l_Lean_Parser_addToken(lean_object*, lean_object*); lean_object* l_Lean_Parser_nameLit___closed__1; +lean_object* l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Parser_Error_toString___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Nat_repr(lean_object*); lean_object* l_Lean_Parser_categoryParserOfStack(lean_object*, lean_object*); extern lean_object* l_Char_HasRepr___closed__1; @@ -637,6 +643,7 @@ lean_object* l_Lean_Parser_addParserCategory___boxed(lean_object*, lean_object*, lean_object* l___private_Init_Lean_Parser_Parser_17__addBuiltinParserCategory___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_registerBuiltinParserAttribute(lean_object*, lean_object*, uint8_t, lean_object*); lean_object* l_Lean_Parser_charLitNoAntiquot___closed__1; +lean_object* l_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; extern lean_object* l___private_Init_Lean_Environment_5__envExtensionsRef; lean_object* l___private_Init_Lean_Parser_Parser_24__ParserExtension_addImported(lean_object*, lean_object*, lean_object*); @@ -925,6 +932,7 @@ lean_object* l_Lean_Parser_dollarSymbol___elambda__1___closed__4; lean_object* l_Lean_Parser_compileParserDescr___main(lean_object*, lean_object*); lean_object* l_Lean_Parser_regBuiltinTermParserAttr(lean_object*); lean_object* l_Lean_Parser_nodeFn(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; @@ -942,6 +950,7 @@ lean_object* l_Lean_Parser_ParserState_mkLongestNodeAlt(lean_object*, lean_objec lean_object* l_Lean_Parser_currLbp(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*); extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__2; lean_object* l_Lean_Parser_sepByInfo___elambda__2(lean_object*, lean_object*, lean_object*); @@ -1060,6 +1069,7 @@ lean_object* l_Lean_Parser_ParserState_keepPrevError(lean_object*, lean_object*, lean_object* l_Lean_Parser_mkAntiquot___closed__25; lean_object* l_Lean_Parser_checkWsBefore___elambda__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Parser_ParserFn_inhabited___rarg___boxed(lean_object*); +extern lean_object* l_String_Inhabited; lean_object* l_List_eraseDups___at_Lean_Parser_addLeadingParser___spec__5(lean_object*); uint8_t l___private_Init_Lean_Parser_Parser_5__isIdFirstOrBeginEscape(uint32_t); lean_object* l_Lean_Parser_mkParserOfConstantUnsafe___closed__3; @@ -1126,6 +1136,7 @@ lean_object* l_Lean_Parser_nonReservedSymbolInfo___boxed(lean_object*, lean_obje 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*); +uint8_t lean_string_dec_lt(lean_object*, lean_object*); lean_object* l_Lean_Parser_parserExtension___elambda__3(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Parser_Parser_19__mergePrecendences___closed__3; lean_object* l_Lean_Parser_fieldIdxFn(lean_object*, lean_object*); @@ -2199,6 +2210,286 @@ goto _start; } } } +lean_object* l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Parser_Error_toString___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = lean_nat_dec_lt(x_5, x_1); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; +lean_dec(x_5); +x_7 = lean_array_swap(x_3, x_4, x_1); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_4); +lean_ctor_set(x_8, 1, x_7); +return x_8; +} +else +{ +lean_object* x_9; lean_object* x_10; uint8_t x_11; +x_9 = l_String_Inhabited; +x_10 = lean_array_get(x_9, x_3, x_5); +x_11 = lean_string_dec_lt(x_10, x_2); +lean_dec(x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_unsigned_to_nat(1u); +x_13 = lean_nat_add(x_5, x_12); +lean_dec(x_5); +x_5 = x_13; +goto _start; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_15 = lean_array_swap(x_3, x_4, x_5); +x_16 = lean_unsigned_to_nat(1u); +x_17 = lean_nat_add(x_4, x_16); +lean_dec(x_4); +x_18 = lean_nat_add(x_5, x_16); +lean_dec(x_5); +x_3 = x_15; +x_4 = x_17; +x_5 = x_18; +goto _start; +} +} +} +} +lean_object* l_Array_qsortAux___main___at_Lean_Parser_Error_toString___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_13; +x_13 = lean_nat_dec_lt(x_2, x_3); +if (x_13 == 0) +{ +lean_dec(x_2); +return x_1; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_14 = lean_nat_add(x_2, x_3); +x_15 = lean_unsigned_to_nat(2u); +x_16 = lean_nat_div(x_14, x_15); +lean_dec(x_14); +x_37 = l_String_Inhabited; +x_38 = lean_array_get(x_37, x_1, x_16); +x_39 = lean_array_get(x_37, x_1, x_2); +x_40 = lean_string_dec_lt(x_38, x_39); +lean_dec(x_39); +lean_dec(x_38); +if (x_40 == 0) +{ +x_17 = x_1; +goto block_36; +} +else +{ +lean_object* x_41; +x_41 = lean_array_swap(x_1, x_2, x_16); +x_17 = x_41; +goto block_36; +} +block_36: +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_18 = l_String_Inhabited; +x_19 = lean_array_get(x_18, x_17, x_3); +x_20 = lean_array_get(x_18, x_17, x_2); +x_21 = lean_string_dec_lt(x_19, x_20); +lean_dec(x_20); +if (x_21 == 0) +{ +lean_object* x_22; uint8_t x_23; +x_22 = lean_array_get(x_18, x_17, x_16); +x_23 = lean_string_dec_lt(x_22, x_19); +lean_dec(x_22); +if (x_23 == 0) +{ +lean_object* x_24; +lean_dec(x_16); +lean_inc_n(x_2, 2); +x_24 = l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Parser_Error_toString___spec__3(x_3, x_19, x_17, x_2, x_2); +lean_dec(x_19); +x_4 = x_24; +goto block_12; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_dec(x_19); +x_25 = lean_array_swap(x_17, x_16, x_3); +lean_dec(x_16); +x_26 = lean_array_get(x_18, x_25, x_3); +lean_inc_n(x_2, 2); +x_27 = l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Parser_Error_toString___spec__3(x_3, x_26, x_25, x_2, x_2); +lean_dec(x_26); +x_4 = x_27; +goto block_12; +} +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; +lean_dec(x_19); +x_28 = lean_array_swap(x_17, x_2, x_3); +x_29 = lean_array_get(x_18, x_28, x_16); +x_30 = lean_array_get(x_18, x_28, x_3); +x_31 = lean_string_dec_lt(x_29, x_30); +lean_dec(x_29); +if (x_31 == 0) +{ +lean_object* x_32; +lean_dec(x_16); +lean_inc_n(x_2, 2); +x_32 = l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Parser_Error_toString___spec__3(x_3, x_30, x_28, x_2, x_2); +lean_dec(x_30); +x_4 = x_32; +goto block_12; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_dec(x_30); +x_33 = lean_array_swap(x_28, x_16, x_3); +lean_dec(x_16); +x_34 = lean_array_get(x_18, x_33, x_3); +lean_inc_n(x_2, 2); +x_35 = l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Parser_Error_toString___spec__3(x_3, x_34, x_33, x_2, x_2); +lean_dec(x_34); +x_4 = x_35; +goto block_12; +} +} +} +} +block_12: +{ +lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_4, 1); +lean_inc(x_6); +lean_dec(x_4); +x_7 = lean_nat_dec_le(x_3, x_5); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = l_Array_qsortAux___main___at_Lean_Parser_Error_toString___spec__2(x_6, x_2, x_5); +x_9 = lean_unsigned_to_nat(1u); +x_10 = lean_nat_add(x_5, x_9); +lean_dec(x_5); +x_1 = x_8; +x_2 = x_10; +goto _start; +} +else +{ +lean_dec(x_5); +lean_dec(x_2); +return x_6; +} +} +} +} +lean_object* l_List_eraseRepsAux___main___at_Lean_Parser_Error_toString___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; lean_object* x_5; +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 = l_List_reverse___rarg(x_4); +return x_5; +} +else +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_2); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; uint8_t x_9; +x_7 = lean_ctor_get(x_2, 0); +x_8 = lean_ctor_get(x_2, 1); +x_9 = lean_string_dec_eq(x_1, x_7); +if (x_9 == 0) +{ +lean_ctor_set(x_2, 1, x_3); +lean_ctor_set(x_2, 0, x_1); +{ +lean_object* _tmp_0 = x_7; +lean_object* _tmp_1 = x_8; +lean_object* _tmp_2 = x_2; +x_1 = _tmp_0; +x_2 = _tmp_1; +x_3 = _tmp_2; +} +goto _start; +} +else +{ +lean_free_object(x_2); +lean_dec(x_7); +x_2 = x_8; +goto _start; +} +} +else +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_2, 0); +x_13 = lean_ctor_get(x_2, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_2); +x_14 = lean_string_dec_eq(x_1, x_12); +if (x_14 == 0) +{ +lean_object* x_15; +x_15 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_15, 0, x_1); +lean_ctor_set(x_15, 1, x_3); +x_1 = x_12; +x_2 = x_13; +x_3 = x_15; +goto _start; +} +else +{ +lean_dec(x_12); +x_2 = x_13; +goto _start; +} +} +} +} +} +lean_object* l_List_eraseReps___at_Lean_Parser_Error_toString___spec__4(lean_object* x_1) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +return x_1; +} +else +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +x_3 = lean_ctor_get(x_1, 1); +lean_inc(x_3); +lean_dec(x_1); +x_4 = lean_box(0); +x_5 = l_List_eraseRepsAux___main___at_Lean_Parser_Error_toString___spec__5(x_2, x_3, x_4); +return x_5; +} +} +} lean_object* _init_l_Lean_Parser_Error_toString___closed__1() { _start: { @@ -2255,27 +2546,41 @@ lean_ctor_set(x_8, 0, x_2); lean_ctor_set(x_8, 1, x_6); if (x_7 == 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; lean_object* x_15; -x_9 = l___private_Init_Lean_Parser_Parser_1__expectedToString___main(x_3); -x_10 = l_Lean_Parser_Error_toString___closed__1; -x_11 = lean_string_append(x_10, x_9); +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_9 = l_List_redLength___main___rarg(x_3); +x_10 = lean_mk_empty_array_with_capacity(x_9); lean_dec(x_9); -x_12 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_12, 0, x_11); -lean_ctor_set(x_12, 1, x_6); -x_13 = l_List_append___rarg(x_8, x_12); -x_14 = l_Lean_Parser_Error_toString___closed__2; -x_15 = l_String_intercalate(x_14, x_13); -return x_15; +x_11 = l_List_toArrayAux___main___rarg(x_3, x_10); +x_12 = lean_array_get_size(x_11); +x_13 = lean_unsigned_to_nat(1u); +x_14 = lean_nat_sub(x_12, x_13); +lean_dec(x_12); +x_15 = lean_unsigned_to_nat(0u); +x_16 = l_Array_qsortAux___main___at_Lean_Parser_Error_toString___spec__2(x_11, x_15, x_14); +lean_dec(x_14); +x_17 = l_Array_toList___rarg(x_16); +lean_dec(x_16); +x_18 = l_List_eraseReps___at_Lean_Parser_Error_toString___spec__4(x_17); +x_19 = l___private_Init_Lean_Parser_Parser_1__expectedToString___main(x_18); +x_20 = l_Lean_Parser_Error_toString___closed__1; +x_21 = lean_string_append(x_20, x_19); +lean_dec(x_19); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_6); +x_23 = l_List_append___rarg(x_8, x_22); +x_24 = l_Lean_Parser_Error_toString___closed__2; +x_25 = l_String_intercalate(x_24, x_23); +return x_25; } else { -lean_object* x_16; lean_object* x_17; lean_object* x_18; +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_dec(x_3); -x_16 = l_List_append___rarg(x_8, x_6); -x_17 = l_Lean_Parser_Error_toString___closed__2; -x_18 = l_String_intercalate(x_17, x_16); -return x_18; +x_26 = l_List_append___rarg(x_8, x_6); +x_27 = l_Lean_Parser_Error_toString___closed__2; +x_28 = l_String_intercalate(x_27, x_26); +return x_28; } } else @@ -2283,25 +2588,39 @@ else lean_dec(x_2); if (x_7 == 0) { -lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; -x_19 = l___private_Init_Lean_Parser_Parser_1__expectedToString___main(x_3); -x_20 = l_Lean_Parser_Error_toString___closed__1; -x_21 = lean_string_append(x_20, x_19); -lean_dec(x_19); -x_22 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_22, 0, x_21); -lean_ctor_set(x_22, 1, x_6); -x_23 = l_List_append___rarg(x_6, x_22); -x_24 = l_Lean_Parser_Error_toString___closed__2; -x_25 = l_String_intercalate(x_24, x_23); -return x_25; +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_29 = l_List_redLength___main___rarg(x_3); +x_30 = lean_mk_empty_array_with_capacity(x_29); +lean_dec(x_29); +x_31 = l_List_toArrayAux___main___rarg(x_3, x_30); +x_32 = lean_array_get_size(x_31); +x_33 = lean_unsigned_to_nat(1u); +x_34 = lean_nat_sub(x_32, x_33); +lean_dec(x_32); +x_35 = lean_unsigned_to_nat(0u); +x_36 = l_Array_qsortAux___main___at_Lean_Parser_Error_toString___spec__2(x_31, x_35, x_34); +lean_dec(x_34); +x_37 = l_Array_toList___rarg(x_36); +lean_dec(x_36); +x_38 = l_List_eraseReps___at_Lean_Parser_Error_toString___spec__4(x_37); +x_39 = l___private_Init_Lean_Parser_Parser_1__expectedToString___main(x_38); +x_40 = l_Lean_Parser_Error_toString___closed__1; +x_41 = lean_string_append(x_40, x_39); +lean_dec(x_39); +x_42 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_6); +x_43 = l_List_append___rarg(x_6, x_42); +x_44 = l_Lean_Parser_Error_toString___closed__2; +x_45 = l_String_intercalate(x_44, x_43); +return x_45; } else { -lean_object* x_26; +lean_object* x_46; lean_dec(x_3); -x_26 = l_Lean_Parser_Error_toString___closed__4; -return x_26; +x_46 = l_Lean_Parser_Error_toString___closed__4; +return x_46; } } } @@ -2317,6 +2636,25 @@ x_4 = lean_box(x_3); return x_4; } } +lean_object* l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Parser_Error_toString___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l___private_Init_Data_Array_QSort_1__partitionAux___main___at_Lean_Parser_Error_toString___spec__3(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_2); +lean_dec(x_1); +return x_6; +} +} +lean_object* l_Array_qsortAux___main___at_Lean_Parser_Error_toString___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Array_qsortAux___main___at_Lean_Parser_Error_toString___spec__2(x_1, x_2, x_3); +lean_dec(x_3); +return x_4; +} +} lean_object* _init_l_Lean_Parser_Error_HasToString___closed__1() { _start: { @@ -2791,7 +3129,6 @@ x_8 = lean_ctor_get(x_2, 1); lean_inc(x_8); lean_dec(x_2); x_9 = l_Lean_FileMap_toPosition(x_7, x_8); -lean_dec(x_8); lean_dec(x_7); x_10 = lean_ctor_get(x_6, 1); lean_inc(x_10); @@ -12551,7 +12888,6 @@ x_6 = lean_ctor_get(x_5, 2); x_7 = lean_ctor_get(x_4, 1); lean_inc(x_7); x_8 = l_Lean_FileMap_toPosition(x_6, x_7); -lean_dec(x_7); x_9 = lean_ctor_get(x_8, 1); lean_inc(x_9); lean_dec(x_8); @@ -12606,7 +12942,6 @@ lean_dec(x_4); x_6 = lean_ctor_get(x_3, 1); lean_inc(x_6); x_7 = l_Lean_FileMap_toPosition(x_5, x_6); -lean_dec(x_6); lean_dec(x_5); x_8 = lean_apply_1(x_1, x_7); x_9 = lean_ctor_get(x_8, 1); @@ -12656,6 +12991,7 @@ lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_ob x_7 = lean_ctor_get(x_3, 0); x_8 = lean_ctor_get(x_7, 2); x_9 = lean_ctor_get(x_4, 1); +lean_inc(x_9); x_10 = l_Lean_FileMap_toPosition(x_8, x_9); x_11 = lean_ctor_get(x_10, 1); lean_inc(x_11); @@ -12673,6 +13009,7 @@ lean_inc(x_32); x_33 = lean_ctor_get(x_32, 2); lean_inc(x_33); lean_dec(x_32); +lean_inc(x_15); x_34 = l_Lean_FileMap_toPosition(x_33, x_15); lean_dec(x_33); x_35 = lean_ctor_get(x_34, 1); @@ -12724,6 +13061,7 @@ else { lean_object* x_23; lean_object* x_24; lean_dec(x_5); +lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); x_23 = l_Lean_Parser_manyAux___main___closed__1; @@ -12736,6 +13074,7 @@ else lean_object* x_25; uint8_t x_26; lean_dec(x_19); lean_dec(x_5); +lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); x_25 = lean_ctor_get(x_18, 1); @@ -12763,6 +13102,7 @@ lean_object* x_28; uint8_t x_29; lean_dec(x_17); lean_dec(x_12); lean_dec(x_5); +lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); x_28 = lean_ctor_get(x_16, 1); @@ -12793,6 +13133,7 @@ lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_ob x_7 = lean_ctor_get(x_3, 0); x_8 = lean_ctor_get(x_7, 2); x_9 = lean_ctor_get(x_4, 1); +lean_inc(x_9); x_10 = l_Lean_FileMap_toPosition(x_8, x_9); x_11 = lean_ctor_get(x_10, 1); lean_inc(x_11); @@ -12810,6 +13151,7 @@ lean_inc(x_32); x_33 = lean_ctor_get(x_32, 2); lean_inc(x_33); lean_dec(x_32); +lean_inc(x_15); x_34 = l_Lean_FileMap_toPosition(x_33, x_15); lean_dec(x_33); x_35 = lean_ctor_get(x_34, 1); @@ -12861,6 +13203,7 @@ else { lean_object* x_23; lean_object* x_24; lean_dec(x_5); +lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); x_23 = l_Lean_Parser_manyAux___main___closed__1; @@ -12873,6 +13216,7 @@ else lean_object* x_25; uint8_t x_26; lean_dec(x_19); lean_dec(x_5); +lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); x_25 = lean_ctor_get(x_18, 1); @@ -12900,6 +13244,7 @@ lean_object* x_28; uint8_t x_29; lean_dec(x_17); lean_dec(x_12); lean_dec(x_5); +lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); x_28 = lean_ctor_get(x_16, 1); @@ -12935,7 +13280,6 @@ lean_dec(x_5); x_7 = lean_ctor_get(x_4, 1); lean_inc(x_7); x_8 = l_Lean_FileMap_toPosition(x_6, x_7); -lean_dec(x_7); lean_dec(x_6); x_9 = lean_ctor_get(x_8, 1); lean_inc(x_9); @@ -12977,7 +13321,6 @@ if (lean_obj_tag(x_19) == 0) lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_inc(x_3); x_20 = l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2(x_1, x_2, x_3, x_4, x_3, x_18); -lean_dec(x_4); lean_dec(x_3); x_21 = l_Lean_nullKind; x_22 = l_Lean_Parser_ParserState_mkNode(x_20, x_21, x_12); @@ -13033,7 +13376,6 @@ _start: { lean_object* x_7; x_7 = l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__1(x_1, x_2, x_3, x_4, x_5, x_6); -lean_dec(x_4); lean_dec(x_3); return x_7; } @@ -13043,7 +13385,6 @@ _start: { lean_object* x_7; x_7 = l_Lean_Parser_manyAux___main___at_Lean_Parser_many1Indent___spec__2(x_1, x_2, x_3, x_4, x_5, x_6); -lean_dec(x_4); lean_dec(x_3); return x_7; } diff --git a/stage0/stdlib/Init/Lean/Parser/Syntax.c b/stage0/stdlib/Init/Lean/Parser/Syntax.c index 409f5816e4..d73fc548e3 100644 --- a/stage0/stdlib/Init/Lean/Parser/Syntax.c +++ b/stage0/stdlib/Init/Lean/Parser/Syntax.c @@ -117,7 +117,6 @@ lean_object* l_Lean_Parser_Command_macroArgSimple___closed__4; lean_object* l_Lean_Parser_Syntax_str___closed__5; lean_object* l_Lean_Parser_Command_macroTailCommand___closed__5; lean_object* l_Lean_Parser_Command_strLitPrec___closed__1; -extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__1; lean_object* l_Lean_Parser_Command_strLitPrec___elambda__1___closed__3; lean_object* l_Lean_Parser_Command_syntaxCat___elambda__1___closed__7; lean_object* l_Lean_Parser_Command_macroArgSimple___closed__1; @@ -237,6 +236,7 @@ lean_object* l_Lean_Parser_Command_quotedSymbolPrec___elambda__1(lean_object*, l lean_object* l_Lean_Parser_Syntax_many1___closed__1; lean_object* l_Lean_Parser_Command_macroHead___elambda__1(lean_object*, lean_object*); lean_object* l___regBuiltinParser_Lean_Parser_Syntax_lookahead(lean_object*); +extern lean_object* l_Lean_Nat_HasQuote___closed__1; lean_object* l_Lean_Parser_Command_notation___closed__5; lean_object* l_Lean_Parser_nodeInfo(lean_object*, lean_object*); lean_object* l_Lean_Parser_Command_infix___closed__1; @@ -287,6 +287,7 @@ lean_object* l_Lean_Parser_Command_macro__rules___elambda__1___closed__6; lean_object* l_Lean_Parser_Command_macroTailCommand___closed__2; lean_object* l_Lean_Parser_Command_postfix___closed__5; lean_object* l_Lean_Parser_Command_postfix___elambda__1___closed__3; +extern lean_object* l_Lean_String_HasQuote___closed__1; lean_object* l_Lean_Parser_Command_macroArgSimple; uint8_t l_Lean_Parser_tryAnti(lean_object*, lean_object*); lean_object* l_Lean_Parser_Command_syntax___closed__7; @@ -404,7 +405,6 @@ lean_object* l_Lean_Parser_Command_reserve___closed__4; lean_object* l___regBuiltinParser_Lean_Parser_Syntax_paren(lean_object*); lean_object* l_Lean_Parser_Command_notation___elambda__1___closed__2; lean_object* l_Lean_Parser_Syntax_char___elambda__1___closed__4; -extern lean_object* l_Lean_Parser_Term_str___elambda__1___closed__1; lean_object* l_Lean_Parser_Syntax_cat___elambda__1___closed__3; lean_object* l_Lean_Parser_Command_postfix___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_Syntax_lookahead___elambda__1___closed__1; @@ -2677,7 +2677,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Syntax_paren___elambda__1___closed__2; -x_2 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_2 = l_Lean_Nat_HasQuote___closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } @@ -2696,7 +2696,7 @@ lean_object* _init_l_Lean_Parser_Syntax_num___elambda__1___closed__3() { _start: { lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_1 = l_Lean_Nat_HasQuote___closed__1; x_2 = l_Lean_Parser_Syntax_num___elambda__1___closed__2; x_3 = 1; x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3); @@ -2707,7 +2707,7 @@ lean_object* _init_l_Lean_Parser_Syntax_num___elambda__1___closed__4() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_Level_num___elambda__1___closed__1; +x_1 = l_Lean_Nat_HasQuote___closed__1; x_2 = l_String_trim(x_1); return x_2; } @@ -2895,7 +2895,7 @@ _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Parser_Syntax_paren___elambda__1___closed__2; -x_2 = l_Lean_Parser_Term_str___elambda__1___closed__1; +x_2 = l_Lean_String_HasQuote___closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } @@ -2914,7 +2914,7 @@ lean_object* _init_l_Lean_Parser_Syntax_str___elambda__1___closed__3() { _start: { lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Term_str___elambda__1___closed__1; +x_1 = l_Lean_String_HasQuote___closed__1; x_2 = l_Lean_Parser_Syntax_str___elambda__1___closed__2; x_3 = 1; x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3); @@ -2925,7 +2925,7 @@ lean_object* _init_l_Lean_Parser_Syntax_str___elambda__1___closed__4() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_Term_str___elambda__1___closed__1; +x_1 = l_Lean_String_HasQuote___closed__1; x_2 = l_String_trim(x_1); return x_2; } diff --git a/stage0/stdlib/Init/Lean/Parser/Tactic.c b/stage0/stdlib/Init/Lean/Parser/Tactic.c index d69dab79b8..6da835018a 100644 --- a/stage0/stdlib/Init/Lean/Parser/Tactic.c +++ b/stage0/stdlib/Init/Lean/Parser/Tactic.c @@ -6902,6 +6902,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -6935,6 +6936,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -6978,6 +6980,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -7092,6 +7095,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -7179,6 +7183,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -7212,6 +7217,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -7255,6 +7261,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -7369,6 +7376,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -7456,6 +7464,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -7489,6 +7498,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -7532,6 +7542,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -7646,6 +7657,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -7733,6 +7745,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -7766,6 +7779,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -7809,6 +7823,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -7923,6 +7938,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -8010,6 +8026,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -8043,6 +8060,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -8086,6 +8104,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -8200,6 +8219,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -8287,6 +8307,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -8320,6 +8341,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -8363,6 +8385,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -8477,6 +8500,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -8600,7 +8624,6 @@ lean_dec(x_3); x_13 = 0; lean_inc(x_1); x_14 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__7(x_1, x_2, x_13, x_13, x_1, x_4); -lean_dec(x_2); lean_dec(x_1); return x_14; } @@ -8699,7 +8722,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__2(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -8713,7 +8735,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__1(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -8729,7 +8750,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__4(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -8743,7 +8763,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__3(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -8759,7 +8778,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__6(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -8773,7 +8791,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__5(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -8789,7 +8806,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__8(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -8803,7 +8819,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__7(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -8819,7 +8834,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__10(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -8833,7 +8847,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__9(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -8849,7 +8862,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__12(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -8863,7 +8875,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Tactic_inductionAlts___elambda__1___spec__11(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } diff --git a/stage0/stdlib/Init/Lean/Parser/Term.c b/stage0/stdlib/Init/Lean/Parser/Term.c index ef075ce1ff..81a96c7cfd 100644 --- a/stage0/stdlib/Init/Lean/Parser/Term.c +++ b/stage0/stdlib/Init/Lean/Parser/Term.c @@ -132,6 +132,7 @@ lean_object* l_Lean_Parser_Term_show___elambda__1___closed__5; extern lean_object* l_Array_iterateMAux___main___at_Lean_ppGoal___spec__6___closed__3; lean_object* l_Lean_Parser_Term_borrowed___elambda__1___closed__7; lean_object* l_Lean_Parser_Term_do___elambda__1___closed__8; +extern lean_object* l_Lean_Nat_HasQuote___closed__2; lean_object* l_Lean_Parser_Term_le; extern lean_object* l_Lean_nullKind; lean_object* l_Lean_Parser_Term_instBinder; @@ -151,7 +152,6 @@ lean_object* l_Lean_Parser_Term_bne___elambda__1___closed__3; lean_object* l_Lean_Parser_Term_suffices___closed__2; lean_object* l_Lean_Parser_Term_doExpr___closed__2; lean_object* l_Lean_Parser_Term_explicit___closed__1; -lean_object* l_Lean_Parser_Term_str___elambda__1___closed__3; lean_object* l_Lean_Parser_Term_andthen___closed__3; lean_object* l_Lean_Parser_Term_not___elambda__1___closed__7; lean_object* l_Lean_Parser_Term_checkIsSort___elambda__1___boxed(lean_object*); @@ -359,7 +359,6 @@ lean_object* l_Lean_Parser_Term_structInstArrayRef___elambda__1___closed__3; lean_object* l_Lean_Parser_Term_tacticBlock___elambda__1___closed__1; lean_object* l___regBuiltinParser_Lean_Parser_Term_do(lean_object*); lean_object* l_Lean_Parser_Term_num___elambda__1___closed__2; -extern lean_object* l_Lean_Parser_Level_num___elambda__1___closed__1; lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__9; lean_object* l_Lean_Parser_regTacticParserAttribute___closed__1; lean_object* l_Lean_Parser_Term_letPatDecl___closed__4; @@ -734,6 +733,7 @@ lean_object* l_Lean_Parser_Term_tupleTail___closed__1; lean_object* l_Lean_Parser_Term_not___elambda__1(lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_le___elambda__1___closed__5; lean_object* l_Lean_Parser_Term_tacticStxQuot___closed__1; +extern lean_object* l_Lean_Nat_HasQuote___closed__1; lean_object* l_Lean_Parser_Term_structInstSource___elambda__1___closed__8; lean_object* l_Lean_Parser_Tactic_seq___closed__5; lean_object* l_Lean_Parser_Term_letEqnsDecl___closed__3; @@ -885,6 +885,7 @@ lean_object* l_Lean_Parser_Term_doLet___closed__3; lean_object* l_Lean_Parser_Term_seq___elambda__1___closed__2; lean_object* l_Lean_Parser_Term_bnot___closed__5; lean_object* l_Lean_Parser_Term_structInstField___elambda__1___closed__3; +extern lean_object* l_Lean_String_HasQuote___closed__1; lean_object* l_Lean_Parser_Term_paren___closed__4; uint8_t l_Lean_Parser_tryAnti(lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_funBinderStxQuot; @@ -1224,7 +1225,6 @@ lean_object* l_Lean_Parser_Term_binderDefault___closed__1; lean_object* l_Lean_Parser_Term_have___closed__8; lean_object* l_Lean_Parser_Term_sorry___elambda__1___closed__6; lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__8; -lean_object* l_Lean_Parser_Term_num___elambda__1___closed__3; lean_object* l_Lean_Parser_Term_and___closed__2; lean_object* l___regBuiltinParser_Lean_Parser_Term_funBinderStxQuot(lean_object*); lean_object* l_Lean_Parser_Term_prop___closed__4; @@ -1325,6 +1325,7 @@ lean_object* l_Lean_Parser_Term_append___elambda__1___closed__4; lean_object* l_Lean_Parser_Term_letDecl___closed__4; lean_object* l_Lean_Parser_Term_prod___elambda__1___closed__3; lean_object* l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_String_HasQuote___closed__2; lean_object* l_Lean_Parser_sepByFn___at_Lean_Parser_Term_structInst___elambda__1___spec__1(uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Parser_Term_if___closed__2; lean_object* l_Lean_Parser_Term_haveAssign___elambda__1___closed__4; @@ -1554,7 +1555,6 @@ lean_object* l_Lean_Parser_Term_forall___closed__9; lean_object* l_Lean_Parser_Term_parser_x21___closed__1; lean_object* l_Lean_Parser_Term_inaccessible___closed__3; lean_object* l_Lean_Parser_Term_match__syntax___elambda__1___closed__4; -lean_object* l_Lean_Parser_Term_str___elambda__1___closed__4; lean_object* l_Lean_Parser_Tactic_nonEmptySeq___closed__3; lean_object* l_Lean_Parser_Term_nativeRefl; lean_object* l_Lean_Parser_regTacticParserAttribute(lean_object*); @@ -5004,29 +5004,19 @@ return x_6; lean_object* _init_l_Lean_Parser_Term_num___elambda__1___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_mkAppStx___closed__6; -x_2 = l_Lean_Parser_Level_num___elambda__1___closed__1; -x_3 = lean_name_mk_string(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_Term_num___elambda__1___closed__2() { -_start: -{ lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_1 = l_Lean_Nat_HasQuote___closed__2; x_2 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l_Lean_Parser_Term_num___elambda__1___closed__3() { +lean_object* _init_l_Lean_Parser_Term_num___elambda__1___closed__2() { _start: { lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Level_num___elambda__1___closed__1; -x_2 = l_Lean_Parser_Term_num___elambda__1___closed__2; +x_1 = l_Lean_Nat_HasQuote___closed__1; +x_2 = l_Lean_Parser_Term_num___elambda__1___closed__1; x_3 = 1; x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3); return x_4; @@ -5036,7 +5026,7 @@ lean_object* l_Lean_Parser_Term_num___elambda__1(lean_object* x_1, lean_object* _start: { lean_object* x_3; lean_object* x_4; uint8_t x_5; -x_3 = l_Lean_Parser_Term_num___elambda__1___closed__3; +x_3 = l_Lean_Parser_Term_num___elambda__1___closed__2; x_4 = lean_ctor_get(x_3, 1); lean_inc(x_4); lean_inc(x_2); @@ -5051,7 +5041,7 @@ 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_Term_num___elambda__1___closed__1; +x_9 = l_Lean_Nat_HasQuote___closed__2; x_10 = l_Lean_Parser_ParserState_mkNode(x_8, x_9, x_7); return x_10; } @@ -5104,7 +5094,7 @@ lean_inc(x_20); x_21 = lean_array_get_size(x_20); lean_dec(x_20); x_22 = l_Lean_Parser_numLit___elambda__1(x_1, x_19); -x_23 = l_Lean_Parser_Term_num___elambda__1___closed__1; +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); @@ -5121,7 +5111,7 @@ 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_Term_num___elambda__1___closed__1; +x_3 = l_Lean_Nat_HasQuote___closed__2; x_4 = l_Lean_Parser_nodeInfo(x_3, x_2); return x_4; } @@ -5130,7 +5120,7 @@ lean_object* _init_l_Lean_Parser_Term_num___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Term_num___elambda__1___closed__3; +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; @@ -5171,7 +5161,7 @@ _start: { lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; x_2 = l_Lean_Parser_termParser___closed__2; -x_3 = l_Lean_Parser_Term_num___elambda__1___closed__1; +x_3 = l_Lean_Nat_HasQuote___closed__2; x_4 = 1; x_5 = l_Lean_Parser_Term_num; x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1); @@ -5181,37 +5171,19 @@ return x_6; lean_object* _init_l_Lean_Parser_Term_str___elambda__1___closed__1() { _start: { -lean_object* x_1; -x_1 = lean_mk_string("str"); -return x_1; -} -} -lean_object* _init_l_Lean_Parser_Term_str___elambda__1___closed__2() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_mkAppStx___closed__6; -x_2 = l_Lean_Parser_Term_str___elambda__1___closed__1; -x_3 = lean_name_mk_string(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Parser_Term_str___elambda__1___closed__3() { -_start: -{ lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_1 = l_Lean_String_HasQuote___closed__2; x_2 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_l_Lean_Parser_Term_str___elambda__1___closed__4() { +lean_object* _init_l_Lean_Parser_Term_str___elambda__1___closed__2() { _start: { lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Term_str___elambda__1___closed__1; -x_2 = l_Lean_Parser_Term_str___elambda__1___closed__3; +x_1 = l_Lean_String_HasQuote___closed__1; +x_2 = l_Lean_Parser_Term_str___elambda__1___closed__1; x_3 = 1; x_4 = l_Lean_Parser_mkAntiquot(x_1, x_2, x_3); return x_4; @@ -5221,7 +5193,7 @@ lean_object* l_Lean_Parser_Term_str___elambda__1(lean_object* x_1, lean_object* _start: { lean_object* x_3; lean_object* x_4; uint8_t x_5; -x_3 = l_Lean_Parser_Term_str___elambda__1___closed__4; +x_3 = l_Lean_Parser_Term_str___elambda__1___closed__2; x_4 = lean_ctor_get(x_3, 1); lean_inc(x_4); lean_inc(x_2); @@ -5236,7 +5208,7 @@ 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_Parser_Term_str___elambda__1___closed__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; } @@ -5289,7 +5261,7 @@ lean_inc(x_20); x_21 = lean_array_get_size(x_20); lean_dec(x_20); x_22 = l_Lean_Parser_strLit___elambda__1(x_1, x_19); -x_23 = l_Lean_Parser_Term_str___elambda__1___closed__2; +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); @@ -5306,7 +5278,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; x_1 = l_Lean_Parser_strLit; x_2 = lean_ctor_get(x_1, 0); lean_inc(x_2); -x_3 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_3 = l_Lean_String_HasQuote___closed__2; x_4 = l_Lean_Parser_nodeInfo(x_3, x_2); return x_4; } @@ -5315,7 +5287,7 @@ lean_object* _init_l_Lean_Parser_Term_str___closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_1 = l_Lean_Parser_Term_str___elambda__1___closed__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; @@ -5356,7 +5328,7 @@ _start: { lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; x_2 = l_Lean_Parser_termParser___closed__2; -x_3 = l_Lean_Parser_Term_str___elambda__1___closed__2; +x_3 = l_Lean_String_HasQuote___closed__2; x_4 = 1; x_5 = l_Lean_Parser_Term_str; x_6 = l_Lean_Parser_addBuiltinParser(x_2, x_3, x_4, x_5, x_1); @@ -27306,6 +27278,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -27339,6 +27312,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -27382,6 +27356,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -27496,6 +27471,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -27583,6 +27559,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -27616,6 +27593,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -27659,6 +27637,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -27773,6 +27752,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -27860,6 +27840,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -27893,6 +27874,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -27936,6 +27918,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -28050,6 +28033,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -28137,6 +28121,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -28170,6 +28155,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -28213,6 +28199,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -28327,6 +28314,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -28414,6 +28402,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -28447,6 +28436,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -28490,6 +28480,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -28604,6 +28595,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -28691,6 +28683,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -28724,6 +28717,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -28767,6 +28761,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -28881,6 +28876,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -28968,6 +28964,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -29001,6 +28998,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -29044,6 +29042,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -29158,6 +29157,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -29245,6 +29245,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -29278,6 +29279,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -29321,6 +29323,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -29435,6 +29438,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -29522,6 +29526,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_ x_9 = lean_ctor_get(x_1, 0); x_10 = lean_ctor_get(x_9, 2); x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); x_12 = l_Lean_FileMap_toPosition(x_10, x_11); x_13 = lean_ctor_get(x_12, 1); lean_inc(x_13); @@ -29555,6 +29560,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_55, 2); lean_inc(x_56); lean_dec(x_55); +lean_inc(x_23); x_57 = l_Lean_FileMap_toPosition(x_56, x_23); lean_dec(x_56); x_58 = lean_ctor_get(x_57, 1); @@ -29598,6 +29604,7 @@ else lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_dec(x_25); lean_dec(x_7); +lean_dec(x_2); x_27 = l_Lean_Parser_ParserState_restore(x_24, x_22, x_23); lean_dec(x_22); x_28 = lean_ctor_get(x_27, 0); @@ -29712,6 +29719,7 @@ lean_object* x_62; uint8_t x_63; lean_dec(x_20); lean_dec(x_13); lean_dec(x_7); +lean_dec(x_2); x_62 = lean_ctor_get(x_19, 1); lean_inc(x_62); x_63 = lean_nat_dec_lt(x_18, x_62); @@ -29837,7 +29845,6 @@ lean_dec(x_4); x_14 = 0; lean_inc(x_2); x_15 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(x_2, x_3, x_14, x_14, x_2, x_5); -lean_dec(x_3); lean_dec(x_2); return x_15; } @@ -29949,7 +29956,6 @@ uint8_t x_28; lean_object* x_29; x_28 = 0; lean_inc(x_2); x_29 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(x_2, x_3, x_28, x_28, x_2, x_26); -lean_dec(x_3); lean_dec(x_2); return x_29; } @@ -29983,7 +29989,6 @@ uint8_t x_35; lean_object* x_36; x_35 = 0; lean_inc(x_2); x_36 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(x_2, x_3, x_35, x_35, x_2, x_33); -lean_dec(x_3); lean_dec(x_2); return x_36; } @@ -30009,7 +30014,6 @@ uint8_t x_41; lean_object* x_42; x_41 = 0; lean_inc(x_2); x_42 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(x_2, x_3, x_41, x_41, x_2, x_39); -lean_dec(x_3); lean_dec(x_2); return x_42; } @@ -30125,7 +30129,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__2(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -30139,7 +30142,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__1(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -30155,7 +30157,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__4(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -30169,7 +30170,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__3(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -30185,7 +30185,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__6(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -30199,7 +30198,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__5(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -30215,7 +30213,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__8(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -30229,7 +30226,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__7(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -30245,7 +30241,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__10(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -30259,7 +30254,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__9(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -30275,7 +30269,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__12(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -30289,7 +30282,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__11(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -30305,7 +30297,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__14(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -30319,7 +30310,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__13(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -30335,7 +30325,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__16(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -30349,7 +30338,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__15(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -30365,7 +30353,6 @@ lean_dec(x_5); x_11 = lean_unbox(x_6); lean_dec(x_6); x_12 = l___private_Init_Lean_Parser_Parser_2__sepByFnAux___main___at_Lean_Parser_Term_matchAlts___elambda__1___spec__18(x_1, x_2, x_9, x_4, x_10, x_11, x_7, x_8); -lean_dec(x_2); lean_dec(x_1); return x_12; } @@ -30379,7 +30366,6 @@ lean_dec(x_3); x_8 = lean_unbox(x_4); lean_dec(x_4); x_9 = l_Lean_Parser_sepBy1Fn___at_Lean_Parser_Term_matchAlts___elambda__1___spec__17(x_1, x_2, x_7, x_8, x_5, x_6); -lean_dec(x_2); lean_dec(x_1); return x_9; } @@ -51774,8 +51760,6 @@ l_Lean_Parser_Term_num___elambda__1___closed__1 = _init_l_Lean_Parser_Term_num__ lean_mark_persistent(l_Lean_Parser_Term_num___elambda__1___closed__1); l_Lean_Parser_Term_num___elambda__1___closed__2 = _init_l_Lean_Parser_Term_num___elambda__1___closed__2(); lean_mark_persistent(l_Lean_Parser_Term_num___elambda__1___closed__2); -l_Lean_Parser_Term_num___elambda__1___closed__3 = _init_l_Lean_Parser_Term_num___elambda__1___closed__3(); -lean_mark_persistent(l_Lean_Parser_Term_num___elambda__1___closed__3); l_Lean_Parser_Term_num___closed__1 = _init_l_Lean_Parser_Term_num___closed__1(); lean_mark_persistent(l_Lean_Parser_Term_num___closed__1); l_Lean_Parser_Term_num___closed__2 = _init_l_Lean_Parser_Term_num___closed__2(); @@ -51793,10 +51777,6 @@ l_Lean_Parser_Term_str___elambda__1___closed__1 = _init_l_Lean_Parser_Term_str__ lean_mark_persistent(l_Lean_Parser_Term_str___elambda__1___closed__1); l_Lean_Parser_Term_str___elambda__1___closed__2 = _init_l_Lean_Parser_Term_str___elambda__1___closed__2(); lean_mark_persistent(l_Lean_Parser_Term_str___elambda__1___closed__2); -l_Lean_Parser_Term_str___elambda__1___closed__3 = _init_l_Lean_Parser_Term_str___elambda__1___closed__3(); -lean_mark_persistent(l_Lean_Parser_Term_str___elambda__1___closed__3); -l_Lean_Parser_Term_str___elambda__1___closed__4 = _init_l_Lean_Parser_Term_str___elambda__1___closed__4(); -lean_mark_persistent(l_Lean_Parser_Term_str___elambda__1___closed__4); l_Lean_Parser_Term_str___closed__1 = _init_l_Lean_Parser_Term_str___closed__1(); lean_mark_persistent(l_Lean_Parser_Term_str___closed__1); l_Lean_Parser_Term_str___closed__2 = _init_l_Lean_Parser_Term_str___closed__2(); diff --git a/stage0/stdlib/Init/Lean/Syntax.c b/stage0/stdlib/Init/Lean/Syntax.c index a5ac2748ea..65095735cd 100644 --- a/stage0/stdlib/Init/Lean/Syntax.c +++ b/stage0/stdlib/Init/Lean/Syntax.c @@ -14,30 +14,49 @@ extern "C" { #endif lean_object* l_Lean_Syntax_reprint___main___closed__1; -lean_object* l_Lean_Syntax_formatStxAux___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_formatStxAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Prod_hasQuote___rarg___closed__1; lean_object* l_Lean_Syntax_reprint___main___boxed(lean_object*); lean_object* l___private_Init_Lean_Syntax_5__reprintLeaf(lean_object*, lean_object*); lean_object* lean_array_set(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_hasQuote___closed__1; lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_reprint___main___spec__2(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Syntax_1__updateInfo(lean_object*, lean_object*); lean_object* l_Lean_Syntax_setTailInfoAux(lean_object*, lean_object*); lean_object* l_Lean_Syntax_reprint___boxed(lean_object*); -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(lean_object*, lean_object*, lean_object*); +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(lean_object*, uint8_t, lean_object*, lean_object*); +lean_object* l_Lean_Nat_HasQuote___closed__2; +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main___closed__4; extern lean_object* l_Lean_nullKind; lean_object* l_Lean_Syntax_modifyArg(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main(lean_object*); lean_object* l_Lean_Syntax_formatStxAux___main___closed__5; +extern lean_object* l_Option_HasRepr___rarg___closed__1; lean_object* l_Lean_Syntax_ifNodeKind___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__6; uint8_t lean_name_eq(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6; lean_object* l_Lean_Syntax_mrewriteBottomUp___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getIdAt(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Syntax_4__updateFirst___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Substring_HasQuote___closed__4; lean_object* l_Lean_Syntax_HasToString; +lean_object* l_Lean_Array_hasQuote___rarg___closed__2; lean_object* l_Lean_SyntaxNode_withArgs(lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__3; +lean_object* l_Lean_Substring_HasQuote(lean_object*); +lean_object* l_Lean_Substring_HasQuote___closed__2; +lean_object* l_Lean_Substring_HasQuote___closed__1; +lean_object* l_Lean_Substring_HasQuote___boxed(lean_object*); +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg(lean_object*, lean_object*); lean_object* l_Lean_Syntax_reprint___main(lean_object*); lean_object* l_Lean_Syntax_mrewriteBottomUp___main___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_mrewriteBottomUp(lean_object*); lean_object* l_Lean_Syntax_ifNodeKind(lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); lean_object* lean_array_get_size(lean_object*); +lean_object* l_Lean_Prod_hasQuote___rarg___closed__2; +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg(lean_object*, lean_object*); lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_reprint___main___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_string_append(lean_object*, lean_object*); lean_object* l_Lean_Syntax_formatStxAux___main___closed__6; @@ -52,8 +71,12 @@ extern lean_object* l_Lean_mkAppStx___closed__4; lean_object* l_Lean_mkAtom(lean_object*); lean_object* l_Lean_Syntax_setHeadInfo(lean_object*, lean_object*); lean_object* l_Lean_Syntax_mreplace___main(lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__5; +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__2; lean_object* l___private_Init_Lean_Syntax_4__updateFirst___main(lean_object*); lean_object* l_Lean_Syntax_Lean_HasFormat(lean_object*); +lean_object* l___private_Init_Lean_Syntax_7__quoteName(lean_object*); +extern lean_object* l_Nat_HasOfNat___closed__1; lean_object* l_Lean_Syntax_truncateTrailing(lean_object*); lean_object* l_Lean_Syntax_mreplace___rarg(lean_object*, lean_object*, lean_object*); lean_object* lean_nat_add(lean_object*, lean_object*); @@ -73,19 +96,26 @@ lean_object* lean_array_fget(lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Syntax_replaceInfo___main___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_SyntaxNode_getKind___boxed(lean_object*); lean_object* l_Lean_Syntax_formatStxAux___main___closed__2; +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__7; uint8_t lean_nat_dec_eq(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__1; +lean_object* l_Lean_Nat_HasQuote___closed__1; lean_object* l_Lean_Syntax_updateTrailing(lean_object*, lean_object*); extern lean_object* l_Lean_numLitKind; lean_object* l_Lean_Syntax_mreplace___main___rarg(lean_object*, lean_object*, lean_object*); lean_object* lean_nat_sub(lean_object*, lean_object*); -lean_object* l_Lean_Syntax_formatStxAux___main___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_formatStxAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__4; lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_reprint___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_findSomeRevMAux___main___at_Lean_Syntax_getTailInfo___main___spec__1(lean_object*, lean_object*, lean_object*); lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_String_HasQuote___closed__1; +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_unreachIsNodeMissing(lean_object*, lean_object*); lean_object* l_Lean_Syntax_getIdAt___boxed(lean_object*, lean_object*); -lean_object* l_Lean_Syntax_formatStx___boxed(lean_object*, lean_object*); +lean_object* l_Lean_String_HasQuote(lean_object*); +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main___closed__1; +lean_object* l_Lean_Syntax_formatStx___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_replaceInfo___main(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Syntax_4__updateFirst(lean_object*, lean_object*); lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); @@ -93,30 +123,40 @@ lean_object* l___private_Init_Lean_Syntax_3__updateLast(lean_object*); lean_object* l_Lean_Syntax_updateLeading(lean_object*); lean_object* l_Lean_Syntax_formatStxAux___main___closed__3; lean_object* l_Lean_Syntax_getPos___boxed(lean_object*); +extern lean_object* l_Lean_Format_join___closed__1; lean_object* l_Lean_Syntax_setArgs(lean_object*, lean_object*); +lean_object* l_Lean_Array_hasQuote___rarg(lean_object*, lean_object*); lean_object* l_Lean_Syntax_mreplace___main___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Nat_repr(lean_object*); lean_object* l_Lean_Syntax_formatStxAux___main___closed__9; +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main___closed__2; +lean_object* l_Lean_Name_hasQuote; lean_object* l_Lean_Syntax_getId(lean_object*); lean_object* lean_name_mk_string(lean_object*, lean_object*); extern lean_object* l_Lean_choiceKind; +lean_object* l___private_Init_Lean_Syntax_6__formatInfo(uint8_t, lean_object*); lean_object* l_Lean_SourceInfo_truncateTrailing(lean_object*); -lean_object* l_Lean_Syntax_formatStx(lean_object*, lean_object*); +lean_object* l_Lean_Syntax_formatStx(lean_object*, lean_object*, uint8_t); lean_object* l_Lean_Syntax_mreplace___main___rarg___lambda__1(lean_object*, lean_object*, lean_object*); lean_object* l_Function_comp___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Syntax_rewriteBottomUp___spec__2(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_replaceInfo(lean_object*, lean_object*); lean_object* l_Lean_Syntax_isMissing___boxed(lean_object*); lean_object* l_Lean_Syntax_mreplace(lean_object*); +extern lean_object* l_Lean_mkAppStx___closed__6; lean_object* l___private_Init_Lean_Syntax_3__updateLast___main(lean_object*); lean_object* l_Array_findSomeRevMAux___main___at_Lean_Syntax_getTailWithInfo___main___spec__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_SyntaxNode_modifyArgs(lean_object*, lean_object*); +lean_object* l_Lean_Array_hasQuote___rarg___boxed(lean_object*, lean_object*); lean_object* l_Lean_SyntaxNode_getArgs___boxed(lean_object*); +lean_object* l_Lean_Array_hasQuote___rarg___closed__1; lean_object* l_Array_findSomeRevMAux___main___at_Lean_Syntax_getTailInfo___main___spec__1___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(lean_object*, lean_object*, lean_object*); +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_unreachIsNodeIdent___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_String_Iterator_HasRepr___closed__2; +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main(lean_object*); lean_object* l_Lean_SourceInfo_appendToLeading(lean_object*, lean_object*); +lean_object* l_Lean_List_hasQuote(lean_object*); lean_object* l_Lean_Syntax_getTailInfo___main___boxed(lean_object*); lean_object* l_Lean_Syntax_ifNode___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_asNode___boxed(lean_object*); @@ -124,9 +164,12 @@ lean_object* l_Lean_Syntax_mreplace___main___at_Lean_Syntax_updateLeading___spec lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_formatStxAux___main___closed__11; lean_object* l_Lean_SyntaxNode_getNumArgs___boxed(lean_object*); +lean_object* l_Lean_String_HasQuote___closed__2; lean_object* l_Lean_Syntax_mrewriteBottomUp___main___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_updateTrailing___main(lean_object*, lean_object*); +lean_object* l_Lean_Option_hasQuote(lean_object*); lean_object* l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList(lean_object*); extern lean_object* l_Lean_Format_sbracket___closed__3; lean_object* l_Lean_unreachIsNodeAtom(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_mreplace___main___rarg___lambda__3(lean_object*, lean_object*, lean_object*); @@ -136,16 +179,20 @@ uint8_t l_Lean_Syntax_isMissing(lean_object*); lean_object* l_Array_umapMAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_HasRepr___closed__1; lean_object* l_Lean_Syntax_setArg___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Array_hasQuote(lean_object*); lean_object* l_Lean_SourceInfo_appendToTrailing(lean_object*, lean_object*); -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main___closed__3; lean_object* l_Lean_SyntaxNode_getNumArgs(lean_object*); extern lean_object* l_Lean_Format_paren___closed__1; extern lean_object* l_Lean_Syntax_inhabited; -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Prod_hasQuote___rarg___closed__3; +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getNumArgs(lean_object*); lean_object* l_Lean_Syntax_setArg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_SourceInfo_updateTrailing(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Syntax_2__updateLeadingAux(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main___closed__5; lean_object* l_Lean_Syntax_getTailWithInfo(lean_object*); lean_object* l_Lean_Syntax_setHeadInfoAux___main(lean_object*, lean_object*); lean_object* l_String_quote(lean_object*); @@ -153,59 +200,86 @@ lean_object* l_Lean_Syntax_HasToString___closed__2; lean_object* l_Lean_Syntax_mrewriteBottomUp___main___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_SyntaxNode_withArgs___rarg(lean_object*, lean_object*); extern lean_object* l_Lean_Format_sbracket___closed__1; +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main___closed__6; +lean_object* l_Lean_List_hasQuote___rarg(lean_object*); extern lean_object* l_Lean_Format_paren___closed__2; lean_object* l_Lean_unreachIsNodeAtom___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l___private_Init_Util_1__mkPanicMessage___closed__2; lean_object* l___private_Init_Lean_Syntax_3__updateLast___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Syntax_4__updateFirst___main___at_Lean_Syntax_setHeadInfoAux___main___spec__1(lean_object*, lean_object*, lean_object*); -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_findSomeRevMAux___main___at_Lean_Syntax_getTailWithInfo___main___spec__1(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_setTailInfoAux___main(lean_object*, lean_object*); lean_object* lean_format_group(lean_object*); lean_object* l_Lean_mkStxStrLit(lean_object*, lean_object*); lean_object* l_Lean_Syntax_getPos(lean_object*); +lean_object* l_Lean_Nat_HasQuote(lean_object*); lean_object* lean_mk_syntax_atom(lean_object*); +lean_object* l___private_Init_Lean_Syntax_9__quoteOption(lean_object*); +lean_object* l_Lean_mkCAppStx(lean_object*, lean_object*); lean_object* lean_mk_syntax_num_lit(lean_object*); +extern lean_object* l_Lean_mkAppStx___closed__9; lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_reprint___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_setInfo(lean_object*, lean_object*); lean_object* l_Array_umapMAux___main___at_Lean_Syntax_updateLeading___spec__2(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_HasToString___closed__1; +lean_object* l_Lean_mkTermIdFrom(lean_object*, lean_object*); extern lean_object* l_Lean_mkOptionalNode___closed__1; lean_object* l___private_Init_Lean_Syntax_4__updateFirst___main___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_6__formatInfo___boxed(lean_object*, lean_object*); lean_object* l_Lean_Syntax_mrewriteBottomUp___main(lean_object*); lean_object* l_Lean_SyntaxNode_getIdAt___boxed(lean_object*, lean_object*); lean_object* l_Lean_Syntax_getTailInfo(lean_object*); lean_object* l_Lean_Syntax_HasToString___lambda__1(lean_object*); lean_object* l_Array_toList___rarg(lean_object*); lean_object* l_Lean_Syntax_mrewriteBottomUp___main___at_Lean_Syntax_rewriteBottomUp___spec__1(lean_object*, lean_object*); -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList___rarg(lean_object*, lean_object*); +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* lean_mk_syntax_list(lean_object*); +lean_object* l_Lean_Prod_hasQuote___rarg___closed__4; lean_object* l_Lean_Syntax_getTailInfo___boxed(lean_object*); lean_object* l_Lean_Syntax_mreplace___main___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_mk_syntax_str_lit(lean_object*); lean_object* l_Lean_mkStxLit(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__4; +extern lean_object* l_Lean_mkOptionalNode___closed__2; extern lean_object* l_Lean_Format_paren___closed__3; lean_object* l_Lean_Syntax_formatStxAux___main___closed__10; +lean_object* l_Lean_mkCTermIdFrom(lean_object*, lean_object*); lean_object* l_Lean_Syntax_asNode(lean_object*); -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__1; +lean_object* l_Lean_Syntax_formatStxAux___main(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_unreachIsNodeIdent(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_System_FilePath_dirName___closed__1; lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*); -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Prod_hasQuote___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_HasQuote; lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*); lean_object* l_Lean_Syntax_mrewriteBottomUp___main___rarg___lambda__2(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__2; +lean_object* l_Lean_Prod_hasQuote(lean_object*, lean_object*); lean_object* l_Lean_Syntax_ifNodeKind___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_mkAppStx___closed__2; lean_object* l_Lean_Syntax_modifyArgs(lean_object*, lean_object*); lean_object* l_Lean_mkNode(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Syntax_5__reprintLeaf___boxed(lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_6__formatInfo___closed__1; lean_object* l_Lean_Syntax_getTailInfo___main(lean_object*); lean_object* l_Lean_SyntaxNode_getArg(lean_object*, lean_object*); lean_object* l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2___boxed(lean_object*, lean_object*); lean_object* l_Lean_Syntax_formatStxAux___main___closed__7; -lean_object* l_Lean_Syntax_formatStxAux(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Substring_HasQuote___closed__3; +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5; +extern lean_object* l_Lean_mkAppStx___closed__1; +lean_object* l_Lean_Syntax_formatStxAux(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* l_Lean_Syntax_reprint(lean_object*); lean_object* l_Lean_Syntax_setHeadInfoAux(lean_object*, lean_object*); lean_object* l_Lean_Syntax_mreplace___main___rarg___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Option_hasQuote___rarg(lean_object*); lean_object* l___private_Init_Lean_Syntax_4__updateFirst___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__3; uint8_t lean_string_dec_eq(lean_object*, lean_object*); uint8_t lean_nat_dec_lt(lean_object*, lean_object*); lean_object* l_Lean_SourceInfo_updateTrailing(lean_object* x_1, lean_object* x_2) { @@ -3293,6 +3367,80 @@ return x_4; } } } +lean_object* l_Lean_Syntax_setInfo(lean_object* x_1, lean_object* x_2) { +_start: +{ +switch (lean_obj_tag(x_2)) { +case 2: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_2, 0); +lean_dec(x_4); +x_5 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_5, 0, x_1); +lean_ctor_set(x_2, 0, x_5); +return x_2; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = lean_ctor_get(x_2, 1); +lean_inc(x_6); +lean_dec(x_2); +x_7 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_7, 0, x_1); +x_8 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_6); +return x_8; +} +} +case 3: +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_2); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_2, 0); +lean_dec(x_10); +x_11 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_11, 0, x_1); +lean_ctor_set(x_2, 0, x_11); +return x_2; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_2, 1); +x_13 = lean_ctor_get(x_2, 2); +x_14 = lean_ctor_get(x_2, 3); +lean_inc(x_14); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_2); +x_15 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_15, 0, x_1); +x_16 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_12); +lean_ctor_set(x_16, 2, x_13); +lean_ctor_set(x_16, 3, x_14); +return x_16; +} +} +default: +{ +lean_dec(x_1); +return x_2; +} +} +} +} lean_object* l_Array_umapMAux___main___at_Lean_Syntax_replaceInfo___main___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { @@ -3329,13 +3477,7 @@ goto _start; lean_object* l_Lean_Syntax_replaceInfo___main(lean_object* x_1, lean_object* x_2) { _start: { -switch (lean_obj_tag(x_2)) { -case 0: -{ -lean_dec(x_1); -return x_2; -} -case 1: +if (lean_obj_tag(x_2) == 1) { uint8_t x_3; x_3 = !lean_is_exclusive(x_2); @@ -3368,68 +3510,11 @@ lean_ctor_set(x_15, 1, x_14); return x_15; } } -case 2: -{ -uint8_t x_16; -x_16 = !lean_is_exclusive(x_2); -if (x_16 == 0) -{ -lean_object* x_17; lean_object* x_18; -x_17 = lean_ctor_get(x_2, 0); -lean_dec(x_17); -x_18 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_18, 0, x_1); -lean_ctor_set(x_2, 0, x_18); -return x_2; -} else { -lean_object* x_19; lean_object* x_20; lean_object* x_21; -x_19 = lean_ctor_get(x_2, 1); -lean_inc(x_19); -lean_dec(x_2); -x_20 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_20, 0, x_1); -x_21 = lean_alloc_ctor(2, 2, 0); -lean_ctor_set(x_21, 0, x_20); -lean_ctor_set(x_21, 1, x_19); -return x_21; -} -} -default: -{ -uint8_t x_22; -x_22 = !lean_is_exclusive(x_2); -if (x_22 == 0) -{ -lean_object* x_23; lean_object* x_24; -x_23 = lean_ctor_get(x_2, 0); -lean_dec(x_23); -x_24 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_24, 0, x_1); -lean_ctor_set(x_2, 0, x_24); -return x_2; -} -else -{ -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -x_25 = lean_ctor_get(x_2, 1); -x_26 = lean_ctor_get(x_2, 2); -x_27 = lean_ctor_get(x_2, 3); -lean_inc(x_27); -lean_inc(x_26); -lean_inc(x_25); -lean_dec(x_2); -x_28 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_28, 0, x_1); -x_29 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_29, 0, x_28); -lean_ctor_set(x_29, 1, x_25); -lean_ctor_set(x_29, 2, x_26); -lean_ctor_set(x_29, 3, x_27); -return x_29; -} -} +lean_object* x_16; +x_16 = l_Lean_Syntax_setInfo(x_1, x_2); +return x_16; } } } @@ -3736,50 +3821,111 @@ lean_dec(x_1); return x_2; } } -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* _init_l___private_Init_Lean_Syntax_6__formatInfo___closed__1() { _start: { -if (lean_obj_tag(x_3) == 0) -{ -lean_object* x_4; -x_4 = lean_box(0); -return x_4; +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Init_Util_1__mkPanicMessage___closed__2; +x_2 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; } -else +} +lean_object* l___private_Init_Lean_Syntax_6__formatInfo(uint8_t x_1, lean_object* x_2) { +_start: { -uint8_t x_5; -x_5 = !lean_is_exclusive(x_3); -if (x_5 == 0) +if (lean_obj_tag(x_2) == 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; -x_6 = lean_ctor_get(x_3, 0); -x_7 = lean_ctor_get(x_3, 1); -x_8 = lean_unsigned_to_nat(1u); -x_9 = lean_nat_add(x_2, x_8); -x_10 = l_Lean_Syntax_formatStxAux___main(x_1, x_9, x_6); -lean_dec(x_9); -x_11 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(x_1, x_2, x_7); -lean_ctor_set(x_3, 1, x_11); -lean_ctor_set(x_3, 0, x_10); +lean_object* x_3; +x_3 = l_Lean_Format_join___closed__1; return x_3; } else { -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; -x_12 = lean_ctor_get(x_3, 0); -x_13 = lean_ctor_get(x_3, 1); +if (x_1 == 0) +{ +lean_object* x_4; +lean_dec(x_2); +x_4 = l_Lean_Format_join___closed__1; +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_10; lean_object* x_11; +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +lean_dec(x_2); +x_6 = lean_ctor_get(x_5, 1); +lean_inc(x_6); +lean_dec(x_5); +x_7 = l_Nat_repr(x_6); +x_8 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_8, 0, x_7); +x_9 = 0; +x_10 = l___private_Init_Lean_Syntax_6__formatInfo___closed__1; +x_11 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_8); +lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_9); +return x_11; +} +} +} +} +lean_object* l___private_Init_Lean_Syntax_6__formatInfo___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = lean_unbox(x_1); +lean_dec(x_1); +x_4 = l___private_Init_Lean_Syntax_6__formatInfo(x_3, x_2); +return x_4; +} +} +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; +x_5 = lean_box(0); +return x_5; +} +else +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_7 = lean_ctor_get(x_4, 0); +x_8 = lean_ctor_get(x_4, 1); +x_9 = lean_unsigned_to_nat(1u); +x_10 = lean_nat_add(x_3, x_9); +x_11 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_10, x_7); +lean_dec(x_10); +x_12 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(x_1, x_2, x_3, x_8); +lean_ctor_set(x_4, 1, x_12); +lean_ctor_set(x_4, 0, x_11); +return x_4; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_13 = lean_ctor_get(x_4, 0); +x_14 = lean_ctor_get(x_4, 1); +lean_inc(x_14); lean_inc(x_13); -lean_inc(x_12); -lean_dec(x_3); -x_14 = lean_unsigned_to_nat(1u); -x_15 = lean_nat_add(x_2, x_14); -x_16 = l_Lean_Syntax_formatStxAux___main(x_1, x_15, x_12); -lean_dec(x_15); -x_17 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(x_1, x_2, x_13); -x_18 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_18, 0, x_16); -lean_ctor_set(x_18, 1, x_17); -return x_18; +lean_dec(x_4); +x_15 = lean_unsigned_to_nat(1u); +x_16 = lean_nat_add(x_3, x_15); +x_17 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_16, x_13); +lean_dec(x_16); +x_18 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(x_1, x_2, x_3, x_14); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +return x_19; } } } @@ -3827,146 +3973,146 @@ return x_10; } } } -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) { _start: { -if (lean_obj_tag(x_3) == 0) +if (lean_obj_tag(x_4) == 0) { -lean_object* x_4; -x_4 = lean_box(0); +lean_object* x_5; +x_5 = lean_box(0); +return x_5; +} +else +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_7 = lean_ctor_get(x_4, 0); +x_8 = lean_ctor_get(x_4, 1); +x_9 = lean_unsigned_to_nat(1u); +x_10 = lean_nat_add(x_3, x_9); +x_11 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_10, x_7); +lean_dec(x_10); +x_12 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(x_1, x_2, x_3, x_8); +lean_ctor_set(x_4, 1, x_12); +lean_ctor_set(x_4, 0, x_11); return x_4; } else { -uint8_t x_5; -x_5 = !lean_is_exclusive(x_3); -if (x_5 == 0) +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_13 = lean_ctor_get(x_4, 0); +x_14 = lean_ctor_get(x_4, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_4); +x_15 = lean_unsigned_to_nat(1u); +x_16 = lean_nat_add(x_3, x_15); +x_17 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_16, x_13); +lean_dec(x_16); +x_18 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(x_1, x_2, x_3, x_14); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +return x_19; +} +} +} +} +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) { +_start: { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; -x_6 = lean_ctor_get(x_3, 0); -x_7 = lean_ctor_get(x_3, 1); -x_8 = lean_unsigned_to_nat(1u); -x_9 = lean_nat_add(x_2, x_8); -x_10 = l_Lean_Syntax_formatStxAux___main(x_1, x_9, x_6); -lean_dec(x_9); -x_11 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(x_1, x_2, x_7); -lean_ctor_set(x_3, 1, x_11); -lean_ctor_set(x_3, 0, x_10); -return x_3; +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; +x_5 = lean_box(0); +return x_5; } else { -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; -x_12 = lean_ctor_get(x_3, 0); -x_13 = lean_ctor_get(x_3, 1); -lean_inc(x_13); -lean_inc(x_12); -lean_dec(x_3); -x_14 = lean_unsigned_to_nat(1u); -x_15 = lean_nat_add(x_2, x_14); -x_16 = l_Lean_Syntax_formatStxAux___main(x_1, x_15, x_12); -lean_dec(x_15); -x_17 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(x_1, x_2, x_13); -x_18 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_18, 0, x_16); -lean_ctor_set(x_18, 1, x_17); -return x_18; -} -} -} -} -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) { -if (lean_obj_tag(x_3) == 0) -{ -lean_object* x_4; -x_4 = lean_box(0); +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_7 = lean_ctor_get(x_4, 0); +x_8 = lean_ctor_get(x_4, 1); +x_9 = lean_unsigned_to_nat(1u); +x_10 = lean_nat_add(x_3, x_9); +x_11 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_10, x_7); +lean_dec(x_10); +x_12 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(x_1, x_2, x_3, x_8); +lean_ctor_set(x_4, 1, x_12); +lean_ctor_set(x_4, 0, x_11); return x_4; } else { -uint8_t x_5; -x_5 = !lean_is_exclusive(x_3); -if (x_5 == 0) +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_13 = lean_ctor_get(x_4, 0); +x_14 = lean_ctor_get(x_4, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_4); +x_15 = lean_unsigned_to_nat(1u); +x_16 = lean_nat_add(x_3, x_15); +x_17 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_16, x_13); +lean_dec(x_16); +x_18 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(x_1, x_2, x_3, x_14); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +return x_19; +} +} +} +} +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) { +_start: { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; -x_6 = lean_ctor_get(x_3, 0); -x_7 = lean_ctor_get(x_3, 1); -x_8 = lean_unsigned_to_nat(1u); -x_9 = lean_nat_add(x_2, x_8); -x_10 = l_Lean_Syntax_formatStxAux___main(x_1, x_9, x_6); -lean_dec(x_9); -x_11 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(x_1, x_2, x_7); -lean_ctor_set(x_3, 1, x_11); -lean_ctor_set(x_3, 0, x_10); -return x_3; +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; +x_5 = lean_box(0); +return x_5; } else { -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; -x_12 = lean_ctor_get(x_3, 0); -x_13 = lean_ctor_get(x_3, 1); -lean_inc(x_13); -lean_inc(x_12); -lean_dec(x_3); -x_14 = lean_unsigned_to_nat(1u); -x_15 = lean_nat_add(x_2, x_14); -x_16 = l_Lean_Syntax_formatStxAux___main(x_1, x_15, x_12); -lean_dec(x_15); -x_17 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(x_1, x_2, x_13); -x_18 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_18, 0, x_16); -lean_ctor_set(x_18, 1, x_17); -return x_18; -} -} -} -} -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3) { -_start: +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) { -if (lean_obj_tag(x_3) == 0) -{ -lean_object* x_4; -x_4 = lean_box(0); +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_7 = lean_ctor_get(x_4, 0); +x_8 = lean_ctor_get(x_4, 1); +x_9 = lean_unsigned_to_nat(1u); +x_10 = lean_nat_add(x_3, x_9); +x_11 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_10, x_7); +lean_dec(x_10); +x_12 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(x_1, x_2, x_3, x_8); +lean_ctor_set(x_4, 1, x_12); +lean_ctor_set(x_4, 0, x_11); return x_4; } else { -uint8_t x_5; -x_5 = !lean_is_exclusive(x_3); -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; -x_6 = lean_ctor_get(x_3, 0); -x_7 = lean_ctor_get(x_3, 1); -x_8 = lean_unsigned_to_nat(1u); -x_9 = lean_nat_add(x_2, x_8); -x_10 = l_Lean_Syntax_formatStxAux___main(x_1, x_9, x_6); -lean_dec(x_9); -x_11 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(x_1, x_2, x_7); -lean_ctor_set(x_3, 1, x_11); -lean_ctor_set(x_3, 0, x_10); -return x_3; -} -else -{ -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; -x_12 = lean_ctor_get(x_3, 0); -x_13 = lean_ctor_get(x_3, 1); +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_13 = lean_ctor_get(x_4, 0); +x_14 = lean_ctor_get(x_4, 1); +lean_inc(x_14); lean_inc(x_13); -lean_inc(x_12); -lean_dec(x_3); -x_14 = lean_unsigned_to_nat(1u); -x_15 = lean_nat_add(x_2, x_14); -x_16 = l_Lean_Syntax_formatStxAux___main(x_1, x_15, x_12); -lean_dec(x_15); -x_17 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(x_1, x_2, x_13); -x_18 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_18, 0, x_16); -lean_ctor_set(x_18, 1, x_17); -return x_18; +lean_dec(x_4); +x_15 = lean_unsigned_to_nat(1u); +x_16 = lean_nat_add(x_3, x_15); +x_17 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_16, x_13); +lean_dec(x_16); +x_18 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(x_1, x_2, x_3, x_14); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +return x_19; } } } @@ -4086,296 +4232,313 @@ x_2 = lean_format_group(x_1); return x_2; } } -lean_object* l_Lean_Syntax_formatStxAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_Syntax_formatStxAux___main(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) { _start: { -switch (lean_obj_tag(x_3)) { +switch (lean_obj_tag(x_4)) { case 0: { -lean_object* x_4; -x_4 = l_Lean_Syntax_formatStxAux___main___closed__2; -return x_4; +lean_object* x_5; +x_5 = l_Lean_Syntax_formatStxAux___main___closed__2; +return x_5; } case 1: { -lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; -x_5 = lean_ctor_get(x_3, 0); -lean_inc(x_5); -x_6 = lean_ctor_get(x_3, 1); +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; +x_6 = lean_ctor_get(x_4, 0); lean_inc(x_6); -lean_dec(x_3); -x_7 = lean_unsigned_to_nat(1u); -x_8 = lean_nat_add(x_2, x_7); -x_9 = l_Lean_Syntax_formatStxAux___main___closed__4; -x_10 = lean_name_eq(x_5, x_9); -if (x_10 == 0) +x_7 = lean_ctor_get(x_4, 1); +lean_inc(x_7); +lean_dec(x_4); +x_8 = lean_unsigned_to_nat(1u); +x_9 = lean_nat_add(x_3, x_8); +x_10 = l_Lean_Syntax_formatStxAux___main___closed__4; +x_11 = lean_name_eq(x_6, x_10); +if (x_11 == 0) { -lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; -x_11 = l_Lean_mkAppStx___closed__4; -x_12 = lean_box(0); -x_13 = l_Lean_Name_replacePrefix___main(x_5, x_11, x_12); -x_14 = l_System_FilePath_dirName___closed__1; -x_15 = l_Lean_Name_toStringWithSep___main(x_14, x_13); -x_16 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_16, 0, x_15); +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 = l_Lean_mkAppStx___closed__4; +x_13 = lean_box(0); +x_14 = l_Lean_Name_replacePrefix___main(x_6, x_12, x_13); +x_15 = l_System_FilePath_dirName___closed__1; +x_16 = l_Lean_Name_toStringWithSep___main(x_15, x_14); +x_17 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_17, 0, x_16); if (lean_obj_tag(x_1) == 0) { -uint8_t x_17; -x_17 = lean_nat_dec_lt(x_8, x_8); -lean_dec(x_8); -if (x_17 == 0) +uint8_t x_18; +x_18 = lean_nat_dec_lt(x_9, x_9); +lean_dec(x_9); +if (x_18 == 0) { -lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_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; -x_18 = l_Array_toList___rarg(x_6); -lean_dec(x_6); -x_19 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(x_1, x_2, x_18); -x_20 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_20, 0, x_16); -lean_ctor_set(x_20, 1, x_19); -x_21 = lean_box(1); -x_22 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_20, x_21); -lean_dec(x_20); -x_23 = 0; -x_24 = l_Lean_Format_paren___closed__2; -x_25 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_25, 0, x_24); -lean_ctor_set(x_25, 1, x_22); -lean_ctor_set_uint8(x_25, sizeof(void*)*2, x_23); -x_26 = l_Lean_Format_paren___closed__3; -x_27 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_27, 0, x_25); -lean_ctor_set(x_27, 1, x_26); -lean_ctor_set_uint8(x_27, sizeof(void*)*2, x_23); -x_28 = l_Lean_Format_paren___closed__1; -x_29 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_29, 0, x_28); -lean_ctor_set(x_29, 1, x_27); -x_30 = lean_format_group(x_29); -return x_30; +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_19 = l_Array_toList___rarg(x_7); +lean_dec(x_7); +x_20 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(x_1, x_2, x_3, x_19); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_17); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_box(1); +x_23 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_21, x_22); +lean_dec(x_21); +x_24 = 0; +x_25 = l_Lean_Format_paren___closed__2; +x_26 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_23); +lean_ctor_set_uint8(x_26, sizeof(void*)*2, x_24); +x_27 = l_Lean_Format_paren___closed__3; +x_28 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_27); +lean_ctor_set_uint8(x_28, sizeof(void*)*2, x_24); +x_29 = l_Lean_Format_paren___closed__1; +x_30 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_28); +x_31 = lean_format_group(x_30); +return x_31; } else { -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; lean_object* x_40; lean_object* x_41; lean_object* x_42; -lean_dec(x_6); -x_31 = l_Lean_Syntax_formatStxAux___main___closed__7; -x_32 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_32, 0, x_16); -lean_ctor_set(x_32, 1, x_31); -x_33 = lean_box(1); -x_34 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_32, x_33); -lean_dec(x_32); -x_35 = 0; -x_36 = l_Lean_Format_paren___closed__2; -x_37 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_37, 0, x_36); -lean_ctor_set(x_37, 1, x_34); -lean_ctor_set_uint8(x_37, sizeof(void*)*2, x_35); -x_38 = l_Lean_Format_paren___closed__3; -x_39 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_39, 0, x_37); -lean_ctor_set(x_39, 1, x_38); -lean_ctor_set_uint8(x_39, sizeof(void*)*2, x_35); -x_40 = l_Lean_Format_paren___closed__1; -x_41 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_41, 0, x_40); -lean_ctor_set(x_41, 1, x_39); -x_42 = lean_format_group(x_41); -return x_42; +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_dec(x_7); +x_32 = l_Lean_Syntax_formatStxAux___main___closed__7; +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_17); +lean_ctor_set(x_33, 1, x_32); +x_34 = lean_box(1); +x_35 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_33, x_34); +lean_dec(x_33); +x_36 = 0; +x_37 = l_Lean_Format_paren___closed__2; +x_38 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_35); +lean_ctor_set_uint8(x_38, sizeof(void*)*2, x_36); +x_39 = l_Lean_Format_paren___closed__3; +x_40 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +lean_ctor_set_uint8(x_40, sizeof(void*)*2, x_36); +x_41 = l_Lean_Format_paren___closed__1; +x_42 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_format_group(x_42); +return x_43; } } else { -lean_object* x_43; uint8_t x_44; -x_43 = lean_ctor_get(x_1, 0); -x_44 = lean_nat_dec_lt(x_43, x_8); -lean_dec(x_8); -if (x_44 == 0) +lean_object* x_44; uint8_t x_45; +x_44 = lean_ctor_get(x_1, 0); +x_45 = lean_nat_dec_lt(x_44, x_9); +lean_dec(x_9); +if (x_45 == 0) { -lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t 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; -x_45 = l_Array_toList___rarg(x_6); -lean_dec(x_6); -x_46 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(x_1, x_2, x_45); -x_47 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_47, 0, x_16); -lean_ctor_set(x_47, 1, x_46); -x_48 = lean_box(1); -x_49 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_47, x_48); -lean_dec(x_47); -x_50 = 0; -x_51 = l_Lean_Format_paren___closed__2; -x_52 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_52, 0, x_51); -lean_ctor_set(x_52, 1, x_49); -lean_ctor_set_uint8(x_52, sizeof(void*)*2, x_50); -x_53 = l_Lean_Format_paren___closed__3; -x_54 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_54, 0, x_52); -lean_ctor_set(x_54, 1, x_53); -lean_ctor_set_uint8(x_54, sizeof(void*)*2, x_50); -x_55 = l_Lean_Format_paren___closed__1; -x_56 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_56, 0, x_55); -lean_ctor_set(x_56, 1, x_54); -x_57 = lean_format_group(x_56); -return x_57; +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t 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; +x_46 = l_Array_toList___rarg(x_7); +lean_dec(x_7); +x_47 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(x_1, x_2, x_3, x_46); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_17); +lean_ctor_set(x_48, 1, x_47); +x_49 = lean_box(1); +x_50 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_48, x_49); +lean_dec(x_48); +x_51 = 0; +x_52 = l_Lean_Format_paren___closed__2; +x_53 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_50); +lean_ctor_set_uint8(x_53, sizeof(void*)*2, x_51); +x_54 = l_Lean_Format_paren___closed__3; +x_55 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +lean_ctor_set_uint8(x_55, sizeof(void*)*2, x_51); +x_56 = l_Lean_Format_paren___closed__1; +x_57 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_55); +x_58 = lean_format_group(x_57); +return x_58; } else { -lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; -lean_dec(x_6); -x_58 = l_Lean_Syntax_formatStxAux___main___closed__7; -x_59 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_59, 0, x_16); -lean_ctor_set(x_59, 1, x_58); -x_60 = lean_box(1); -x_61 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_59, x_60); -lean_dec(x_59); -x_62 = 0; -x_63 = l_Lean_Format_paren___closed__2; -x_64 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_64, 0, x_63); -lean_ctor_set(x_64, 1, x_61); -lean_ctor_set_uint8(x_64, sizeof(void*)*2, x_62); -x_65 = l_Lean_Format_paren___closed__3; -x_66 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_66, 0, x_64); -lean_ctor_set(x_66, 1, x_65); -lean_ctor_set_uint8(x_66, sizeof(void*)*2, x_62); -x_67 = l_Lean_Format_paren___closed__1; -x_68 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_68, 0, x_67); -lean_ctor_set(x_68, 1, x_66); -x_69 = lean_format_group(x_68); -return x_69; +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; 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_dec(x_7); +x_59 = l_Lean_Syntax_formatStxAux___main___closed__7; +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_17); +lean_ctor_set(x_60, 1, x_59); +x_61 = lean_box(1); +x_62 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_60, x_61); +lean_dec(x_60); +x_63 = 0; +x_64 = l_Lean_Format_paren___closed__2; +x_65 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_62); +lean_ctor_set_uint8(x_65, sizeof(void*)*2, x_63); +x_66 = l_Lean_Format_paren___closed__3; +x_67 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_67, 0, x_65); +lean_ctor_set(x_67, 1, x_66); +lean_ctor_set_uint8(x_67, sizeof(void*)*2, x_63); +x_68 = l_Lean_Format_paren___closed__1; +x_69 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_67); +x_70 = lean_format_group(x_69); +return x_70; } } } else { -lean_dec(x_5); +lean_dec(x_6); if (lean_obj_tag(x_1) == 0) { -uint8_t x_70; -x_70 = lean_nat_dec_lt(x_8, x_8); -lean_dec(x_8); -if (x_70 == 0) +uint8_t x_71; +x_71 = lean_nat_dec_lt(x_9, x_9); +lean_dec(x_9); +if (x_71 == 0) { -lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; 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_71 = l_Array_toList___rarg(x_6); -lean_dec(x_6); -x_72 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(x_1, x_2, x_71); -x_73 = lean_box(1); -x_74 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_72, x_73); -lean_dec(x_72); -x_75 = 0; -x_76 = l_Lean_Format_sbracket___closed__2; -x_77 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_77, 0, x_76); -lean_ctor_set(x_77, 1, x_74); -lean_ctor_set_uint8(x_77, sizeof(void*)*2, x_75); -x_78 = l_Lean_Format_sbracket___closed__3; -x_79 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_79, 0, x_77); -lean_ctor_set(x_79, 1, x_78); -lean_ctor_set_uint8(x_79, sizeof(void*)*2, x_75); -x_80 = l_Lean_Format_sbracket___closed__1; -x_81 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_81, 0, x_80); -lean_ctor_set(x_81, 1, x_79); -x_82 = lean_format_group(x_81); -return x_82; -} -else -{ -lean_object* x_83; -lean_dec(x_6); -x_83 = l_Lean_Syntax_formatStxAux___main___closed__11; +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t 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; lean_object* x_83; +x_72 = l_Array_toList___rarg(x_7); +lean_dec(x_7); +x_73 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(x_1, x_2, x_3, x_72); +x_74 = lean_box(1); +x_75 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_73, x_74); +lean_dec(x_73); +x_76 = 0; +x_77 = l_Lean_Format_sbracket___closed__2; +x_78 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_75); +lean_ctor_set_uint8(x_78, sizeof(void*)*2, x_76); +x_79 = l_Lean_Format_sbracket___closed__3; +x_80 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_80, 0, x_78); +lean_ctor_set(x_80, 1, x_79); +lean_ctor_set_uint8(x_80, sizeof(void*)*2, x_76); +x_81 = l_Lean_Format_sbracket___closed__1; +x_82 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_80); +x_83 = lean_format_group(x_82); return x_83; } +else +{ +lean_object* x_84; +lean_dec(x_7); +x_84 = l_Lean_Syntax_formatStxAux___main___closed__11; +return x_84; +} } else { -lean_object* x_84; uint8_t x_85; -x_84 = lean_ctor_get(x_1, 0); -x_85 = lean_nat_dec_lt(x_84, x_8); -lean_dec(x_8); -if (x_85 == 0) +lean_object* x_85; uint8_t x_86; +x_85 = lean_ctor_get(x_1, 0); +x_86 = lean_nat_dec_lt(x_85, x_9); +lean_dec(x_9); +if (x_86 == 0) { -lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; -x_86 = l_Array_toList___rarg(x_6); -lean_dec(x_6); -x_87 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(x_1, x_2, x_86); -x_88 = lean_box(1); -x_89 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_87, x_88); -lean_dec(x_87); -x_90 = 0; -x_91 = l_Lean_Format_sbracket___closed__2; -x_92 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_92, 0, x_91); -lean_ctor_set(x_92, 1, x_89); -lean_ctor_set_uint8(x_92, sizeof(void*)*2, x_90); -x_93 = l_Lean_Format_sbracket___closed__3; -x_94 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_94, 0, x_92); -lean_ctor_set(x_94, 1, x_93); -lean_ctor_set_uint8(x_94, sizeof(void*)*2, x_90); -x_95 = l_Lean_Format_sbracket___closed__1; -x_96 = lean_alloc_ctor(3, 2, 0); -lean_ctor_set(x_96, 0, x_95); -lean_ctor_set(x_96, 1, x_94); -x_97 = lean_format_group(x_96); -return x_97; -} -else -{ -lean_object* x_98; -lean_dec(x_6); -x_98 = l_Lean_Syntax_formatStxAux___main___closed__11; +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; uint8_t x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_87 = l_Array_toList___rarg(x_7); +lean_dec(x_7); +x_88 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(x_1, x_2, x_3, x_87); +x_89 = lean_box(1); +x_90 = l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2(x_88, x_89); +lean_dec(x_88); +x_91 = 0; +x_92 = l_Lean_Format_sbracket___closed__2; +x_93 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_93, 0, x_92); +lean_ctor_set(x_93, 1, x_90); +lean_ctor_set_uint8(x_93, sizeof(void*)*2, x_91); +x_94 = l_Lean_Format_sbracket___closed__3; +x_95 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_95, 0, x_93); +lean_ctor_set(x_95, 1, x_94); +lean_ctor_set_uint8(x_95, sizeof(void*)*2, x_91); +x_96 = l_Lean_Format_sbracket___closed__1; +x_97 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_97, 0, x_96); +lean_ctor_set(x_97, 1, x_95); +x_98 = lean_format_group(x_97); return x_98; } +else +{ +lean_object* x_99; +lean_dec(x_7); +x_99 = l_Lean_Syntax_formatStxAux___main___closed__11; +return x_99; +} } } } case 2: { -lean_object* x_99; lean_object* x_100; lean_object* x_101; -x_99 = lean_ctor_get(x_3, 1); -lean_inc(x_99); -lean_dec(x_3); -x_100 = l_String_quote(x_99); -x_101 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_101, 0, x_100); -return x_101; +lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; uint8_t x_105; lean_object* x_106; +x_100 = lean_ctor_get(x_4, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_4, 1); +lean_inc(x_101); +lean_dec(x_4); +x_102 = l_String_quote(x_101); +x_103 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_103, 0, x_102); +x_104 = l___private_Init_Lean_Syntax_6__formatInfo(x_2, x_100); +x_105 = 0; +x_106 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +lean_ctor_set_uint8(x_106, sizeof(void*)*2, x_105); +return x_106; } default: { -lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; lean_object* x_108; -x_102 = lean_ctor_get(x_3, 2); -lean_inc(x_102); -lean_dec(x_3); -x_103 = l_System_FilePath_dirName___closed__1; -x_104 = l_Lean_Name_toStringWithSep___main(x_103, x_102); -x_105 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_105, 0, x_104); -x_106 = 0; -x_107 = l_Lean_formatDataValue___closed__2; -x_108 = lean_alloc_ctor(4, 2, 1); -lean_ctor_set(x_108, 0, x_107); -lean_ctor_set(x_108, 1, x_105); -lean_ctor_set_uint8(x_108, sizeof(void*)*2, x_106); -return x_108; +lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; uint8_t x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_107 = lean_ctor_get(x_4, 0); +lean_inc(x_107); +x_108 = lean_ctor_get(x_4, 2); +lean_inc(x_108); +lean_dec(x_4); +x_109 = l_System_FilePath_dirName___closed__1; +x_110 = l_Lean_Name_toStringWithSep___main(x_109, x_108); +x_111 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_111, 0, x_110); +x_112 = 0; +x_113 = l_Lean_formatDataValue___closed__2; +x_114 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_114, 0, x_113); +lean_ctor_set(x_114, 1, x_111); +lean_ctor_set_uint8(x_114, sizeof(void*)*2, x_112); +x_115 = l___private_Init_Lean_Syntax_6__formatInfo(x_2, x_107); +x_116 = lean_alloc_ctor(4, 2, 1); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +lean_ctor_set_uint8(x_116, sizeof(void*)*2, x_112); +return x_116; } } } } -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_4; -x_4 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(x_1, x_2, x_3); +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_2); lean_dec(x_2); +x_6 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__1(x_1, x_5, x_3, x_4); +lean_dec(x_3); lean_dec(x_1); -return x_4; +return x_6; } } lean_object* l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2___boxed(lean_object* x_1, lean_object* x_2) { @@ -4387,100 +4550,114 @@ lean_dec(x_1); return x_3; } } -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_4; -x_4 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(x_1, x_2, x_3); +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_2); lean_dec(x_2); +x_6 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__3(x_1, x_5, x_3, x_4); +lean_dec(x_3); lean_dec(x_1); -return x_4; +return x_6; } } -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_4; -x_4 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(x_1, x_2, x_3); +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_2); lean_dec(x_2); +x_6 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__4(x_1, x_5, x_3, x_4); +lean_dec(x_3); lean_dec(x_1); -return x_4; +return x_6; } } -lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_4; -x_4 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(x_1, x_2, x_3); +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_2); lean_dec(x_2); +x_6 = l_List_map___main___at_Lean_Syntax_formatStxAux___main___spec__5(x_1, x_5, x_3, x_4); +lean_dec(x_3); lean_dec(x_1); -return x_4; +return x_6; } } -lean_object* l_Lean_Syntax_formatStxAux___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_Syntax_formatStxAux___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_4; -x_4 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_3); +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_2); lean_dec(x_2); +x_6 = l_Lean_Syntax_formatStxAux___main(x_1, x_5, x_3, x_4); +lean_dec(x_3); lean_dec(x_1); -return x_4; +return x_6; } } -lean_object* l_Lean_Syntax_formatStxAux(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_Syntax_formatStxAux(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_4; -x_4 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_3); -return x_4; +lean_object* x_5; +x_5 = l_Lean_Syntax_formatStxAux___main(x_1, x_2, x_3, x_4); +return x_5; } } -lean_object* l_Lean_Syntax_formatStxAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_Syntax_formatStxAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_4; -x_4 = l_Lean_Syntax_formatStxAux(x_1, x_2, x_3); +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_2); lean_dec(x_2); +x_6 = l_Lean_Syntax_formatStxAux(x_1, x_5, x_3, x_4); +lean_dec(x_3); lean_dec(x_1); -return x_4; +return x_6; } } -lean_object* l_Lean_Syntax_formatStx(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Syntax_formatStx(lean_object* x_1, lean_object* x_2, uint8_t x_3) { _start: { -lean_object* x_3; lean_object* x_4; -x_3 = lean_unsigned_to_nat(0u); -x_4 = l_Lean_Syntax_formatStxAux___main(x_2, x_3, x_1); -return x_4; +lean_object* x_4; lean_object* x_5; +x_4 = lean_unsigned_to_nat(0u); +x_5 = l_Lean_Syntax_formatStxAux___main(x_2, x_3, x_4, x_1); +return x_5; } } -lean_object* l_Lean_Syntax_formatStx___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_Syntax_formatStx___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { -lean_object* x_3; -x_3 = l_Lean_Syntax_formatStx(x_1, x_2); +uint8_t x_4; lean_object* x_5; +x_4 = lean_unbox(x_3); +lean_dec(x_3); +x_5 = l_Lean_Syntax_formatStx(x_1, x_2, x_4); lean_dec(x_2); -return x_3; +return x_5; } } lean_object* l_Lean_Syntax_Lean_HasFormat(lean_object* x_1) { _start: { -lean_object* x_2; lean_object* x_3; lean_object* x_4; +lean_object* x_2; uint8_t x_3; lean_object* x_4; lean_object* x_5; x_2 = lean_box(0); -x_3 = lean_unsigned_to_nat(0u); -x_4 = l_Lean_Syntax_formatStxAux___main(x_2, x_3, x_1); -return x_4; +x_3 = 0; +x_4 = lean_unsigned_to_nat(0u); +x_5 = l_Lean_Syntax_formatStxAux___main(x_2, x_3, x_4, x_1); +return x_5; } } lean_object* l_Lean_Syntax_HasToString___lambda__1(lean_object* x_1) { _start: { -lean_object* x_2; lean_object* x_3; lean_object* x_4; +lean_object* x_2; uint8_t x_3; lean_object* x_4; lean_object* x_5; x_2 = lean_box(0); -x_3 = lean_unsigned_to_nat(0u); -x_4 = l_Lean_Syntax_formatStxAux___main(x_2, x_3, x_1); -return x_4; +x_3 = 0; +x_4 = lean_unsigned_to_nat(0u); +x_5 = l_Lean_Syntax_formatStxAux___main(x_2, x_3, x_4, x_1); +return x_5; } } lean_object* _init_l_Lean_Syntax_HasToString___closed__1() { @@ -4596,6 +4773,647 @@ x_5 = l_Lean_mkStxLit(x_4, x_2, x_3); return x_5; } } +lean_object* _init_l_Lean_Syntax_HasQuote() { +_start: +{ +lean_object* x_1; +x_1 = l_Nat_HasOfNat___closed__1; +return x_1; +} +} +lean_object* _init_l_Lean_String_HasQuote___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("str"); +return x_1; +} +} +lean_object* _init_l_Lean_String_HasQuote___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_mkAppStx___closed__6; +x_2 = l_Lean_String_HasQuote___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_String_HasQuote(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_2 = lean_box(0); +x_3 = l_Lean_mkStxStrLit(x_1, x_2); +x_4 = l_Lean_mkOptionalNode___closed__2; +x_5 = lean_array_push(x_4, x_3); +x_6 = l_Lean_String_HasQuote___closed__2; +x_7 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +lean_object* _init_l_Lean_Nat_HasQuote___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("num"); +return x_1; +} +} +lean_object* _init_l_Lean_Nat_HasQuote___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_mkAppStx___closed__6; +x_2 = l_Lean_Nat_HasQuote___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Nat_HasQuote(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; +x_2 = l_Nat_repr(x_1); +x_3 = lean_box(0); +x_4 = l_Lean_numLitKind; +x_5 = l_Lean_mkStxLit(x_4, x_2, x_3); +x_6 = l_Lean_mkOptionalNode___closed__2; +x_7 = lean_array_push(x_6, x_5); +x_8 = l_Lean_Nat_HasQuote___closed__2; +x_9 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_7); +return x_9; +} +} +lean_object* _init_l_Lean_Substring_HasQuote___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("String"); +return x_1; +} +} +lean_object* _init_l_Lean_Substring_HasQuote___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Substring_HasQuote___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Substring_HasQuote___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("toSubstring"); +return x_1; +} +} +lean_object* _init_l_Lean_Substring_HasQuote___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Substring_HasQuote___closed__2; +x_2 = l_Lean_Substring_HasQuote___closed__3; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Substring_HasQuote(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_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_2 = lean_box(0); +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_string_utf8_extract(x_3, x_4, x_5); +x_7 = l_Lean_mkStxStrLit(x_6, x_2); +x_8 = l_Lean_mkOptionalNode___closed__2; +x_9 = lean_array_push(x_8, x_7); +x_10 = l_Lean_String_HasQuote___closed__2; +x_11 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_9); +x_12 = lean_array_push(x_8, x_11); +x_13 = l_Lean_Substring_HasQuote___closed__4; +x_14 = l_Lean_mkCAppStx(x_13, x_12); +return x_14; +} +} +lean_object* l_Lean_Substring_HasQuote___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_Substring_HasQuote(x_1); +lean_dec(x_1); +return x_2; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("Name"); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("anonymous"); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("mkNameStr"); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_mkAppStx___closed__2; +x_2 = l___private_Init_Lean_Syntax_7__quoteName___main___closed__3; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("mkNameNum"); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_mkAppStx___closed__2; +x_2 = l___private_Init_Lean_Syntax_7__quoteName___main___closed__5; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l___private_Init_Lean_Syntax_7__quoteName___main(lean_object* x_1) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +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; +x_2 = l_Lean_mkAppStx___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +x_4 = l___private_Init_Lean_Syntax_7__quoteName___main___closed__1; +x_5 = lean_name_mk_string(x_3, x_4); +x_6 = l___private_Init_Lean_Syntax_7__quoteName___main___closed__2; +x_7 = lean_name_mk_string(x_5, x_6); +x_8 = lean_box(0); +x_9 = l_Lean_mkCTermIdFrom(x_8, x_7); +return x_9; +} +case 1: +{ +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; +x_10 = lean_ctor_get(x_1, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_1, 1); +lean_inc(x_11); +lean_dec(x_1); +x_12 = l___private_Init_Lean_Syntax_7__quoteName___main(x_10); +x_13 = lean_box(0); +x_14 = l_Lean_mkStxStrLit(x_11, x_13); +x_15 = l_Lean_mkOptionalNode___closed__2; +x_16 = lean_array_push(x_15, x_14); +x_17 = l_Lean_String_HasQuote___closed__2; +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_16); +x_19 = l_Lean_mkAppStx___closed__9; +x_20 = lean_array_push(x_19, x_12); +x_21 = lean_array_push(x_20, x_18); +x_22 = l___private_Init_Lean_Syntax_7__quoteName___main___closed__4; +x_23 = l_Lean_mkCAppStx(x_22, x_21); +return x_23; +} +default: +{ +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; +x_24 = lean_ctor_get(x_1, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_1, 1); +lean_inc(x_25); +lean_dec(x_1); +x_26 = l___private_Init_Lean_Syntax_7__quoteName___main(x_24); +x_27 = l_Nat_repr(x_25); +x_28 = lean_box(0); +x_29 = l_Lean_numLitKind; +x_30 = l_Lean_mkStxLit(x_29, x_27, x_28); +x_31 = l_Lean_mkOptionalNode___closed__2; +x_32 = lean_array_push(x_31, x_30); +x_33 = l_Lean_Nat_HasQuote___closed__2; +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_32); +x_35 = l_Lean_mkAppStx___closed__9; +x_36 = lean_array_push(x_35, x_26); +x_37 = lean_array_push(x_36, x_34); +x_38 = l___private_Init_Lean_Syntax_7__quoteName___main___closed__6; +x_39 = l_Lean_mkCAppStx(x_38, x_37); +return x_39; +} +} +} +} +lean_object* l___private_Init_Lean_Syntax_7__quoteName(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l___private_Init_Lean_Syntax_7__quoteName___main(x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Name_hasQuote___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Init_Lean_Syntax_7__quoteName), 1, 0); +return x_1; +} +} +lean_object* _init_l_Lean_Name_hasQuote() { +_start: +{ +lean_object* x_1; +x_1 = l_Lean_Name_hasQuote___closed__1; +return x_1; +} +} +lean_object* _init_l_Lean_Prod_hasQuote___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("Prod"); +return x_1; +} +} +lean_object* _init_l_Lean_Prod_hasQuote___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Prod_hasQuote___rarg___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Prod_hasQuote___rarg___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("mk"); +return x_1; +} +} +lean_object* _init_l_Lean_Prod_hasQuote___rarg___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Prod_hasQuote___rarg___closed__2; +x_2 = l_Lean_Prod_hasQuote___rarg___closed__3; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Prod_hasQuote___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_4 = lean_ctor_get(x_3, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_3, 1); +lean_inc(x_5); +lean_dec(x_3); +x_6 = lean_apply_1(x_1, x_4); +x_7 = lean_apply_1(x_2, x_5); +x_8 = l_Lean_mkAppStx___closed__9; +x_9 = lean_array_push(x_8, x_6); +x_10 = lean_array_push(x_9, x_7); +x_11 = l_Lean_Prod_hasQuote___rarg___closed__4; +x_12 = l_Lean_mkCAppStx(x_11, x_10); +return x_12; +} +} +lean_object* l_Lean_Prod_hasQuote(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lean_Prod_hasQuote___rarg), 3, 0); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("List"); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("nil"); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__2; +x_2 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__3; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__4; +x_3 = l_Lean_mkCTermIdFrom(x_1, x_2); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("cons"); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__2; +x_2 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__6; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; +lean_dec(x_1); +x_3 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__5; +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_11; lean_object* x_12; +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); +lean_inc(x_1); +x_6 = lean_apply_1(x_1, x_4); +x_7 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg(x_1, x_5); +x_8 = l_Lean_mkAppStx___closed__9; +x_9 = lean_array_push(x_8, x_6); +x_10 = lean_array_push(x_9, x_7); +x_11 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__7; +x_12 = l_Lean_mkCAppStx(x_11, x_10); +return x_12; +} +} +} +lean_object* l___private_Init_Lean_Syntax_8__quoteList___main(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Syntax_8__quoteList___main___rarg), 2, 0); +return x_2; +} +} +lean_object* l___private_Init_Lean_Syntax_8__quoteList___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg(x_1, x_2); +return x_3; +} +} +lean_object* l___private_Init_Lean_Syntax_8__quoteList(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Syntax_8__quoteList___rarg), 2, 0); +return x_2; +} +} +lean_object* l_Lean_List_hasQuote___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Syntax_8__quoteList___rarg), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* l_Lean_List_hasQuote(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_List_hasQuote___rarg), 1, 0); +return x_2; +} +} +lean_object* _init_l_Lean_Array_hasQuote___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("toArray"); +return x_1; +} +} +lean_object* _init_l_Lean_Array_hasQuote___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__2; +x_2 = l_Lean_Array_hasQuote___rarg___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Array_hasQuote___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_3 = l_Array_toList___rarg(x_2); +x_4 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg(x_1, x_3); +x_5 = l_Lean_mkOptionalNode___closed__2; +x_6 = lean_array_push(x_5, x_4); +x_7 = l_Lean_Array_hasQuote___rarg___closed__2; +x_8 = l_Lean_mkCAppStx(x_7, x_6); +return x_8; +} +} +lean_object* l_Lean_Array_hasQuote(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Array_hasQuote___rarg___boxed), 2, 0); +return x_2; +} +} +lean_object* l_Lean_Array_hasQuote___rarg___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lean_Array_hasQuote___rarg(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("Option"); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__2; +x_2 = l_Option_HasRepr___rarg___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__3; +x_3 = l_Lean_mkTermIdFrom(x_1, x_2); +return x_3; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("some"); +return x_1; +} +} +lean_object* _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__2; +x_2 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l___private_Init_Lean_Syntax_9__quoteOption___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; +lean_dec(x_1); +x_3 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__4; +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; +x_4 = lean_ctor_get(x_2, 0); +lean_inc(x_4); +lean_dec(x_2); +x_5 = lean_apply_1(x_1, x_4); +x_6 = l_Lean_mkOptionalNode___closed__2; +x_7 = lean_array_push(x_6, x_5); +x_8 = l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6; +x_9 = l_Lean_mkCAppStx(x_8, x_7); +return x_9; +} +} +} +lean_object* l___private_Init_Lean_Syntax_9__quoteOption(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Syntax_9__quoteOption___rarg), 2, 0); +return x_2; +} +} +lean_object* l_Lean_Option_hasQuote___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l___private_Init_Lean_Syntax_9__quoteOption___rarg), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* l_Lean_Option_hasQuote(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Option_hasQuote___rarg), 1, 0); +return x_2; +} +} lean_object* initialize_Init_Data_Array(lean_object*); lean_object* initialize_Init_Lean_Data_Name(lean_object*); lean_object* initialize_Init_Lean_Data_Format(lean_object*); @@ -4615,6 +5433,8 @@ if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); l_Lean_Syntax_reprint___main___closed__1 = _init_l_Lean_Syntax_reprint___main___closed__1(); lean_mark_persistent(l_Lean_Syntax_reprint___main___closed__1); +l___private_Init_Lean_Syntax_6__formatInfo___closed__1 = _init_l___private_Init_Lean_Syntax_6__formatInfo___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Syntax_6__formatInfo___closed__1); l_Lean_Syntax_formatStxAux___main___closed__1 = _init_l_Lean_Syntax_formatStxAux___main___closed__1(); lean_mark_persistent(l_Lean_Syntax_formatStxAux___main___closed__1); l_Lean_Syntax_formatStxAux___main___closed__2 = _init_l_Lean_Syntax_formatStxAux___main___closed__2(); @@ -4643,6 +5463,78 @@ l_Lean_Syntax_HasToString___closed__2 = _init_l_Lean_Syntax_HasToString___closed lean_mark_persistent(l_Lean_Syntax_HasToString___closed__2); l_Lean_Syntax_HasToString = _init_l_Lean_Syntax_HasToString(); lean_mark_persistent(l_Lean_Syntax_HasToString); +l_Lean_Syntax_HasQuote = _init_l_Lean_Syntax_HasQuote(); +lean_mark_persistent(l_Lean_Syntax_HasQuote); +l_Lean_String_HasQuote___closed__1 = _init_l_Lean_String_HasQuote___closed__1(); +lean_mark_persistent(l_Lean_String_HasQuote___closed__1); +l_Lean_String_HasQuote___closed__2 = _init_l_Lean_String_HasQuote___closed__2(); +lean_mark_persistent(l_Lean_String_HasQuote___closed__2); +l_Lean_Nat_HasQuote___closed__1 = _init_l_Lean_Nat_HasQuote___closed__1(); +lean_mark_persistent(l_Lean_Nat_HasQuote___closed__1); +l_Lean_Nat_HasQuote___closed__2 = _init_l_Lean_Nat_HasQuote___closed__2(); +lean_mark_persistent(l_Lean_Nat_HasQuote___closed__2); +l_Lean_Substring_HasQuote___closed__1 = _init_l_Lean_Substring_HasQuote___closed__1(); +lean_mark_persistent(l_Lean_Substring_HasQuote___closed__1); +l_Lean_Substring_HasQuote___closed__2 = _init_l_Lean_Substring_HasQuote___closed__2(); +lean_mark_persistent(l_Lean_Substring_HasQuote___closed__2); +l_Lean_Substring_HasQuote___closed__3 = _init_l_Lean_Substring_HasQuote___closed__3(); +lean_mark_persistent(l_Lean_Substring_HasQuote___closed__3); +l_Lean_Substring_HasQuote___closed__4 = _init_l_Lean_Substring_HasQuote___closed__4(); +lean_mark_persistent(l_Lean_Substring_HasQuote___closed__4); +l___private_Init_Lean_Syntax_7__quoteName___main___closed__1 = _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Syntax_7__quoteName___main___closed__1); +l___private_Init_Lean_Syntax_7__quoteName___main___closed__2 = _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Syntax_7__quoteName___main___closed__2); +l___private_Init_Lean_Syntax_7__quoteName___main___closed__3 = _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Syntax_7__quoteName___main___closed__3); +l___private_Init_Lean_Syntax_7__quoteName___main___closed__4 = _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Syntax_7__quoteName___main___closed__4); +l___private_Init_Lean_Syntax_7__quoteName___main___closed__5 = _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Syntax_7__quoteName___main___closed__5); +l___private_Init_Lean_Syntax_7__quoteName___main___closed__6 = _init_l___private_Init_Lean_Syntax_7__quoteName___main___closed__6(); +lean_mark_persistent(l___private_Init_Lean_Syntax_7__quoteName___main___closed__6); +l_Lean_Name_hasQuote___closed__1 = _init_l_Lean_Name_hasQuote___closed__1(); +lean_mark_persistent(l_Lean_Name_hasQuote___closed__1); +l_Lean_Name_hasQuote = _init_l_Lean_Name_hasQuote(); +lean_mark_persistent(l_Lean_Name_hasQuote); +l_Lean_Prod_hasQuote___rarg___closed__1 = _init_l_Lean_Prod_hasQuote___rarg___closed__1(); +lean_mark_persistent(l_Lean_Prod_hasQuote___rarg___closed__1); +l_Lean_Prod_hasQuote___rarg___closed__2 = _init_l_Lean_Prod_hasQuote___rarg___closed__2(); +lean_mark_persistent(l_Lean_Prod_hasQuote___rarg___closed__2); +l_Lean_Prod_hasQuote___rarg___closed__3 = _init_l_Lean_Prod_hasQuote___rarg___closed__3(); +lean_mark_persistent(l_Lean_Prod_hasQuote___rarg___closed__3); +l_Lean_Prod_hasQuote___rarg___closed__4 = _init_l_Lean_Prod_hasQuote___rarg___closed__4(); +lean_mark_persistent(l_Lean_Prod_hasQuote___rarg___closed__4); +l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__1 = _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__1); +l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__2 = _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__2); +l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__3 = _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__3); +l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__4 = _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__4); +l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__5 = _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__5); +l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__6 = _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__6(); +lean_mark_persistent(l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__6); +l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__7 = _init_l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__7(); +lean_mark_persistent(l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__7); +l_Lean_Array_hasQuote___rarg___closed__1 = _init_l_Lean_Array_hasQuote___rarg___closed__1(); +lean_mark_persistent(l_Lean_Array_hasQuote___rarg___closed__1); +l_Lean_Array_hasQuote___rarg___closed__2 = _init_l_Lean_Array_hasQuote___rarg___closed__2(); +lean_mark_persistent(l_Lean_Array_hasQuote___rarg___closed__2); +l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__1 = _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__1(); +lean_mark_persistent(l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__1); +l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__2 = _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__2(); +lean_mark_persistent(l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__2); +l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__3 = _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__3(); +lean_mark_persistent(l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__3); +l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__4 = _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__4(); +lean_mark_persistent(l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__4); +l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5 = _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5(); +lean_mark_persistent(l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__5); +l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6 = _init_l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6(); +lean_mark_persistent(l___private_Init_Lean_Syntax_9__quoteOption___rarg___closed__6); return lean_mk_io_result(lean_box(0)); } #ifdef __cplusplus diff --git a/stage0/stdlib/Init/Lean/Util/Closure.c b/stage0/stdlib/Init/Lean/Util/Closure.c new file mode 100644 index 0000000000..a8d6b165aa --- /dev/null +++ b/stage0/stdlib/Init/Lean/Util/Closure.c @@ -0,0 +1,6829 @@ +// Lean compiler output +// Module: Init.Lean.Util.Closure +// Imports: Init.Default Init.Lean.MetavarContext Init.Lean.Environment Init.Lean.Util.FoldConsts +#include "runtime/lean.h" +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +lean_object* l_Lean_Closure_mkNewLevelParam___closed__1; +lean_object* lean_expr_update_forall(lean_object*, uint8_t, lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkNewLevelParam___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkNewLevelParam___closed__2; +lean_object* l_Lean_Closure_mkLetDecl___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(lean_object*, lean_object*); +lean_object* l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(lean_object*, lean_object*); +lean_object* l_Lean_Closure_getUserName(lean_object*, lean_object*, lean_object*); +lean_object* l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(lean_object*, lean_object*, lean_object*); +lean_object* l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Closure_collectLevel___boxed(lean_object*, lean_object*, lean_object*); +lean_object* lean_array_uget(lean_object*, size_t); +lean_object* l_Lean_Closure_mkLetDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_expr_update_mdata(lean_object*, lean_object*); +lean_object* l_List_mapM___main___at_Lean_Closure_collectExprAux___main___spec__1___boxed(lean_object*, lean_object*, lean_object*); +lean_object* lean_local_ctx_mk_let_decl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Expr_updateMData_x21___closed__2; +lean_object* lean_array_uset(lean_object*, size_t, lean_object*); +extern lean_object* l_Array_empty___closed__1; +uint8_t l_Lean_Level_hasMVar(lean_object*); +extern lean_object* l_Lean_MetavarContext_getDecl___closed__2; +uint8_t l_AssocList_contains___main___at_Lean_Closure_visitExpr___spec__4(lean_object*, lean_object*); +size_t l_Lean_Level_hash(lean_object*); +lean_object* l_Lean_Closure_collectLevelAux___main___boxed(lean_object*, lean_object*, lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +lean_object* lean_array_get_size(lean_object*); +lean_object* l_AssocList_contains___main___at_Lean_Closure_visitLevel___spec__4___boxed(lean_object*, lean_object*); +extern lean_object* l_Lean_Level_Inhabited; +uint8_t l_Lean_Level_hasParam(lean_object*); +lean_object* l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkFreshFVarId(lean_object*); +lean_object* lean_nat_add(lean_object*, lean_object*); +lean_object* l_AssocList_find_x3f___main___at_Lean_Closure_visitLevel___spec__2___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Closure_collectLevel(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Level_updateMax_x21___closed__2; +extern lean_object* l_Lean_Expr_updateLambdaE_x21___closed__1; +uint32_t l_UInt32_add(uint32_t, uint32_t); +uint8_t l_Lean_Environment_hasUnsafe(lean_object*, lean_object*); +lean_object* l_Lean_LocalContext_getFVars(lean_object*); +extern lean_object* l_Lean_LocalContext_Inhabited___closed__2; +lean_object* l_Lean_mkAuxDefinition(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_mkHashMap___at_Lean_Closure_mkClosure___spec__3(lean_object*); +lean_object* lean_array_fget(lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkClosure___closed__4; +uint8_t l_Lean_Expr_hasLevelParam(lean_object*); +lean_object* l_Lean_Closure_mkNextUserName___rarg(lean_object*); +lean_object* l_AssocList_find_x3f___main___at_Lean_Closure_visitExpr___spec__2(lean_object*, lean_object*); +lean_object* lean_level_update_max(lean_object*, lean_object*, lean_object*); +lean_object* l_AssocList_find_x3f___main___at_Lean_Closure_visitExpr___spec__2___boxed(lean_object*, lean_object*); +lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_appendIndexAfter(lean_object*, lean_object*); +lean_object* l_AssocList_foldlM___main___at_Lean_Closure_visitExpr___spec__7(lean_object*, lean_object*); +lean_object* l_Lean_Closure_collectLevelAux___main(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkClosure___closed__5; +lean_object* l_HashMapImp_expand___at_Lean_Closure_visitExpr___spec__5(lean_object*, lean_object*); +size_t l_Lean_Expr_hash(lean_object*); +lean_object* lean_name_mk_string(lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkFreshFVarId___rarg(lean_object*); +lean_object* l_Lean_Closure_mkClosure___closed__6; +lean_object* l_HashMapImp_moveEntries___main___at_Lean_Closure_visitLevel___spec__6(lean_object*, lean_object*, lean_object*); +size_t lean_usize_modn(size_t, lean_object*); +lean_object* l_Lean_getMaxHeight(lean_object*, lean_object*); +extern lean_object* l_Lean_Expr_updateApp_x21___closed__1; +lean_object* l_Lean_Closure_collectLevelAux(lean_object*, lean_object*, lean_object*); +lean_object* l_HashMapImp_moveEntries___main___at_Lean_Closure_visitExpr___spec__6(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkClosure___closed__3; +lean_object* l_mkHashMapImp___rarg(lean_object*); +lean_object* lean_expr_update_let(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Closure_collectExprAux(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_mkFVar(lean_object*); +lean_object* l_Lean_Closure_collectLevelAux___boxed(lean_object*, lean_object*, lean_object*); +uint8_t l_Lean_Expr_Data_binderInfo(uint64_t); +lean_object* l_Lean_Closure_mkLocalDecl(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_expr_update_proj(lean_object*, lean_object*); +extern lean_object* l_Lean_Expr_updateProj_x21___closed__2; +lean_object* lean_local_ctx_mk_local_decl(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); +lean_object* l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(lean_object*, lean_object*, lean_object*); +lean_object* l_AssocList_replace___main___at_Lean_Closure_visitExpr___spec__8(lean_object*, lean_object*, lean_object*); +lean_object* l_AssocList_find_x3f___main___at_Lean_Closure_visitLevel___spec__2(lean_object*, lean_object*); +lean_object* lean_level_update_imax(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkNextUserName(lean_object*); +uint8_t lean_expr_equal(lean_object*, lean_object*); +lean_object* lean_expr_update_sort(lean_object*, lean_object*); +lean_object* l_List_mapM___main___at_Lean_Closure_collectExprAux___main___spec__1(lean_object*, lean_object*, lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +uint8_t l_Lean_Expr_hasMVar(lean_object*); +lean_object* l_Lean_Closure_mkClosure___closed__1; +lean_object* l_Lean_Environment_addAndCompile(lean_object*, lean_object*, lean_object*); +lean_object* lean_panic_fn(lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkNextUserName___rarg___closed__1; +lean_object* l_Lean_Closure_mkClosure(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Level_updateSucc_x21___closed__2; +lean_object* l_Lean_LocalContext_mkLambda(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkClosure___closed__2; +lean_object* l_Lean_Closure_mkNextUserName___rarg___closed__2; +lean_object* lean_nat_mul(lean_object*, lean_object*); +lean_object* lean_metavar_ctx_find_decl(lean_object*, lean_object*); +lean_object* l_AssocList_foldlM___main___at_Lean_Closure_visitLevel___spec__7(lean_object*, lean_object*); +lean_object* l_HashMapImp_expand___at_Lean_Closure_visitLevel___spec__5(lean_object*, lean_object*); +lean_object* l_ShareCommonT_withShareCommon___at_Lean_Closure_mkClosure___spec__1(lean_object*, lean_object*); +extern lean_object* l_Lean_Expr_updateLet_x21___closed__1; +lean_object* lean_expr_update_lambda(lean_object*, uint8_t, lean_object*, lean_object*); +lean_object* lean_level_update_succ(lean_object*, lean_object*); +extern lean_object* l_Lean_LocalContext_get_x21___closed__1; +lean_object* l_Array_toList___rarg(lean_object*); +extern lean_object* l_Lean_Expr_Inhabited; +lean_object* lean_mk_array(lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkFreshFVarId___boxed(lean_object*); +lean_object* l_Lean_Closure_mkLocalDecl___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_mkHashMap___at_Lean_Closure_mkClosure___spec__2(lean_object*); +lean_object* l_Lean_Closure_collectExprAux___main(lean_object*, lean_object*, lean_object*); +extern lean_object* l_ShareCommon_State_empty; +lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_local_ctx_find(lean_object*, lean_object*); +lean_object* l_Lean_mkLevelParam(lean_object*); +lean_object* l_Lean_LocalContext_mkForall(lean_object*, lean_object*, lean_object*); +lean_object* lean_expr_update_app(lean_object*, lean_object*, lean_object*); +lean_object* l_AssocList_replace___main___at_Lean_Closure_visitLevel___spec__8(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Closure_mkNextUserName___boxed(lean_object*); +lean_object* lean_state_sharecommon(lean_object*, lean_object*); +uint8_t lean_level_eq(lean_object*, lean_object*); +lean_object* l_Lean_Closure_visitExpr(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_Lean_Expr_hasFVar(lean_object*); +lean_object* l_Lean_Closure_mkNewLevelParam(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Closure_getUserName___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_mkConst(lean_object*, lean_object*); +lean_object* l_Lean_Closure_collectExpr(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Expr_updateForallE_x21___closed__1; +lean_object* lean_name_mk_numeral(lean_object*, lean_object*); +lean_object* lean_expr_update_const(lean_object*, lean_object*); +extern lean_object* l_Lean_Level_updateIMax_x21___closed__2; +lean_object* l_Lean_Closure_visitLevel(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_AssocList_contains___main___at_Lean_Closure_visitLevel___spec__4(lean_object*, lean_object*); +lean_object* l_AssocList_contains___main___at_Lean_Closure_visitExpr___spec__4___boxed(lean_object*, lean_object*); +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +lean_object* l_Lean_mkAuxDefinition___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_AssocList_find_x3f___main___at_Lean_Closure_visitLevel___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; +x_3 = lean_box(0); +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_ctor_get(x_2, 2); +x_7 = lean_level_eq(x_4, x_1); +if (x_7 == 0) +{ +x_2 = x_6; +goto _start; +} +else +{ +lean_object* x_9; +lean_inc(x_5); +x_9 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_9, 0, x_5); +return x_9; +} +} +} +} +lean_object* l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_8; +x_3 = lean_ctor_get(x_1, 1); +x_4 = lean_array_get_size(x_3); +x_5 = l_Lean_Level_hash(x_2); +x_6 = lean_usize_modn(x_5, x_4); +lean_dec(x_4); +x_7 = lean_array_uget(x_3, x_6); +x_8 = l_AssocList_find_x3f___main___at_Lean_Closure_visitLevel___spec__2(x_2, x_7); +lean_dec(x_7); +return x_8; +} +} +uint8_t l_AssocList_contains___main___at_Lean_Closure_visitLevel___spec__4(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = 0; +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 2); +x_6 = lean_level_eq(x_4, x_1); +if (x_6 == 0) +{ +x_2 = x_5; +goto _start; +} +else +{ +uint8_t x_8; +x_8 = 1; +return x_8; +} +} +} +} +lean_object* l_AssocList_foldlM___main___at_Lean_Closure_visitLevel___spec__7(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +return x_1; +} +else +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; size_t x_7; size_t x_8; lean_object* x_9; lean_object* x_10; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 2); +x_6 = lean_array_get_size(x_1); +x_7 = l_Lean_Level_hash(x_4); +x_8 = lean_usize_modn(x_7, x_6); +lean_dec(x_6); +x_9 = lean_array_uget(x_1, x_8); +lean_ctor_set(x_2, 2, x_9); +x_10 = lean_array_uset(x_1, x_8, x_2); +x_1 = x_10; +x_2 = x_5; +goto _start; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; size_t x_16; size_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_12 = lean_ctor_get(x_2, 0); +x_13 = lean_ctor_get(x_2, 1); +x_14 = lean_ctor_get(x_2, 2); +lean_inc(x_14); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_2); +x_15 = lean_array_get_size(x_1); +x_16 = l_Lean_Level_hash(x_12); +x_17 = lean_usize_modn(x_16, x_15); +lean_dec(x_15); +x_18 = lean_array_uget(x_1, x_17); +x_19 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_13); +lean_ctor_set(x_19, 2, x_18); +x_20 = lean_array_uset(x_1, x_17, x_19); +x_1 = x_20; +x_2 = x_14; +goto _start; +} +} +} +} +lean_object* l_HashMapImp_moveEntries___main___at_Lean_Closure_visitLevel___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_array_get_size(x_2); +x_5 = lean_nat_dec_lt(x_1, x_4); +lean_dec(x_4); +if (x_5 == 0) +{ +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_6 = lean_array_fget(x_2, x_1); +x_7 = lean_box(0); +x_8 = lean_array_fset(x_2, x_1, x_7); +x_9 = l_AssocList_foldlM___main___at_Lean_Closure_visitLevel___spec__7(x_3, x_6); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_8; +x_3 = x_9; +goto _start; +} +} +} +lean_object* l_HashMapImp_expand___at_Lean_Closure_visitLevel___spec__5(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; +x_3 = lean_array_get_size(x_2); +x_4 = lean_unsigned_to_nat(2u); +x_5 = lean_nat_mul(x_3, x_4); +lean_dec(x_3); +x_6 = lean_box(0); +x_7 = lean_mk_array(x_5, x_6); +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_HashMapImp_moveEntries___main___at_Lean_Closure_visitLevel___spec__6(x_8, x_2, x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +return x_10; +} +} +lean_object* l_AssocList_replace___main___at_Lean_Closure_visitLevel___spec__8(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +else +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +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_ctor_get(x_3, 1); +x_7 = lean_ctor_get(x_3, 2); +x_8 = lean_level_eq(x_5, x_1); +if (x_8 == 0) +{ +lean_object* x_9; +x_9 = l_AssocList_replace___main___at_Lean_Closure_visitLevel___spec__8(x_1, x_2, x_7); +lean_ctor_set(x_3, 2, x_9); +return x_3; +} +else +{ +lean_dec(x_6); +lean_dec(x_5); +lean_ctor_set(x_3, 1, x_2); +lean_ctor_set(x_3, 0, x_1); +return x_3; +} +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_10 = lean_ctor_get(x_3, 0); +x_11 = lean_ctor_get(x_3, 1); +x_12 = lean_ctor_get(x_3, 2); +lean_inc(x_12); +lean_inc(x_11); +lean_inc(x_10); +lean_dec(x_3); +x_13 = lean_level_eq(x_10, x_1); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; +x_14 = l_AssocList_replace___main___at_Lean_Closure_visitLevel___spec__8(x_1, x_2, x_12); +x_15 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_15, 0, x_10); +lean_ctor_set(x_15, 1, x_11); +lean_ctor_set(x_15, 2, x_14); +return x_15; +} +else +{ +lean_object* x_16; +lean_dec(x_11); +lean_dec(x_10); +x_16 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_16, 0, x_1); +lean_ctor_set(x_16, 1, x_2); +lean_ctor_set(x_16, 2, x_12); +return x_16; +} +} +} +} +} +lean_object* l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_1); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; size_t x_8; size_t x_9; lean_object* x_10; uint8_t x_11; +x_5 = lean_ctor_get(x_1, 0); +x_6 = lean_ctor_get(x_1, 1); +x_7 = lean_array_get_size(x_6); +x_8 = l_Lean_Level_hash(x_2); +x_9 = lean_usize_modn(x_8, x_7); +x_10 = lean_array_uget(x_6, x_9); +x_11 = l_AssocList_contains___main___at_Lean_Closure_visitLevel___spec__4(x_2, x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_12 = lean_unsigned_to_nat(1u); +x_13 = lean_nat_add(x_5, x_12); +lean_dec(x_5); +x_14 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_14, 0, x_2); +lean_ctor_set(x_14, 1, x_3); +lean_ctor_set(x_14, 2, x_10); +x_15 = lean_array_uset(x_6, x_9, x_14); +x_16 = lean_nat_dec_le(x_13, x_7); +lean_dec(x_7); +if (x_16 == 0) +{ +lean_object* x_17; +lean_free_object(x_1); +x_17 = l_HashMapImp_expand___at_Lean_Closure_visitLevel___spec__5(x_13, x_15); +return x_17; +} +else +{ +lean_ctor_set(x_1, 1, x_15); +lean_ctor_set(x_1, 0, x_13); +return x_1; +} +} +else +{ +lean_object* x_18; lean_object* x_19; +lean_dec(x_7); +x_18 = l_AssocList_replace___main___at_Lean_Closure_visitLevel___spec__8(x_2, x_3, x_10); +x_19 = lean_array_uset(x_6, x_9, x_18); +lean_ctor_set(x_1, 1, x_19); +return x_1; +} +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; size_t x_23; size_t x_24; lean_object* x_25; uint8_t x_26; +x_20 = lean_ctor_get(x_1, 0); +x_21 = lean_ctor_get(x_1, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_1); +x_22 = lean_array_get_size(x_21); +x_23 = l_Lean_Level_hash(x_2); +x_24 = lean_usize_modn(x_23, x_22); +x_25 = lean_array_uget(x_21, x_24); +x_26 = l_AssocList_contains___main___at_Lean_Closure_visitLevel___spec__4(x_2, x_25); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_27 = lean_unsigned_to_nat(1u); +x_28 = lean_nat_add(x_20, x_27); +lean_dec(x_20); +x_29 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_29, 0, x_2); +lean_ctor_set(x_29, 1, x_3); +lean_ctor_set(x_29, 2, x_25); +x_30 = lean_array_uset(x_21, x_24, x_29); +x_31 = lean_nat_dec_le(x_28, x_22); +lean_dec(x_22); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = l_HashMapImp_expand___at_Lean_Closure_visitLevel___spec__5(x_28, x_30); +return x_32; +} +else +{ +lean_object* x_33; +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_28); +lean_ctor_set(x_33, 1, x_30); +return x_33; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +lean_dec(x_22); +x_34 = l_AssocList_replace___main___at_Lean_Closure_visitLevel___spec__8(x_2, x_3, x_25); +x_35 = lean_array_uset(x_21, x_24, x_34); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_20); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +} +} +lean_object* l_Lean_Closure_visitLevel(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; uint8_t x_49; +x_49 = l_Lean_Level_hasMVar(x_2); +if (x_49 == 0) +{ +uint8_t x_50; +x_50 = l_Lean_Level_hasParam(x_2); +if (x_50 == 0) +{ +lean_object* x_51; +lean_dec(x_3); +lean_dec(x_1); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_2); +lean_ctor_set(x_51, 1, x_4); +return x_51; +} +else +{ +lean_object* x_52; +x_52 = lean_box(0); +x_5 = x_52; +goto block_48; +} +} +else +{ +lean_object* x_53; +x_53 = lean_box(0); +x_5 = x_53; +goto block_48; +} +block_48: +{ +lean_object* x_6; lean_object* x_7; +lean_dec(x_5); +x_6 = lean_ctor_get(x_4, 2); +lean_inc(x_6); +x_7 = l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(x_6, x_2); +lean_dec(x_6); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; +lean_inc(x_2); +x_8 = lean_apply_3(x_1, x_2, x_3, x_4); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; uint8_t x_11; +x_10 = lean_ctor_get(x_8, 1); +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_8, 0); +x_13 = lean_ctor_get(x_10, 2); +lean_inc(x_12); +x_14 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_13, x_2, x_12); +lean_ctor_set(x_10, 2, 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; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_15 = lean_ctor_get(x_8, 0); +x_16 = lean_ctor_get(x_10, 0); +x_17 = lean_ctor_get(x_10, 1); +x_18 = lean_ctor_get(x_10, 2); +x_19 = lean_ctor_get(x_10, 3); +x_20 = lean_ctor_get(x_10, 4); +x_21 = lean_ctor_get(x_10, 5); +x_22 = lean_ctor_get(x_10, 6); +x_23 = lean_ctor_get(x_10, 7); +x_24 = lean_ctor_get(x_10, 8); +lean_inc(x_24); +lean_inc(x_23); +lean_inc(x_22); +lean_inc(x_21); +lean_inc(x_20); +lean_inc(x_19); +lean_inc(x_18); +lean_inc(x_17); +lean_inc(x_16); +lean_dec(x_10); +lean_inc(x_15); +x_25 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_18, x_2, x_15); +x_26 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_26, 0, x_16); +lean_ctor_set(x_26, 1, x_17); +lean_ctor_set(x_26, 2, x_25); +lean_ctor_set(x_26, 3, x_19); +lean_ctor_set(x_26, 4, x_20); +lean_ctor_set(x_26, 5, x_21); +lean_ctor_set(x_26, 6, x_22); +lean_ctor_set(x_26, 7, x_23); +lean_ctor_set(x_26, 8, x_24); +lean_ctor_set(x_8, 1, x_26); +return x_8; +} +} +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; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_27 = lean_ctor_get(x_8, 1); +x_28 = lean_ctor_get(x_8, 0); +lean_inc(x_27); +lean_inc(x_28); +lean_dec(x_8); +x_29 = lean_ctor_get(x_27, 0); +lean_inc(x_29); +x_30 = lean_ctor_get(x_27, 1); +lean_inc(x_30); +x_31 = lean_ctor_get(x_27, 2); +lean_inc(x_31); +x_32 = lean_ctor_get(x_27, 3); +lean_inc(x_32); +x_33 = lean_ctor_get(x_27, 4); +lean_inc(x_33); +x_34 = lean_ctor_get(x_27, 5); +lean_inc(x_34); +x_35 = lean_ctor_get(x_27, 6); +lean_inc(x_35); +x_36 = lean_ctor_get(x_27, 7); +lean_inc(x_36); +x_37 = lean_ctor_get(x_27, 8); +lean_inc(x_37); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + lean_ctor_release(x_27, 2); + lean_ctor_release(x_27, 3); + lean_ctor_release(x_27, 4); + lean_ctor_release(x_27, 5); + lean_ctor_release(x_27, 6); + lean_ctor_release(x_27, 7); + lean_ctor_release(x_27, 8); + x_38 = x_27; +} else { + lean_dec_ref(x_27); + x_38 = lean_box(0); +} +lean_inc(x_28); +x_39 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_31, x_2, x_28); +if (lean_is_scalar(x_38)) { + x_40 = lean_alloc_ctor(0, 9, 0); +} else { + x_40 = x_38; +} +lean_ctor_set(x_40, 0, x_29); +lean_ctor_set(x_40, 1, x_30); +lean_ctor_set(x_40, 2, x_39); +lean_ctor_set(x_40, 3, x_32); +lean_ctor_set(x_40, 4, x_33); +lean_ctor_set(x_40, 5, x_34); +lean_ctor_set(x_40, 6, x_35); +lean_ctor_set(x_40, 7, x_36); +lean_ctor_set(x_40, 8, x_37); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_28); +lean_ctor_set(x_41, 1, x_40); +return x_41; +} +} +else +{ +uint8_t x_42; +lean_dec(x_2); +x_42 = !lean_is_exclusive(x_8); +if (x_42 == 0) +{ +return x_8; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_8, 0); +x_44 = lean_ctor_get(x_8, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_8); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +return x_45; +} +} +} +else +{ +lean_object* x_46; lean_object* x_47; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_46 = lean_ctor_get(x_7, 0); +lean_inc(x_46); +lean_dec(x_7); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_4); +return x_47; +} +} +} +} +lean_object* l_AssocList_find_x3f___main___at_Lean_Closure_visitLevel___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_AssocList_find_x3f___main___at_Lean_Closure_visitLevel___spec__2(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_AssocList_contains___main___at_Lean_Closure_visitLevel___spec__4___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_AssocList_contains___main___at_Lean_Closure_visitLevel___spec__4(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_Closure_mkNewLevelParam___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("u"); +return x_1; +} +} +lean_object* _init_l_Lean_Closure_mkNewLevelParam___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Closure_mkNewLevelParam___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Closure_mkNewLevelParam(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_5 = lean_ctor_get(x_3, 4); +x_6 = lean_ctor_get(x_3, 5); +x_7 = lean_ctor_get(x_3, 6); +x_8 = l_Lean_Closure_mkNewLevelParam___closed__2; +lean_inc(x_6); +x_9 = l_Lean_Name_appendIndexAfter(x_8, x_6); +lean_inc(x_9); +x_10 = lean_array_push(x_5, x_9); +x_11 = lean_unsigned_to_nat(1u); +x_12 = lean_nat_add(x_6, x_11); +lean_dec(x_6); +x_13 = lean_array_push(x_7, x_1); +lean_ctor_set(x_3, 6, x_13); +lean_ctor_set(x_3, 5, x_12); +lean_ctor_set(x_3, 4, x_10); +x_14 = l_Lean_mkLevelParam(x_9); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_3); +return x_15; +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 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; +x_16 = lean_ctor_get(x_3, 0); +x_17 = lean_ctor_get(x_3, 1); +x_18 = lean_ctor_get(x_3, 2); +x_19 = lean_ctor_get(x_3, 3); +x_20 = lean_ctor_get(x_3, 4); +x_21 = lean_ctor_get(x_3, 5); +x_22 = lean_ctor_get(x_3, 6); +x_23 = lean_ctor_get(x_3, 7); +x_24 = lean_ctor_get(x_3, 8); +lean_inc(x_24); +lean_inc(x_23); +lean_inc(x_22); +lean_inc(x_21); +lean_inc(x_20); +lean_inc(x_19); +lean_inc(x_18); +lean_inc(x_17); +lean_inc(x_16); +lean_dec(x_3); +x_25 = l_Lean_Closure_mkNewLevelParam___closed__2; +lean_inc(x_21); +x_26 = l_Lean_Name_appendIndexAfter(x_25, x_21); +lean_inc(x_26); +x_27 = lean_array_push(x_20, x_26); +x_28 = lean_unsigned_to_nat(1u); +x_29 = lean_nat_add(x_21, x_28); +lean_dec(x_21); +x_30 = lean_array_push(x_22, x_1); +x_31 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_31, 0, x_16); +lean_ctor_set(x_31, 1, x_17); +lean_ctor_set(x_31, 2, x_18); +lean_ctor_set(x_31, 3, x_19); +lean_ctor_set(x_31, 4, x_27); +lean_ctor_set(x_31, 5, x_29); +lean_ctor_set(x_31, 6, x_30); +lean_ctor_set(x_31, 7, x_23); +lean_ctor_set(x_31, 8, x_24); +x_32 = l_Lean_mkLevelParam(x_26); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_31); +return x_33; +} +} +} +lean_object* l_Lean_Closure_mkNewLevelParam___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Closure_mkNewLevelParam(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +lean_object* l_Lean_Closure_collectLevelAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +switch (lean_obj_tag(x_1)) { +case 0: +{ +lean_object* x_13; +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_1); +lean_ctor_set(x_13, 1, x_3); +return x_13; +} +case 1: +{ +lean_object* x_14; lean_object* x_15; uint8_t x_37; +x_14 = lean_ctor_get(x_1, 0); +lean_inc(x_14); +x_37 = l_Lean_Level_hasMVar(x_14); +if (x_37 == 0) +{ +uint8_t x_38; +x_38 = l_Lean_Level_hasParam(x_14); +if (x_38 == 0) +{ +x_4 = x_14; +x_5 = x_3; +goto block_12; +} +else +{ +lean_object* x_39; +x_39 = lean_box(0); +x_15 = x_39; +goto block_36; +} +} +else +{ +lean_object* x_40; +x_40 = lean_box(0); +x_15 = x_40; +goto block_36; +} +block_36: +{ +lean_object* x_16; lean_object* x_17; +lean_dec(x_15); +x_16 = lean_ctor_get(x_3, 2); +lean_inc(x_16); +x_17 = l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(x_16, x_14); +lean_dec(x_16); +if (lean_obj_tag(x_17) == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; +lean_inc(x_14); +x_18 = l_Lean_Closure_collectLevelAux___main(x_14, x_2, x_3); +x_19 = lean_ctor_get(x_18, 1); +lean_inc(x_19); +x_20 = lean_ctor_get(x_18, 0); +lean_inc(x_20); +lean_dec(x_18); +x_21 = !lean_is_exclusive(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; +x_22 = lean_ctor_get(x_19, 2); +lean_inc(x_20); +x_23 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_22, x_14, x_20); +lean_ctor_set(x_19, 2, x_23); +x_4 = x_20; +x_5 = x_19; +goto block_12; +} +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; +x_24 = lean_ctor_get(x_19, 0); +x_25 = lean_ctor_get(x_19, 1); +x_26 = lean_ctor_get(x_19, 2); +x_27 = lean_ctor_get(x_19, 3); +x_28 = lean_ctor_get(x_19, 4); +x_29 = lean_ctor_get(x_19, 5); +x_30 = lean_ctor_get(x_19, 6); +x_31 = lean_ctor_get(x_19, 7); +x_32 = lean_ctor_get(x_19, 8); +lean_inc(x_32); +lean_inc(x_31); +lean_inc(x_30); +lean_inc(x_29); +lean_inc(x_28); +lean_inc(x_27); +lean_inc(x_26); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_19); +lean_inc(x_20); +x_33 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_26, x_14, x_20); +x_34 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_34, 0, x_24); +lean_ctor_set(x_34, 1, x_25); +lean_ctor_set(x_34, 2, x_33); +lean_ctor_set(x_34, 3, x_27); +lean_ctor_set(x_34, 4, x_28); +lean_ctor_set(x_34, 5, x_29); +lean_ctor_set(x_34, 6, x_30); +lean_ctor_set(x_34, 7, x_31); +lean_ctor_set(x_34, 8, x_32); +x_4 = x_20; +x_5 = x_34; +goto block_12; +} +} +else +{ +lean_object* x_35; +lean_dec(x_14); +x_35 = lean_ctor_get(x_17, 0); +lean_inc(x_35); +lean_dec(x_17); +x_4 = x_35; +x_5 = x_3; +goto block_12; +} +} +} +case 2: +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_81; uint8_t x_103; +x_41 = lean_ctor_get(x_1, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_1, 1); +lean_inc(x_42); +x_103 = l_Lean_Level_hasMVar(x_41); +if (x_103 == 0) +{ +uint8_t x_104; +x_104 = l_Lean_Level_hasParam(x_41); +if (x_104 == 0) +{ +x_43 = x_41; +x_44 = x_3; +goto block_80; +} +else +{ +lean_object* x_105; +x_105 = lean_box(0); +x_81 = x_105; +goto block_102; +} +} +else +{ +lean_object* x_106; +x_106 = lean_box(0); +x_81 = x_106; +goto block_102; +} +block_80: +{ +lean_object* x_45; lean_object* x_46; lean_object* x_54; uint8_t x_76; +x_76 = l_Lean_Level_hasMVar(x_42); +if (x_76 == 0) +{ +uint8_t x_77; +x_77 = l_Lean_Level_hasParam(x_42); +if (x_77 == 0) +{ +x_45 = x_42; +x_46 = x_44; +goto block_53; +} +else +{ +lean_object* x_78; +x_78 = lean_box(0); +x_54 = x_78; +goto block_75; +} +} +else +{ +lean_object* x_79; +x_79 = lean_box(0); +x_54 = x_79; +goto block_75; +} +block_53: +{ +if (lean_obj_tag(x_1) == 2) +{ +lean_object* x_47; lean_object* x_48; +x_47 = lean_level_update_max(x_1, x_43, x_45); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_46); +return x_48; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +lean_dec(x_45); +lean_dec(x_43); +lean_dec(x_1); +x_49 = l_Lean_Level_Inhabited; +x_50 = l_Lean_Level_updateMax_x21___closed__2; +x_51 = lean_panic_fn(x_49, x_50); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_46); +return x_52; +} +} +block_75: +{ +lean_object* x_55; lean_object* x_56; +lean_dec(x_54); +x_55 = lean_ctor_get(x_44, 2); +lean_inc(x_55); +x_56 = l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(x_55, x_42); +lean_dec(x_55); +if (lean_obj_tag(x_56) == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +lean_inc(x_42); +x_57 = l_Lean_Closure_collectLevelAux___main(x_42, x_2, x_44); +x_58 = lean_ctor_get(x_57, 1); +lean_inc(x_58); +x_59 = lean_ctor_get(x_57, 0); +lean_inc(x_59); +lean_dec(x_57); +x_60 = !lean_is_exclusive(x_58); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; +x_61 = lean_ctor_get(x_58, 2); +lean_inc(x_59); +x_62 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_61, x_42, x_59); +lean_ctor_set(x_58, 2, x_62); +x_45 = x_59; +x_46 = x_58; +goto block_53; +} +else +{ +lean_object* x_63; lean_object* x_64; 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; lean_object* x_72; lean_object* x_73; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +x_65 = lean_ctor_get(x_58, 2); +x_66 = lean_ctor_get(x_58, 3); +x_67 = lean_ctor_get(x_58, 4); +x_68 = lean_ctor_get(x_58, 5); +x_69 = lean_ctor_get(x_58, 6); +x_70 = lean_ctor_get(x_58, 7); +x_71 = lean_ctor_get(x_58, 8); +lean_inc(x_71); +lean_inc(x_70); +lean_inc(x_69); +lean_inc(x_68); +lean_inc(x_67); +lean_inc(x_66); +lean_inc(x_65); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +lean_inc(x_59); +x_72 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_65, x_42, x_59); +x_73 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_73, 0, x_63); +lean_ctor_set(x_73, 1, x_64); +lean_ctor_set(x_73, 2, x_72); +lean_ctor_set(x_73, 3, x_66); +lean_ctor_set(x_73, 4, x_67); +lean_ctor_set(x_73, 5, x_68); +lean_ctor_set(x_73, 6, x_69); +lean_ctor_set(x_73, 7, x_70); +lean_ctor_set(x_73, 8, x_71); +x_45 = x_59; +x_46 = x_73; +goto block_53; +} +} +else +{ +lean_object* x_74; +lean_dec(x_42); +x_74 = lean_ctor_get(x_56, 0); +lean_inc(x_74); +lean_dec(x_56); +x_45 = x_74; +x_46 = x_44; +goto block_53; +} +} +} +block_102: +{ +lean_object* x_82; lean_object* x_83; +lean_dec(x_81); +x_82 = lean_ctor_get(x_3, 2); +lean_inc(x_82); +x_83 = l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(x_82, x_41); +lean_dec(x_82); +if (lean_obj_tag(x_83) == 0) +{ +lean_object* x_84; lean_object* x_85; lean_object* x_86; uint8_t x_87; +lean_inc(x_41); +x_84 = l_Lean_Closure_collectLevelAux___main(x_41, x_2, x_3); +x_85 = lean_ctor_get(x_84, 1); +lean_inc(x_85); +x_86 = lean_ctor_get(x_84, 0); +lean_inc(x_86); +lean_dec(x_84); +x_87 = !lean_is_exclusive(x_85); +if (x_87 == 0) +{ +lean_object* x_88; lean_object* x_89; +x_88 = lean_ctor_get(x_85, 2); +lean_inc(x_86); +x_89 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_88, x_41, x_86); +lean_ctor_set(x_85, 2, x_89); +x_43 = x_86; +x_44 = x_85; +goto block_80; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_90 = lean_ctor_get(x_85, 0); +x_91 = lean_ctor_get(x_85, 1); +x_92 = lean_ctor_get(x_85, 2); +x_93 = lean_ctor_get(x_85, 3); +x_94 = lean_ctor_get(x_85, 4); +x_95 = lean_ctor_get(x_85, 5); +x_96 = lean_ctor_get(x_85, 6); +x_97 = lean_ctor_get(x_85, 7); +x_98 = lean_ctor_get(x_85, 8); +lean_inc(x_98); +lean_inc(x_97); +lean_inc(x_96); +lean_inc(x_95); +lean_inc(x_94); +lean_inc(x_93); +lean_inc(x_92); +lean_inc(x_91); +lean_inc(x_90); +lean_dec(x_85); +lean_inc(x_86); +x_99 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_92, x_41, x_86); +x_100 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_100, 0, x_90); +lean_ctor_set(x_100, 1, x_91); +lean_ctor_set(x_100, 2, x_99); +lean_ctor_set(x_100, 3, x_93); +lean_ctor_set(x_100, 4, x_94); +lean_ctor_set(x_100, 5, x_95); +lean_ctor_set(x_100, 6, x_96); +lean_ctor_set(x_100, 7, x_97); +lean_ctor_set(x_100, 8, x_98); +x_43 = x_86; +x_44 = x_100; +goto block_80; +} +} +else +{ +lean_object* x_101; +lean_dec(x_41); +x_101 = lean_ctor_get(x_83, 0); +lean_inc(x_101); +lean_dec(x_83); +x_43 = x_101; +x_44 = x_3; +goto block_80; +} +} +} +case 3: +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_147; uint8_t x_169; +x_107 = lean_ctor_get(x_1, 0); +lean_inc(x_107); +x_108 = lean_ctor_get(x_1, 1); +lean_inc(x_108); +x_169 = l_Lean_Level_hasMVar(x_107); +if (x_169 == 0) +{ +uint8_t x_170; +x_170 = l_Lean_Level_hasParam(x_107); +if (x_170 == 0) +{ +x_109 = x_107; +x_110 = x_3; +goto block_146; +} +else +{ +lean_object* x_171; +x_171 = lean_box(0); +x_147 = x_171; +goto block_168; +} +} +else +{ +lean_object* x_172; +x_172 = lean_box(0); +x_147 = x_172; +goto block_168; +} +block_146: +{ +lean_object* x_111; lean_object* x_112; lean_object* x_120; uint8_t x_142; +x_142 = l_Lean_Level_hasMVar(x_108); +if (x_142 == 0) +{ +uint8_t x_143; +x_143 = l_Lean_Level_hasParam(x_108); +if (x_143 == 0) +{ +x_111 = x_108; +x_112 = x_110; +goto block_119; +} +else +{ +lean_object* x_144; +x_144 = lean_box(0); +x_120 = x_144; +goto block_141; +} +} +else +{ +lean_object* x_145; +x_145 = lean_box(0); +x_120 = x_145; +goto block_141; +} +block_119: +{ +if (lean_obj_tag(x_1) == 3) +{ +lean_object* x_113; lean_object* x_114; +x_113 = lean_level_update_imax(x_1, x_109, x_111); +x_114 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_114, 0, x_113); +lean_ctor_set(x_114, 1, x_112); +return x_114; +} +else +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; +lean_dec(x_111); +lean_dec(x_109); +lean_dec(x_1); +x_115 = l_Lean_Level_Inhabited; +x_116 = l_Lean_Level_updateIMax_x21___closed__2; +x_117 = lean_panic_fn(x_115, x_116); +x_118 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_112); +return x_118; +} +} +block_141: +{ +lean_object* x_121; lean_object* x_122; +lean_dec(x_120); +x_121 = lean_ctor_get(x_110, 2); +lean_inc(x_121); +x_122 = l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(x_121, x_108); +lean_dec(x_121); +if (lean_obj_tag(x_122) == 0) +{ +lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; +lean_inc(x_108); +x_123 = l_Lean_Closure_collectLevelAux___main(x_108, x_2, x_110); +x_124 = lean_ctor_get(x_123, 1); +lean_inc(x_124); +x_125 = lean_ctor_get(x_123, 0); +lean_inc(x_125); +lean_dec(x_123); +x_126 = !lean_is_exclusive(x_124); +if (x_126 == 0) +{ +lean_object* x_127; lean_object* x_128; +x_127 = lean_ctor_get(x_124, 2); +lean_inc(x_125); +x_128 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_127, x_108, x_125); +lean_ctor_set(x_124, 2, x_128); +x_111 = x_125; +x_112 = x_124; +goto block_119; +} +else +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_129 = lean_ctor_get(x_124, 0); +x_130 = lean_ctor_get(x_124, 1); +x_131 = lean_ctor_get(x_124, 2); +x_132 = lean_ctor_get(x_124, 3); +x_133 = lean_ctor_get(x_124, 4); +x_134 = lean_ctor_get(x_124, 5); +x_135 = lean_ctor_get(x_124, 6); +x_136 = lean_ctor_get(x_124, 7); +x_137 = lean_ctor_get(x_124, 8); +lean_inc(x_137); +lean_inc(x_136); +lean_inc(x_135); +lean_inc(x_134); +lean_inc(x_133); +lean_inc(x_132); +lean_inc(x_131); +lean_inc(x_130); +lean_inc(x_129); +lean_dec(x_124); +lean_inc(x_125); +x_138 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_131, x_108, x_125); +x_139 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_139, 0, x_129); +lean_ctor_set(x_139, 1, x_130); +lean_ctor_set(x_139, 2, x_138); +lean_ctor_set(x_139, 3, x_132); +lean_ctor_set(x_139, 4, x_133); +lean_ctor_set(x_139, 5, x_134); +lean_ctor_set(x_139, 6, x_135); +lean_ctor_set(x_139, 7, x_136); +lean_ctor_set(x_139, 8, x_137); +x_111 = x_125; +x_112 = x_139; +goto block_119; +} +} +else +{ +lean_object* x_140; +lean_dec(x_108); +x_140 = lean_ctor_get(x_122, 0); +lean_inc(x_140); +lean_dec(x_122); +x_111 = x_140; +x_112 = x_110; +goto block_119; +} +} +} +block_168: +{ +lean_object* x_148; lean_object* x_149; +lean_dec(x_147); +x_148 = lean_ctor_get(x_3, 2); +lean_inc(x_148); +x_149 = l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(x_148, x_107); +lean_dec(x_148); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; uint8_t x_153; +lean_inc(x_107); +x_150 = l_Lean_Closure_collectLevelAux___main(x_107, x_2, x_3); +x_151 = lean_ctor_get(x_150, 1); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 0); +lean_inc(x_152); +lean_dec(x_150); +x_153 = !lean_is_exclusive(x_151); +if (x_153 == 0) +{ +lean_object* x_154; lean_object* x_155; +x_154 = lean_ctor_get(x_151, 2); +lean_inc(x_152); +x_155 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_154, x_107, x_152); +lean_ctor_set(x_151, 2, x_155); +x_109 = x_152; +x_110 = x_151; +goto block_146; +} +else +{ +lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; +x_156 = lean_ctor_get(x_151, 0); +x_157 = lean_ctor_get(x_151, 1); +x_158 = lean_ctor_get(x_151, 2); +x_159 = lean_ctor_get(x_151, 3); +x_160 = lean_ctor_get(x_151, 4); +x_161 = lean_ctor_get(x_151, 5); +x_162 = lean_ctor_get(x_151, 6); +x_163 = lean_ctor_get(x_151, 7); +x_164 = lean_ctor_get(x_151, 8); +lean_inc(x_164); +lean_inc(x_163); +lean_inc(x_162); +lean_inc(x_161); +lean_inc(x_160); +lean_inc(x_159); +lean_inc(x_158); +lean_inc(x_157); +lean_inc(x_156); +lean_dec(x_151); +lean_inc(x_152); +x_165 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_158, x_107, x_152); +x_166 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_166, 0, x_156); +lean_ctor_set(x_166, 1, x_157); +lean_ctor_set(x_166, 2, x_165); +lean_ctor_set(x_166, 3, x_159); +lean_ctor_set(x_166, 4, x_160); +lean_ctor_set(x_166, 5, x_161); +lean_ctor_set(x_166, 6, x_162); +lean_ctor_set(x_166, 7, x_163); +lean_ctor_set(x_166, 8, x_164); +x_109 = x_152; +x_110 = x_166; +goto block_146; +} +} +else +{ +lean_object* x_167; +lean_dec(x_107); +x_167 = lean_ctor_get(x_149, 0); +lean_inc(x_167); +lean_dec(x_149); +x_109 = x_167; +x_110 = x_3; +goto block_146; +} +} +} +default: +{ +lean_object* x_173; +x_173 = l_Lean_Closure_mkNewLevelParam(x_1, x_2, x_3); +return x_173; +} +} +block_12: +{ +if (lean_obj_tag(x_1) == 1) +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_level_update_succ(x_1, x_4); +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; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_4); +lean_dec(x_1); +x_8 = l_Lean_Level_Inhabited; +x_9 = l_Lean_Level_updateSucc_x21___closed__2; +x_10 = lean_panic_fn(x_8, x_9); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_5); +return x_11; +} +} +} +} +lean_object* l_Lean_Closure_collectLevelAux___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Closure_collectLevelAux___main(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +lean_object* l_Lean_Closure_collectLevelAux(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Closure_collectLevelAux___main(x_1, x_2, x_3); +return x_4; +} +} +lean_object* l_Lean_Closure_collectLevelAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Closure_collectLevelAux(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +lean_object* l_Lean_Closure_collectLevel(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_44; +x_44 = l_Lean_Level_hasMVar(x_1); +if (x_44 == 0) +{ +uint8_t x_45; +x_45 = l_Lean_Level_hasParam(x_1); +if (x_45 == 0) +{ +lean_object* x_46; +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_1); +lean_ctor_set(x_46, 1, x_3); +return x_46; +} +else +{ +lean_object* x_47; +x_47 = lean_box(0); +x_4 = x_47; +goto block_43; +} +} +else +{ +lean_object* x_48; +x_48 = lean_box(0); +x_4 = x_48; +goto block_43; +} +block_43: +{ +lean_object* x_5; lean_object* x_6; +lean_dec(x_4); +x_5 = lean_ctor_get(x_3, 2); +lean_inc(x_5); +x_6 = l_HashMapImp_find_x3f___at_Lean_Closure_visitLevel___spec__1(x_5, x_1); +lean_dec(x_5); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; uint8_t x_8; +lean_inc(x_1); +x_7 = l_Lean_Closure_collectLevelAux___main(x_1, x_2, x_3); +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_7, 1); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_7, 0); +x_12 = lean_ctor_get(x_9, 2); +lean_inc(x_11); +x_13 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_12, x_1, x_11); +lean_ctor_set(x_9, 2, x_13); +return x_7; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_14 = lean_ctor_get(x_7, 0); +x_15 = lean_ctor_get(x_9, 0); +x_16 = lean_ctor_get(x_9, 1); +x_17 = lean_ctor_get(x_9, 2); +x_18 = lean_ctor_get(x_9, 3); +x_19 = lean_ctor_get(x_9, 4); +x_20 = lean_ctor_get(x_9, 5); +x_21 = lean_ctor_get(x_9, 6); +x_22 = lean_ctor_get(x_9, 7); +x_23 = lean_ctor_get(x_9, 8); +lean_inc(x_23); +lean_inc(x_22); +lean_inc(x_21); +lean_inc(x_20); +lean_inc(x_19); +lean_inc(x_18); +lean_inc(x_17); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_9); +lean_inc(x_14); +x_24 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_17, x_1, x_14); +x_25 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_25, 0, x_15); +lean_ctor_set(x_25, 1, x_16); +lean_ctor_set(x_25, 2, x_24); +lean_ctor_set(x_25, 3, x_18); +lean_ctor_set(x_25, 4, x_19); +lean_ctor_set(x_25, 5, x_20); +lean_ctor_set(x_25, 6, x_21); +lean_ctor_set(x_25, 7, x_22); +lean_ctor_set(x_25, 8, x_23); +lean_ctor_set(x_7, 1, x_25); +return x_7; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_26 = lean_ctor_get(x_7, 1); +x_27 = lean_ctor_get(x_7, 0); +lean_inc(x_26); +lean_inc(x_27); +lean_dec(x_7); +x_28 = lean_ctor_get(x_26, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_26, 1); +lean_inc(x_29); +x_30 = lean_ctor_get(x_26, 2); +lean_inc(x_30); +x_31 = lean_ctor_get(x_26, 3); +lean_inc(x_31); +x_32 = lean_ctor_get(x_26, 4); +lean_inc(x_32); +x_33 = lean_ctor_get(x_26, 5); +lean_inc(x_33); +x_34 = lean_ctor_get(x_26, 6); +lean_inc(x_34); +x_35 = lean_ctor_get(x_26, 7); +lean_inc(x_35); +x_36 = lean_ctor_get(x_26, 8); +lean_inc(x_36); +if (lean_is_exclusive(x_26)) { + lean_ctor_release(x_26, 0); + lean_ctor_release(x_26, 1); + lean_ctor_release(x_26, 2); + lean_ctor_release(x_26, 3); + lean_ctor_release(x_26, 4); + lean_ctor_release(x_26, 5); + lean_ctor_release(x_26, 6); + lean_ctor_release(x_26, 7); + lean_ctor_release(x_26, 8); + x_37 = x_26; +} else { + lean_dec_ref(x_26); + x_37 = lean_box(0); +} +lean_inc(x_27); +x_38 = l_HashMapImp_insert___at_Lean_Closure_visitLevel___spec__3(x_30, x_1, x_27); +if (lean_is_scalar(x_37)) { + x_39 = lean_alloc_ctor(0, 9, 0); +} else { + x_39 = x_37; +} +lean_ctor_set(x_39, 0, x_28); +lean_ctor_set(x_39, 1, x_29); +lean_ctor_set(x_39, 2, x_38); +lean_ctor_set(x_39, 3, x_31); +lean_ctor_set(x_39, 4, x_32); +lean_ctor_set(x_39, 5, x_33); +lean_ctor_set(x_39, 6, x_34); +lean_ctor_set(x_39, 7, x_35); +lean_ctor_set(x_39, 8, x_36); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_27); +lean_ctor_set(x_40, 1, x_39); +return x_40; +} +} +else +{ +lean_object* x_41; lean_object* x_42; +lean_dec(x_1); +x_41 = lean_ctor_get(x_6, 0); +lean_inc(x_41); +lean_dec(x_6); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_3); +return x_42; +} +} +} +} +lean_object* l_Lean_Closure_collectLevel___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Closure_collectLevel(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +lean_object* l_Lean_Closure_mkFreshFVarId___rarg(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_ctor_get(x_1, 1); +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_ctor_get(x_3, 1); +lean_inc(x_6); +lean_inc(x_5); +x_7 = lean_name_mk_numeral(x_5, x_6); +x_8 = lean_unsigned_to_nat(1u); +x_9 = lean_nat_add(x_6, x_8); +lean_dec(x_6); +lean_ctor_set(x_3, 1, x_9); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_7); +lean_ctor_set(x_10, 1, x_1); +return x_10; +} +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; +x_11 = lean_ctor_get(x_3, 0); +x_12 = lean_ctor_get(x_3, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_3); +lean_inc(x_12); +lean_inc(x_11); +x_13 = lean_name_mk_numeral(x_11, x_12); +x_14 = lean_unsigned_to_nat(1u); +x_15 = lean_nat_add(x_12, x_14); +lean_dec(x_12); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_11); +lean_ctor_set(x_16, 1, x_15); +lean_ctor_set(x_1, 1, x_16); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_13); +lean_ctor_set(x_17, 1, x_1); +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; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_18 = lean_ctor_get(x_1, 1); +x_19 = lean_ctor_get(x_1, 0); +x_20 = lean_ctor_get(x_1, 2); +x_21 = lean_ctor_get(x_1, 3); +x_22 = lean_ctor_get(x_1, 4); +x_23 = lean_ctor_get(x_1, 5); +x_24 = lean_ctor_get(x_1, 6); +x_25 = lean_ctor_get(x_1, 7); +x_26 = lean_ctor_get(x_1, 8); +lean_inc(x_26); +lean_inc(x_25); +lean_inc(x_24); +lean_inc(x_23); +lean_inc(x_22); +lean_inc(x_21); +lean_inc(x_20); +lean_inc(x_18); +lean_inc(x_19); +lean_dec(x_1); +x_27 = lean_ctor_get(x_18, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_18, 1); +lean_inc(x_28); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + lean_ctor_release(x_18, 1); + x_29 = x_18; +} else { + lean_dec_ref(x_18); + x_29 = lean_box(0); +} +lean_inc(x_28); +lean_inc(x_27); +x_30 = lean_name_mk_numeral(x_27, x_28); +x_31 = lean_unsigned_to_nat(1u); +x_32 = lean_nat_add(x_28, x_31); +lean_dec(x_28); +if (lean_is_scalar(x_29)) { + x_33 = lean_alloc_ctor(0, 2, 0); +} else { + x_33 = x_29; +} +lean_ctor_set(x_33, 0, x_27); +lean_ctor_set(x_33, 1, x_32); +x_34 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_34, 0, x_19); +lean_ctor_set(x_34, 1, x_33); +lean_ctor_set(x_34, 2, x_20); +lean_ctor_set(x_34, 3, x_21); +lean_ctor_set(x_34, 4, x_22); +lean_ctor_set(x_34, 5, x_23); +lean_ctor_set(x_34, 6, x_24); +lean_ctor_set(x_34, 7, x_25); +lean_ctor_set(x_34, 8, x_26); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_30); +lean_ctor_set(x_35, 1, x_34); +return x_35; +} +} +} +lean_object* l_Lean_Closure_mkFreshFVarId(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Closure_mkFreshFVarId___rarg), 1, 0); +return x_2; +} +} +lean_object* l_Lean_Closure_mkFreshFVarId___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_Closure_mkFreshFVarId(x_1); +lean_dec(x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Closure_mkNextUserName___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("_x"); +return x_1; +} +} +lean_object* _init_l_Lean_Closure_mkNextUserName___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Closure_mkNextUserName___rarg___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* l_Lean_Closure_mkNextUserName___rarg(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_3 = lean_ctor_get(x_1, 7); +x_4 = l_Lean_Closure_mkNextUserName___rarg___closed__2; +lean_inc(x_3); +x_5 = l_Lean_Name_appendIndexAfter(x_4, x_3); +x_6 = lean_unsigned_to_nat(1u); +x_7 = lean_nat_add(x_3, x_6); +lean_dec(x_3); +lean_ctor_set(x_1, 7, x_7); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_5); +lean_ctor_set(x_8, 1, x_1); +return x_8; +} +else +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 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; +x_9 = lean_ctor_get(x_1, 0); +x_10 = lean_ctor_get(x_1, 1); +x_11 = lean_ctor_get(x_1, 2); +x_12 = lean_ctor_get(x_1, 3); +x_13 = lean_ctor_get(x_1, 4); +x_14 = lean_ctor_get(x_1, 5); +x_15 = lean_ctor_get(x_1, 6); +x_16 = lean_ctor_get(x_1, 7); +x_17 = lean_ctor_get(x_1, 8); +lean_inc(x_17); +lean_inc(x_16); +lean_inc(x_15); +lean_inc(x_14); +lean_inc(x_13); +lean_inc(x_12); +lean_inc(x_11); +lean_inc(x_10); +lean_inc(x_9); +lean_dec(x_1); +x_18 = l_Lean_Closure_mkNextUserName___rarg___closed__2; +lean_inc(x_16); +x_19 = l_Lean_Name_appendIndexAfter(x_18, x_16); +x_20 = lean_unsigned_to_nat(1u); +x_21 = lean_nat_add(x_16, x_20); +lean_dec(x_16); +x_22 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_22, 0, x_9); +lean_ctor_set(x_22, 1, x_10); +lean_ctor_set(x_22, 2, x_11); +lean_ctor_set(x_22, 3, x_12); +lean_ctor_set(x_22, 4, x_13); +lean_ctor_set(x_22, 5, x_14); +lean_ctor_set(x_22, 6, x_15); +lean_ctor_set(x_22, 7, x_21); +lean_ctor_set(x_22, 8, x_17); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_19); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +lean_object* l_Lean_Closure_mkNextUserName(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Closure_mkNextUserName___rarg), 1, 0); +return x_2; +} +} +lean_object* l_Lean_Closure_mkNextUserName___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_Closure_mkNextUserName(x_1); +lean_dec(x_1); +return x_2; +} +} +lean_object* l_Lean_Closure_getUserName(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_4; +x_4 = l_Lean_Closure_mkNextUserName___rarg(x_3); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_1, 0); +lean_inc(x_5); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_3); +return x_6; +} +} +} +lean_object* l_Lean_Closure_getUserName___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Closure_getUserName(x_1, x_2, x_3); +lean_dec(x_2); +lean_dec(x_1); +return x_4; +} +} +lean_object* l_Lean_Closure_mkLocalDecl(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; +x_5 = l_Lean_Closure_getUserName(x_1, x_3, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +lean_dec(x_5); +x_8 = l_Lean_Closure_mkFreshFVarId___rarg(x_7); +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; uint8_t x_11; +x_10 = lean_ctor_get(x_8, 1); +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_8, 0); +x_13 = lean_ctor_get(x_10, 0); +x_14 = 0; +lean_inc(x_12); +x_15 = lean_local_ctx_mk_local_decl(x_13, x_12, x_6, x_2, x_14); +lean_ctor_set(x_10, 0, x_15); +x_16 = l_Lean_mkFVar(x_12); +lean_ctor_set(x_8, 0, 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; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_17 = lean_ctor_get(x_8, 0); +x_18 = lean_ctor_get(x_10, 0); +x_19 = lean_ctor_get(x_10, 1); +x_20 = lean_ctor_get(x_10, 2); +x_21 = lean_ctor_get(x_10, 3); +x_22 = lean_ctor_get(x_10, 4); +x_23 = lean_ctor_get(x_10, 5); +x_24 = lean_ctor_get(x_10, 6); +x_25 = lean_ctor_get(x_10, 7); +x_26 = lean_ctor_get(x_10, 8); +lean_inc(x_26); +lean_inc(x_25); +lean_inc(x_24); +lean_inc(x_23); +lean_inc(x_22); +lean_inc(x_21); +lean_inc(x_20); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_10); +x_27 = 0; +lean_inc(x_17); +x_28 = lean_local_ctx_mk_local_decl(x_18, x_17, x_6, x_2, x_27); +x_29 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_19); +lean_ctor_set(x_29, 2, x_20); +lean_ctor_set(x_29, 3, x_21); +lean_ctor_set(x_29, 4, x_22); +lean_ctor_set(x_29, 5, x_23); +lean_ctor_set(x_29, 6, x_24); +lean_ctor_set(x_29, 7, x_25); +lean_ctor_set(x_29, 8, x_26); +x_30 = l_Lean_mkFVar(x_17); +lean_ctor_set(x_8, 1, x_29); +lean_ctor_set(x_8, 0, x_30); +return x_8; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_31 = lean_ctor_get(x_8, 1); +x_32 = lean_ctor_get(x_8, 0); +lean_inc(x_31); +lean_inc(x_32); +lean_dec(x_8); +x_33 = lean_ctor_get(x_31, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_31, 1); +lean_inc(x_34); +x_35 = lean_ctor_get(x_31, 2); +lean_inc(x_35); +x_36 = lean_ctor_get(x_31, 3); +lean_inc(x_36); +x_37 = lean_ctor_get(x_31, 4); +lean_inc(x_37); +x_38 = lean_ctor_get(x_31, 5); +lean_inc(x_38); +x_39 = lean_ctor_get(x_31, 6); +lean_inc(x_39); +x_40 = lean_ctor_get(x_31, 7); +lean_inc(x_40); +x_41 = lean_ctor_get(x_31, 8); +lean_inc(x_41); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + lean_ctor_release(x_31, 2); + lean_ctor_release(x_31, 3); + lean_ctor_release(x_31, 4); + lean_ctor_release(x_31, 5); + lean_ctor_release(x_31, 6); + lean_ctor_release(x_31, 7); + lean_ctor_release(x_31, 8); + x_42 = x_31; +} else { + lean_dec_ref(x_31); + x_42 = lean_box(0); +} +x_43 = 0; +lean_inc(x_32); +x_44 = lean_local_ctx_mk_local_decl(x_33, x_32, x_6, x_2, x_43); +if (lean_is_scalar(x_42)) { + x_45 = lean_alloc_ctor(0, 9, 0); +} else { + x_45 = x_42; +} +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_34); +lean_ctor_set(x_45, 2, x_35); +lean_ctor_set(x_45, 3, x_36); +lean_ctor_set(x_45, 4, x_37); +lean_ctor_set(x_45, 5, x_38); +lean_ctor_set(x_45, 6, x_39); +lean_ctor_set(x_45, 7, x_40); +lean_ctor_set(x_45, 8, x_41); +x_46 = l_Lean_mkFVar(x_32); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_45); +return x_47; +} +} +} +lean_object* l_Lean_Closure_mkLocalDecl___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_Closure_mkLocalDecl(x_1, x_2, x_3, x_4); +lean_dec(x_3); +lean_dec(x_1); +return x_5; +} +} +lean_object* l_Lean_Closure_mkLetDecl(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; uint8_t x_7; +x_6 = l_Lean_Closure_mkFreshFVarId___rarg(x_5); +x_7 = !lean_is_exclusive(x_6); +if (x_7 == 0) +{ +lean_object* x_8; uint8_t x_9; +x_8 = lean_ctor_get(x_6, 1); +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_10 = lean_ctor_get(x_6, 0); +x_11 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +x_12 = lean_local_ctx_mk_let_decl(x_11, x_10, x_1, x_2, x_3); +lean_ctor_set(x_8, 0, x_12); +x_13 = l_Lean_mkFVar(x_10); +lean_ctor_set(x_6, 0, x_13); +return x_6; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_14 = lean_ctor_get(x_6, 0); +x_15 = lean_ctor_get(x_8, 0); +x_16 = lean_ctor_get(x_8, 1); +x_17 = lean_ctor_get(x_8, 2); +x_18 = lean_ctor_get(x_8, 3); +x_19 = lean_ctor_get(x_8, 4); +x_20 = lean_ctor_get(x_8, 5); +x_21 = lean_ctor_get(x_8, 6); +x_22 = lean_ctor_get(x_8, 7); +x_23 = lean_ctor_get(x_8, 8); +lean_inc(x_23); +lean_inc(x_22); +lean_inc(x_21); +lean_inc(x_20); +lean_inc(x_19); +lean_inc(x_18); +lean_inc(x_17); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_8); +lean_inc(x_14); +x_24 = lean_local_ctx_mk_let_decl(x_15, x_14, x_1, x_2, x_3); +x_25 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_16); +lean_ctor_set(x_25, 2, x_17); +lean_ctor_set(x_25, 3, x_18); +lean_ctor_set(x_25, 4, x_19); +lean_ctor_set(x_25, 5, x_20); +lean_ctor_set(x_25, 6, x_21); +lean_ctor_set(x_25, 7, x_22); +lean_ctor_set(x_25, 8, x_23); +x_26 = l_Lean_mkFVar(x_14); +lean_ctor_set(x_6, 1, x_25); +lean_ctor_set(x_6, 0, x_26); +return x_6; +} +} +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; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_27 = lean_ctor_get(x_6, 1); +x_28 = lean_ctor_get(x_6, 0); +lean_inc(x_27); +lean_inc(x_28); +lean_dec(x_6); +x_29 = lean_ctor_get(x_27, 0); +lean_inc(x_29); +x_30 = lean_ctor_get(x_27, 1); +lean_inc(x_30); +x_31 = lean_ctor_get(x_27, 2); +lean_inc(x_31); +x_32 = lean_ctor_get(x_27, 3); +lean_inc(x_32); +x_33 = lean_ctor_get(x_27, 4); +lean_inc(x_33); +x_34 = lean_ctor_get(x_27, 5); +lean_inc(x_34); +x_35 = lean_ctor_get(x_27, 6); +lean_inc(x_35); +x_36 = lean_ctor_get(x_27, 7); +lean_inc(x_36); +x_37 = lean_ctor_get(x_27, 8); +lean_inc(x_37); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + lean_ctor_release(x_27, 2); + lean_ctor_release(x_27, 3); + lean_ctor_release(x_27, 4); + lean_ctor_release(x_27, 5); + lean_ctor_release(x_27, 6); + lean_ctor_release(x_27, 7); + lean_ctor_release(x_27, 8); + x_38 = x_27; +} else { + lean_dec_ref(x_27); + x_38 = lean_box(0); +} +lean_inc(x_28); +x_39 = lean_local_ctx_mk_let_decl(x_29, x_28, x_1, x_2, x_3); +if (lean_is_scalar(x_38)) { + x_40 = lean_alloc_ctor(0, 9, 0); +} else { + x_40 = x_38; +} +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_30); +lean_ctor_set(x_40, 2, x_31); +lean_ctor_set(x_40, 3, x_32); +lean_ctor_set(x_40, 4, x_33); +lean_ctor_set(x_40, 5, x_34); +lean_ctor_set(x_40, 6, x_35); +lean_ctor_set(x_40, 7, x_36); +lean_ctor_set(x_40, 8, x_37); +x_41 = l_Lean_mkFVar(x_28); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_40); +return x_42; +} +} +} +lean_object* l_Lean_Closure_mkLetDecl___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lean_Closure_mkLetDecl(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_4); +return x_6; +} +} +lean_object* l_AssocList_find_x3f___main___at_Lean_Closure_visitExpr___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; +x_3 = lean_box(0); +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_ctor_get(x_2, 2); +x_7 = lean_expr_equal(x_4, x_1); +if (x_7 == 0) +{ +x_2 = x_6; +goto _start; +} +else +{ +lean_object* x_9; +lean_inc(x_5); +x_9 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_9, 0, x_5); +return x_9; +} +} +} +} +lean_object* l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_8; +x_3 = lean_ctor_get(x_1, 1); +x_4 = lean_array_get_size(x_3); +x_5 = l_Lean_Expr_hash(x_2); +x_6 = lean_usize_modn(x_5, x_4); +lean_dec(x_4); +x_7 = lean_array_uget(x_3, x_6); +x_8 = l_AssocList_find_x3f___main___at_Lean_Closure_visitExpr___spec__2(x_2, x_7); +lean_dec(x_7); +return x_8; +} +} +uint8_t l_AssocList_contains___main___at_Lean_Closure_visitExpr___spec__4(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = 0; +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 2); +x_6 = lean_expr_equal(x_4, x_1); +if (x_6 == 0) +{ +x_2 = x_5; +goto _start; +} +else +{ +uint8_t x_8; +x_8 = 1; +return x_8; +} +} +} +} +lean_object* l_AssocList_foldlM___main___at_Lean_Closure_visitExpr___spec__7(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +return x_1; +} +else +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; size_t x_7; size_t x_8; lean_object* x_9; lean_object* x_10; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 2); +x_6 = lean_array_get_size(x_1); +x_7 = l_Lean_Expr_hash(x_4); +x_8 = lean_usize_modn(x_7, x_6); +lean_dec(x_6); +x_9 = lean_array_uget(x_1, x_8); +lean_ctor_set(x_2, 2, x_9); +x_10 = lean_array_uset(x_1, x_8, x_2); +x_1 = x_10; +x_2 = x_5; +goto _start; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; size_t x_16; size_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_12 = lean_ctor_get(x_2, 0); +x_13 = lean_ctor_get(x_2, 1); +x_14 = lean_ctor_get(x_2, 2); +lean_inc(x_14); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_2); +x_15 = lean_array_get_size(x_1); +x_16 = l_Lean_Expr_hash(x_12); +x_17 = lean_usize_modn(x_16, x_15); +lean_dec(x_15); +x_18 = lean_array_uget(x_1, x_17); +x_19 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_13); +lean_ctor_set(x_19, 2, x_18); +x_20 = lean_array_uset(x_1, x_17, x_19); +x_1 = x_20; +x_2 = x_14; +goto _start; +} +} +} +} +lean_object* l_HashMapImp_moveEntries___main___at_Lean_Closure_visitExpr___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_array_get_size(x_2); +x_5 = lean_nat_dec_lt(x_1, x_4); +lean_dec(x_4); +if (x_5 == 0) +{ +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_6 = lean_array_fget(x_2, x_1); +x_7 = lean_box(0); +x_8 = lean_array_fset(x_2, x_1, x_7); +x_9 = l_AssocList_foldlM___main___at_Lean_Closure_visitExpr___spec__7(x_3, x_6); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_8; +x_3 = x_9; +goto _start; +} +} +} +lean_object* l_HashMapImp_expand___at_Lean_Closure_visitExpr___spec__5(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; +x_3 = lean_array_get_size(x_2); +x_4 = lean_unsigned_to_nat(2u); +x_5 = lean_nat_mul(x_3, x_4); +lean_dec(x_3); +x_6 = lean_box(0); +x_7 = lean_mk_array(x_5, x_6); +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_HashMapImp_moveEntries___main___at_Lean_Closure_visitExpr___spec__6(x_8, x_2, x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +return x_10; +} +} +lean_object* l_AssocList_replace___main___at_Lean_Closure_visitExpr___spec__8(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +else +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +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_ctor_get(x_3, 1); +x_7 = lean_ctor_get(x_3, 2); +x_8 = lean_expr_equal(x_5, x_1); +if (x_8 == 0) +{ +lean_object* x_9; +x_9 = l_AssocList_replace___main___at_Lean_Closure_visitExpr___spec__8(x_1, x_2, x_7); +lean_ctor_set(x_3, 2, x_9); +return x_3; +} +else +{ +lean_dec(x_6); +lean_dec(x_5); +lean_ctor_set(x_3, 1, x_2); +lean_ctor_set(x_3, 0, x_1); +return x_3; +} +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_10 = lean_ctor_get(x_3, 0); +x_11 = lean_ctor_get(x_3, 1); +x_12 = lean_ctor_get(x_3, 2); +lean_inc(x_12); +lean_inc(x_11); +lean_inc(x_10); +lean_dec(x_3); +x_13 = lean_expr_equal(x_10, x_1); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; +x_14 = l_AssocList_replace___main___at_Lean_Closure_visitExpr___spec__8(x_1, x_2, x_12); +x_15 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_15, 0, x_10); +lean_ctor_set(x_15, 1, x_11); +lean_ctor_set(x_15, 2, x_14); +return x_15; +} +else +{ +lean_object* x_16; +lean_dec(x_11); +lean_dec(x_10); +x_16 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_16, 0, x_1); +lean_ctor_set(x_16, 1, x_2); +lean_ctor_set(x_16, 2, x_12); +return x_16; +} +} +} +} +} +lean_object* l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_1); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; size_t x_8; size_t x_9; lean_object* x_10; uint8_t x_11; +x_5 = lean_ctor_get(x_1, 0); +x_6 = lean_ctor_get(x_1, 1); +x_7 = lean_array_get_size(x_6); +x_8 = l_Lean_Expr_hash(x_2); +x_9 = lean_usize_modn(x_8, x_7); +x_10 = lean_array_uget(x_6, x_9); +x_11 = l_AssocList_contains___main___at_Lean_Closure_visitExpr___spec__4(x_2, x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_12 = lean_unsigned_to_nat(1u); +x_13 = lean_nat_add(x_5, x_12); +lean_dec(x_5); +x_14 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_14, 0, x_2); +lean_ctor_set(x_14, 1, x_3); +lean_ctor_set(x_14, 2, x_10); +x_15 = lean_array_uset(x_6, x_9, x_14); +x_16 = lean_nat_dec_le(x_13, x_7); +lean_dec(x_7); +if (x_16 == 0) +{ +lean_object* x_17; +lean_free_object(x_1); +x_17 = l_HashMapImp_expand___at_Lean_Closure_visitExpr___spec__5(x_13, x_15); +return x_17; +} +else +{ +lean_ctor_set(x_1, 1, x_15); +lean_ctor_set(x_1, 0, x_13); +return x_1; +} +} +else +{ +lean_object* x_18; lean_object* x_19; +lean_dec(x_7); +x_18 = l_AssocList_replace___main___at_Lean_Closure_visitExpr___spec__8(x_2, x_3, x_10); +x_19 = lean_array_uset(x_6, x_9, x_18); +lean_ctor_set(x_1, 1, x_19); +return x_1; +} +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; size_t x_23; size_t x_24; lean_object* x_25; uint8_t x_26; +x_20 = lean_ctor_get(x_1, 0); +x_21 = lean_ctor_get(x_1, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_1); +x_22 = lean_array_get_size(x_21); +x_23 = l_Lean_Expr_hash(x_2); +x_24 = lean_usize_modn(x_23, x_22); +x_25 = lean_array_uget(x_21, x_24); +x_26 = l_AssocList_contains___main___at_Lean_Closure_visitExpr___spec__4(x_2, x_25); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_27 = lean_unsigned_to_nat(1u); +x_28 = lean_nat_add(x_20, x_27); +lean_dec(x_20); +x_29 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_29, 0, x_2); +lean_ctor_set(x_29, 1, x_3); +lean_ctor_set(x_29, 2, x_25); +x_30 = lean_array_uset(x_21, x_24, x_29); +x_31 = lean_nat_dec_le(x_28, x_22); +lean_dec(x_22); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = l_HashMapImp_expand___at_Lean_Closure_visitExpr___spec__5(x_28, x_30); +return x_32; +} +else +{ +lean_object* x_33; +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_28); +lean_ctor_set(x_33, 1, x_30); +return x_33; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +lean_dec(x_22); +x_34 = l_AssocList_replace___main___at_Lean_Closure_visitExpr___spec__8(x_2, x_3, x_25); +x_35 = lean_array_uset(x_21, x_24, x_34); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_20); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +} +} +lean_object* l_Lean_Closure_visitExpr(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; uint8_t x_49; +x_49 = l_Lean_Expr_hasLevelParam(x_2); +if (x_49 == 0) +{ +uint8_t x_50; +x_50 = l_Lean_Expr_hasFVar(x_2); +if (x_50 == 0) +{ +uint8_t x_51; +x_51 = l_Lean_Expr_hasMVar(x_2); +if (x_51 == 0) +{ +lean_object* x_52; +lean_dec(x_3); +lean_dec(x_1); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_2); +lean_ctor_set(x_52, 1, x_4); +return x_52; +} +else +{ +lean_object* x_53; +x_53 = lean_box(0); +x_5 = x_53; +goto block_48; +} +} +else +{ +lean_object* x_54; +x_54 = lean_box(0); +x_5 = x_54; +goto block_48; +} +} +else +{ +lean_object* x_55; +x_55 = lean_box(0); +x_5 = x_55; +goto block_48; +} +block_48: +{ +lean_object* x_6; lean_object* x_7; +lean_dec(x_5); +x_6 = lean_ctor_get(x_4, 3); +lean_inc(x_6); +x_7 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_6, x_2); +lean_dec(x_6); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; +lean_inc(x_2); +x_8 = lean_apply_3(x_1, x_2, x_3, x_4); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; uint8_t x_11; +x_10 = lean_ctor_get(x_8, 1); +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_8, 0); +x_13 = lean_ctor_get(x_10, 3); +lean_inc(x_12); +x_14 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_13, x_2, x_12); +lean_ctor_set(x_10, 3, 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; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_15 = lean_ctor_get(x_8, 0); +x_16 = lean_ctor_get(x_10, 0); +x_17 = lean_ctor_get(x_10, 1); +x_18 = lean_ctor_get(x_10, 2); +x_19 = lean_ctor_get(x_10, 3); +x_20 = lean_ctor_get(x_10, 4); +x_21 = lean_ctor_get(x_10, 5); +x_22 = lean_ctor_get(x_10, 6); +x_23 = lean_ctor_get(x_10, 7); +x_24 = lean_ctor_get(x_10, 8); +lean_inc(x_24); +lean_inc(x_23); +lean_inc(x_22); +lean_inc(x_21); +lean_inc(x_20); +lean_inc(x_19); +lean_inc(x_18); +lean_inc(x_17); +lean_inc(x_16); +lean_dec(x_10); +lean_inc(x_15); +x_25 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_19, x_2, x_15); +x_26 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_26, 0, x_16); +lean_ctor_set(x_26, 1, x_17); +lean_ctor_set(x_26, 2, x_18); +lean_ctor_set(x_26, 3, x_25); +lean_ctor_set(x_26, 4, x_20); +lean_ctor_set(x_26, 5, x_21); +lean_ctor_set(x_26, 6, x_22); +lean_ctor_set(x_26, 7, x_23); +lean_ctor_set(x_26, 8, x_24); +lean_ctor_set(x_8, 1, x_26); +return x_8; +} +} +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; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_27 = lean_ctor_get(x_8, 1); +x_28 = lean_ctor_get(x_8, 0); +lean_inc(x_27); +lean_inc(x_28); +lean_dec(x_8); +x_29 = lean_ctor_get(x_27, 0); +lean_inc(x_29); +x_30 = lean_ctor_get(x_27, 1); +lean_inc(x_30); +x_31 = lean_ctor_get(x_27, 2); +lean_inc(x_31); +x_32 = lean_ctor_get(x_27, 3); +lean_inc(x_32); +x_33 = lean_ctor_get(x_27, 4); +lean_inc(x_33); +x_34 = lean_ctor_get(x_27, 5); +lean_inc(x_34); +x_35 = lean_ctor_get(x_27, 6); +lean_inc(x_35); +x_36 = lean_ctor_get(x_27, 7); +lean_inc(x_36); +x_37 = lean_ctor_get(x_27, 8); +lean_inc(x_37); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + lean_ctor_release(x_27, 2); + lean_ctor_release(x_27, 3); + lean_ctor_release(x_27, 4); + lean_ctor_release(x_27, 5); + lean_ctor_release(x_27, 6); + lean_ctor_release(x_27, 7); + lean_ctor_release(x_27, 8); + x_38 = x_27; +} else { + lean_dec_ref(x_27); + x_38 = lean_box(0); +} +lean_inc(x_28); +x_39 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_32, x_2, x_28); +if (lean_is_scalar(x_38)) { + x_40 = lean_alloc_ctor(0, 9, 0); +} else { + x_40 = x_38; +} +lean_ctor_set(x_40, 0, x_29); +lean_ctor_set(x_40, 1, x_30); +lean_ctor_set(x_40, 2, x_31); +lean_ctor_set(x_40, 3, x_39); +lean_ctor_set(x_40, 4, x_33); +lean_ctor_set(x_40, 5, x_34); +lean_ctor_set(x_40, 6, x_35); +lean_ctor_set(x_40, 7, x_36); +lean_ctor_set(x_40, 8, x_37); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_28); +lean_ctor_set(x_41, 1, x_40); +return x_41; +} +} +else +{ +uint8_t x_42; +lean_dec(x_2); +x_42 = !lean_is_exclusive(x_8); +if (x_42 == 0) +{ +return x_8; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_8, 0); +x_44 = lean_ctor_get(x_8, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_8); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +return x_45; +} +} +} +else +{ +lean_object* x_46; lean_object* x_47; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_46 = lean_ctor_get(x_7, 0); +lean_inc(x_46); +lean_dec(x_7); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_4); +return x_47; +} +} +} +} +lean_object* l_AssocList_find_x3f___main___at_Lean_Closure_visitExpr___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_AssocList_find_x3f___main___at_Lean_Closure_visitExpr___spec__2(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +lean_object* l_AssocList_contains___main___at_Lean_Closure_visitExpr___spec__4___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_AssocList_contains___main___at_Lean_Closure_visitExpr___spec__4(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +lean_object* l_List_mapM___main___at_Lean_Closure_collectExprAux___main___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_box(0); +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_4); +lean_ctor_set(x_5, 1, x_3); +return x_5; +} +else +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_1); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_7 = lean_ctor_get(x_1, 0); +x_8 = lean_ctor_get(x_1, 1); +x_9 = l_Lean_Closure_collectLevel(x_7, x_2, x_3); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = l_List_mapM___main___at_Lean_Closure_collectExprAux___main___spec__1(x_8, x_2, x_11); +x_13 = !lean_is_exclusive(x_12); +if (x_13 == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_ctor_set(x_1, 1, x_14); +lean_ctor_set(x_1, 0, x_10); +lean_ctor_set(x_12, 0, x_1); +return x_12; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_12, 0); +x_16 = lean_ctor_get(x_12, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_12); +lean_ctor_set(x_1, 1, x_15); +lean_ctor_set(x_1, 0, x_10); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_1); +lean_ctor_set(x_17, 1, 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; lean_object* x_28; +x_18 = lean_ctor_get(x_1, 0); +x_19 = lean_ctor_get(x_1, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_1); +x_20 = l_Lean_Closure_collectLevel(x_18, x_2, x_3); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +x_22 = lean_ctor_get(x_20, 1); +lean_inc(x_22); +lean_dec(x_20); +x_23 = l_List_mapM___main___at_Lean_Closure_collectExprAux___main___spec__1(x_19, x_2, x_22); +x_24 = lean_ctor_get(x_23, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_23, 1); +lean_inc(x_25); +if (lean_is_exclusive(x_23)) { + lean_ctor_release(x_23, 0); + lean_ctor_release(x_23, 1); + x_26 = x_23; +} else { + lean_dec_ref(x_23); + x_26 = lean_box(0); +} +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_21); +lean_ctor_set(x_27, 1, x_24); +if (lean_is_scalar(x_26)) { + x_28 = lean_alloc_ctor(0, 2, 0); +} else { + x_28 = x_26; +} +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_25); +return x_28; +} +} +} +} +lean_object* l_Lean_Closure_collectExprAux___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_13; lean_object* x_14; +switch (lean_obj_tag(x_1)) { +case 1: +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_1, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_2, 1); +lean_inc(x_23); +x_24 = lean_local_ctx_find(x_23, x_22); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; lean_object* x_26; +lean_dec(x_2); +lean_dec(x_1); +x_25 = l_Lean_LocalContext_get_x21___closed__1; +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_3); +return x_26; +} +else +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_24, 0); +lean_inc(x_27); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + x_28 = x_24; +} else { + lean_dec_ref(x_24); + x_28 = lean_box(0); +} +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_67; uint8_t x_93; +x_29 = lean_ctor_get(x_27, 2); +lean_inc(x_29); +x_30 = lean_ctor_get(x_27, 3); +lean_inc(x_30); +lean_dec(x_27); +x_93 = l_Lean_Expr_hasLevelParam(x_30); +if (x_93 == 0) +{ +uint8_t x_94; +x_94 = l_Lean_Expr_hasFVar(x_30); +if (x_94 == 0) +{ +uint8_t x_95; +x_95 = l_Lean_Expr_hasMVar(x_30); +if (x_95 == 0) +{ +x_31 = x_30; +x_32 = x_3; +goto block_66; +} +else +{ +lean_object* x_96; +x_96 = lean_box(0); +x_67 = x_96; +goto block_92; +} +} +else +{ +lean_object* x_97; +x_97 = lean_box(0); +x_67 = x_97; +goto block_92; +} +} +else +{ +lean_object* x_98; +x_98 = lean_box(0); +x_67 = x_98; +goto block_92; +} +block_66: +{ +lean_object* x_33; lean_object* x_34; uint8_t x_35; +if (lean_is_scalar(x_28)) { + x_33 = lean_alloc_ctor(1, 1, 0); +} else { + x_33 = x_28; +} +lean_ctor_set(x_33, 0, x_29); +x_34 = l_Lean_Closure_mkLocalDecl(x_33, x_31, x_2, x_32); +lean_dec(x_2); +lean_dec(x_33); +x_35 = !lean_is_exclusive(x_34); +if (x_35 == 0) +{ +lean_object* x_36; uint8_t x_37; +x_36 = lean_ctor_get(x_34, 1); +x_37 = !lean_is_exclusive(x_36); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; +x_38 = lean_ctor_get(x_36, 8); +x_39 = lean_array_push(x_38, x_1); +lean_ctor_set(x_36, 8, x_39); +return x_34; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_40 = lean_ctor_get(x_36, 0); +x_41 = lean_ctor_get(x_36, 1); +x_42 = lean_ctor_get(x_36, 2); +x_43 = lean_ctor_get(x_36, 3); +x_44 = lean_ctor_get(x_36, 4); +x_45 = lean_ctor_get(x_36, 5); +x_46 = lean_ctor_get(x_36, 6); +x_47 = lean_ctor_get(x_36, 7); +x_48 = lean_ctor_get(x_36, 8); +lean_inc(x_48); +lean_inc(x_47); +lean_inc(x_46); +lean_inc(x_45); +lean_inc(x_44); +lean_inc(x_43); +lean_inc(x_42); +lean_inc(x_41); +lean_inc(x_40); +lean_dec(x_36); +x_49 = lean_array_push(x_48, x_1); +x_50 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_50, 0, x_40); +lean_ctor_set(x_50, 1, x_41); +lean_ctor_set(x_50, 2, x_42); +lean_ctor_set(x_50, 3, x_43); +lean_ctor_set(x_50, 4, x_44); +lean_ctor_set(x_50, 5, x_45); +lean_ctor_set(x_50, 6, x_46); +lean_ctor_set(x_50, 7, x_47); +lean_ctor_set(x_50, 8, x_49); +lean_ctor_set(x_34, 1, x_50); +return x_34; +} +} +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_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; +x_51 = lean_ctor_get(x_34, 1); +x_52 = lean_ctor_get(x_34, 0); +lean_inc(x_51); +lean_inc(x_52); +lean_dec(x_34); +x_53 = lean_ctor_get(x_51, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_51, 1); +lean_inc(x_54); +x_55 = lean_ctor_get(x_51, 2); +lean_inc(x_55); +x_56 = lean_ctor_get(x_51, 3); +lean_inc(x_56); +x_57 = lean_ctor_get(x_51, 4); +lean_inc(x_57); +x_58 = lean_ctor_get(x_51, 5); +lean_inc(x_58); +x_59 = lean_ctor_get(x_51, 6); +lean_inc(x_59); +x_60 = lean_ctor_get(x_51, 7); +lean_inc(x_60); +x_61 = lean_ctor_get(x_51, 8); +lean_inc(x_61); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + lean_ctor_release(x_51, 2); + lean_ctor_release(x_51, 3); + lean_ctor_release(x_51, 4); + lean_ctor_release(x_51, 5); + lean_ctor_release(x_51, 6); + lean_ctor_release(x_51, 7); + lean_ctor_release(x_51, 8); + x_62 = x_51; +} else { + lean_dec_ref(x_51); + x_62 = lean_box(0); +} +x_63 = lean_array_push(x_61, x_1); +if (lean_is_scalar(x_62)) { + x_64 = lean_alloc_ctor(0, 9, 0); +} else { + x_64 = x_62; +} +lean_ctor_set(x_64, 0, x_53); +lean_ctor_set(x_64, 1, x_54); +lean_ctor_set(x_64, 2, x_55); +lean_ctor_set(x_64, 3, x_56); +lean_ctor_set(x_64, 4, x_57); +lean_ctor_set(x_64, 5, x_58); +lean_ctor_set(x_64, 6, x_59); +lean_ctor_set(x_64, 7, x_60); +lean_ctor_set(x_64, 8, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_52); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +block_92: +{ +lean_object* x_68; lean_object* x_69; +lean_dec(x_67); +x_68 = lean_ctor_get(x_3, 3); +lean_inc(x_68); +x_69 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_68, x_30); +lean_dec(x_68); +if (lean_obj_tag(x_69) == 0) +{ +lean_object* x_70; +lean_inc(x_2); +lean_inc(x_30); +x_70 = l_Lean_Closure_collectExprAux___main(x_30, x_2, x_3); +if (lean_obj_tag(x_70) == 0) +{ +lean_object* x_71; lean_object* x_72; uint8_t x_73; +x_71 = lean_ctor_get(x_70, 1); +lean_inc(x_71); +x_72 = lean_ctor_get(x_70, 0); +lean_inc(x_72); +lean_dec(x_70); +x_73 = !lean_is_exclusive(x_71); +if (x_73 == 0) +{ +lean_object* x_74; lean_object* x_75; +x_74 = lean_ctor_get(x_71, 3); +lean_inc(x_72); +x_75 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_74, x_30, x_72); +lean_ctor_set(x_71, 3, x_75); +x_31 = x_72; +x_32 = x_71; +goto block_66; +} +else +{ +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; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_76 = lean_ctor_get(x_71, 0); +x_77 = lean_ctor_get(x_71, 1); +x_78 = lean_ctor_get(x_71, 2); +x_79 = lean_ctor_get(x_71, 3); +x_80 = lean_ctor_get(x_71, 4); +x_81 = lean_ctor_get(x_71, 5); +x_82 = lean_ctor_get(x_71, 6); +x_83 = lean_ctor_get(x_71, 7); +x_84 = lean_ctor_get(x_71, 8); +lean_inc(x_84); +lean_inc(x_83); +lean_inc(x_82); +lean_inc(x_81); +lean_inc(x_80); +lean_inc(x_79); +lean_inc(x_78); +lean_inc(x_77); +lean_inc(x_76); +lean_dec(x_71); +lean_inc(x_72); +x_85 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_79, x_30, x_72); +x_86 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_86, 0, x_76); +lean_ctor_set(x_86, 1, x_77); +lean_ctor_set(x_86, 2, x_78); +lean_ctor_set(x_86, 3, x_85); +lean_ctor_set(x_86, 4, x_80); +lean_ctor_set(x_86, 5, x_81); +lean_ctor_set(x_86, 6, x_82); +lean_ctor_set(x_86, 7, x_83); +lean_ctor_set(x_86, 8, x_84); +x_31 = x_72; +x_32 = x_86; +goto block_66; +} +} +else +{ +uint8_t x_87; +lean_dec(x_30); +lean_dec(x_29); +lean_dec(x_28); +lean_dec(x_2); +lean_dec(x_1); +x_87 = !lean_is_exclusive(x_70); +if (x_87 == 0) +{ +return x_70; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_70, 0); +x_89 = lean_ctor_get(x_70, 1); +lean_inc(x_89); +lean_inc(x_88); +lean_dec(x_70); +x_90 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_90, 0, x_88); +lean_ctor_set(x_90, 1, x_89); +return x_90; +} +} +} +else +{ +lean_object* x_91; +lean_dec(x_30); +x_91 = lean_ctor_get(x_69, 0); +lean_inc(x_91); +lean_dec(x_69); +x_31 = x_91; +x_32 = x_3; +goto block_66; +} +} +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_141; uint8_t x_167; +lean_dec(x_28); +lean_dec(x_1); +x_99 = lean_ctor_get(x_27, 2); +lean_inc(x_99); +x_100 = lean_ctor_get(x_27, 3); +lean_inc(x_100); +x_101 = lean_ctor_get(x_27, 4); +lean_inc(x_101); +lean_dec(x_27); +x_167 = l_Lean_Expr_hasLevelParam(x_100); +if (x_167 == 0) +{ +uint8_t x_168; +x_168 = l_Lean_Expr_hasFVar(x_100); +if (x_168 == 0) +{ +uint8_t x_169; +x_169 = l_Lean_Expr_hasMVar(x_100); +if (x_169 == 0) +{ +x_102 = x_100; +x_103 = x_3; +goto block_140; +} +else +{ +lean_object* x_170; +x_170 = lean_box(0); +x_141 = x_170; +goto block_166; +} +} +else +{ +lean_object* x_171; +x_171 = lean_box(0); +x_141 = x_171; +goto block_166; +} +} +else +{ +lean_object* x_172; +x_172 = lean_box(0); +x_141 = x_172; +goto block_166; +} +block_140: +{ +lean_object* x_104; uint8_t x_133; +x_133 = l_Lean_Expr_hasLevelParam(x_101); +if (x_133 == 0) +{ +uint8_t x_134; +x_134 = l_Lean_Expr_hasFVar(x_101); +if (x_134 == 0) +{ +uint8_t x_135; +x_135 = l_Lean_Expr_hasMVar(x_101); +if (x_135 == 0) +{ +lean_object* x_136; +x_136 = l_Lean_Closure_mkLetDecl(x_99, x_102, x_101, x_2, x_103); +lean_dec(x_2); +return x_136; +} +else +{ +lean_object* x_137; +x_137 = lean_box(0); +x_104 = x_137; +goto block_132; +} +} +else +{ +lean_object* x_138; +x_138 = lean_box(0); +x_104 = x_138; +goto block_132; +} +} +else +{ +lean_object* x_139; +x_139 = lean_box(0); +x_104 = x_139; +goto block_132; +} +block_132: +{ +lean_object* x_105; lean_object* x_106; +lean_dec(x_104); +x_105 = lean_ctor_get(x_103, 3); +lean_inc(x_105); +x_106 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_105, x_101); +lean_dec(x_105); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; +lean_inc(x_2); +lean_inc(x_101); +x_107 = l_Lean_Closure_collectExprAux___main(x_101, x_2, x_103); +if (lean_obj_tag(x_107) == 0) +{ +lean_object* x_108; lean_object* x_109; uint8_t x_110; +x_108 = lean_ctor_get(x_107, 1); +lean_inc(x_108); +x_109 = lean_ctor_get(x_107, 0); +lean_inc(x_109); +lean_dec(x_107); +x_110 = !lean_is_exclusive(x_108); +if (x_110 == 0) +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_111 = lean_ctor_get(x_108, 3); +lean_inc(x_109); +x_112 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_111, x_101, x_109); +lean_ctor_set(x_108, 3, x_112); +x_113 = l_Lean_Closure_mkLetDecl(x_99, x_102, x_109, x_2, x_108); +lean_dec(x_2); +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_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; +x_114 = lean_ctor_get(x_108, 0); +x_115 = lean_ctor_get(x_108, 1); +x_116 = lean_ctor_get(x_108, 2); +x_117 = lean_ctor_get(x_108, 3); +x_118 = lean_ctor_get(x_108, 4); +x_119 = lean_ctor_get(x_108, 5); +x_120 = lean_ctor_get(x_108, 6); +x_121 = lean_ctor_get(x_108, 7); +x_122 = lean_ctor_get(x_108, 8); +lean_inc(x_122); +lean_inc(x_121); +lean_inc(x_120); +lean_inc(x_119); +lean_inc(x_118); +lean_inc(x_117); +lean_inc(x_116); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_108); +lean_inc(x_109); +x_123 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_117, x_101, x_109); +x_124 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_124, 0, x_114); +lean_ctor_set(x_124, 1, x_115); +lean_ctor_set(x_124, 2, x_116); +lean_ctor_set(x_124, 3, x_123); +lean_ctor_set(x_124, 4, x_118); +lean_ctor_set(x_124, 5, x_119); +lean_ctor_set(x_124, 6, x_120); +lean_ctor_set(x_124, 7, x_121); +lean_ctor_set(x_124, 8, x_122); +x_125 = l_Lean_Closure_mkLetDecl(x_99, x_102, x_109, x_2, x_124); +lean_dec(x_2); +return x_125; +} +} +else +{ +uint8_t x_126; +lean_dec(x_102); +lean_dec(x_101); +lean_dec(x_99); +lean_dec(x_2); +x_126 = !lean_is_exclusive(x_107); +if (x_126 == 0) +{ +return x_107; +} +else +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; +x_127 = lean_ctor_get(x_107, 0); +x_128 = lean_ctor_get(x_107, 1); +lean_inc(x_128); +lean_inc(x_127); +lean_dec(x_107); +x_129 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_129, 0, x_127); +lean_ctor_set(x_129, 1, x_128); +return x_129; +} +} +} +else +{ +lean_object* x_130; lean_object* x_131; +lean_dec(x_101); +x_130 = lean_ctor_get(x_106, 0); +lean_inc(x_130); +lean_dec(x_106); +x_131 = l_Lean_Closure_mkLetDecl(x_99, x_102, x_130, x_2, x_103); +lean_dec(x_2); +return x_131; +} +} +} +block_166: +{ +lean_object* x_142; lean_object* x_143; +lean_dec(x_141); +x_142 = lean_ctor_get(x_3, 3); +lean_inc(x_142); +x_143 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_142, x_100); +lean_dec(x_142); +if (lean_obj_tag(x_143) == 0) +{ +lean_object* x_144; +lean_inc(x_2); +lean_inc(x_100); +x_144 = l_Lean_Closure_collectExprAux___main(x_100, x_2, x_3); +if (lean_obj_tag(x_144) == 0) +{ +lean_object* x_145; lean_object* x_146; uint8_t x_147; +x_145 = lean_ctor_get(x_144, 1); +lean_inc(x_145); +x_146 = lean_ctor_get(x_144, 0); +lean_inc(x_146); +lean_dec(x_144); +x_147 = !lean_is_exclusive(x_145); +if (x_147 == 0) +{ +lean_object* x_148; lean_object* x_149; +x_148 = lean_ctor_get(x_145, 3); +lean_inc(x_146); +x_149 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_148, x_100, x_146); +lean_ctor_set(x_145, 3, x_149); +x_102 = x_146; +x_103 = x_145; +goto block_140; +} +else +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +x_150 = lean_ctor_get(x_145, 0); +x_151 = lean_ctor_get(x_145, 1); +x_152 = lean_ctor_get(x_145, 2); +x_153 = lean_ctor_get(x_145, 3); +x_154 = lean_ctor_get(x_145, 4); +x_155 = lean_ctor_get(x_145, 5); +x_156 = lean_ctor_get(x_145, 6); +x_157 = lean_ctor_get(x_145, 7); +x_158 = lean_ctor_get(x_145, 8); +lean_inc(x_158); +lean_inc(x_157); +lean_inc(x_156); +lean_inc(x_155); +lean_inc(x_154); +lean_inc(x_153); +lean_inc(x_152); +lean_inc(x_151); +lean_inc(x_150); +lean_dec(x_145); +lean_inc(x_146); +x_159 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_153, x_100, x_146); +x_160 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_160, 0, x_150); +lean_ctor_set(x_160, 1, x_151); +lean_ctor_set(x_160, 2, x_152); +lean_ctor_set(x_160, 3, x_159); +lean_ctor_set(x_160, 4, x_154); +lean_ctor_set(x_160, 5, x_155); +lean_ctor_set(x_160, 6, x_156); +lean_ctor_set(x_160, 7, x_157); +lean_ctor_set(x_160, 8, x_158); +x_102 = x_146; +x_103 = x_160; +goto block_140; +} +} +else +{ +uint8_t x_161; +lean_dec(x_101); +lean_dec(x_100); +lean_dec(x_99); +lean_dec(x_2); +x_161 = !lean_is_exclusive(x_144); +if (x_161 == 0) +{ +return x_144; +} +else +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; +x_162 = lean_ctor_get(x_144, 0); +x_163 = lean_ctor_get(x_144, 1); +lean_inc(x_163); +lean_inc(x_162); +lean_dec(x_144); +x_164 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_164, 0, x_162); +lean_ctor_set(x_164, 1, x_163); +return x_164; +} +} +} +else +{ +lean_object* x_165; +lean_dec(x_100); +x_165 = lean_ctor_get(x_143, 0); +lean_inc(x_165); +lean_dec(x_143); +x_102 = x_165; +x_103 = x_3; +goto block_140; +} +} +} +} +} +case 2: +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_210; lean_object* x_211; +x_173 = lean_ctor_get(x_1, 0); +lean_inc(x_173); +x_210 = lean_ctor_get(x_2, 0); +lean_inc(x_210); +x_211 = lean_metavar_ctx_find_decl(x_210, x_173); +if (lean_obj_tag(x_211) == 0) +{ +lean_object* x_212; lean_object* x_213; +lean_dec(x_2); +lean_dec(x_1); +x_212 = l_Lean_MetavarContext_getDecl___closed__2; +x_213 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_213, 0, x_212); +lean_ctor_set(x_213, 1, x_3); +return x_213; +} +else +{ +lean_object* x_214; lean_object* x_215; lean_object* x_216; uint8_t x_242; +x_214 = lean_ctor_get(x_211, 0); +lean_inc(x_214); +lean_dec(x_211); +x_215 = lean_ctor_get(x_214, 2); +lean_inc(x_215); +lean_dec(x_214); +x_242 = l_Lean_Expr_hasLevelParam(x_215); +if (x_242 == 0) +{ +uint8_t x_243; +x_243 = l_Lean_Expr_hasFVar(x_215); +if (x_243 == 0) +{ +uint8_t x_244; +x_244 = l_Lean_Expr_hasMVar(x_215); +if (x_244 == 0) +{ +x_174 = x_215; +x_175 = x_3; +goto block_209; +} +else +{ +lean_object* x_245; +x_245 = lean_box(0); +x_216 = x_245; +goto block_241; +} +} +else +{ +lean_object* x_246; +x_246 = lean_box(0); +x_216 = x_246; +goto block_241; +} +} +else +{ +lean_object* x_247; +x_247 = lean_box(0); +x_216 = x_247; +goto block_241; +} +block_241: +{ +lean_object* x_217; lean_object* x_218; +lean_dec(x_216); +x_217 = lean_ctor_get(x_3, 3); +lean_inc(x_217); +x_218 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_217, x_215); +lean_dec(x_217); +if (lean_obj_tag(x_218) == 0) +{ +lean_object* x_219; +lean_inc(x_2); +lean_inc(x_215); +x_219 = l_Lean_Closure_collectExprAux___main(x_215, x_2, x_3); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; uint8_t x_222; +x_220 = lean_ctor_get(x_219, 1); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 0); +lean_inc(x_221); +lean_dec(x_219); +x_222 = !lean_is_exclusive(x_220); +if (x_222 == 0) +{ +lean_object* x_223; lean_object* x_224; +x_223 = lean_ctor_get(x_220, 3); +lean_inc(x_221); +x_224 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_223, x_215, x_221); +lean_ctor_set(x_220, 3, x_224); +x_174 = x_221; +x_175 = x_220; +goto block_209; +} +else +{ +lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; +x_225 = lean_ctor_get(x_220, 0); +x_226 = lean_ctor_get(x_220, 1); +x_227 = lean_ctor_get(x_220, 2); +x_228 = lean_ctor_get(x_220, 3); +x_229 = lean_ctor_get(x_220, 4); +x_230 = lean_ctor_get(x_220, 5); +x_231 = lean_ctor_get(x_220, 6); +x_232 = lean_ctor_get(x_220, 7); +x_233 = lean_ctor_get(x_220, 8); +lean_inc(x_233); +lean_inc(x_232); +lean_inc(x_231); +lean_inc(x_230); +lean_inc(x_229); +lean_inc(x_228); +lean_inc(x_227); +lean_inc(x_226); +lean_inc(x_225); +lean_dec(x_220); +lean_inc(x_221); +x_234 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_228, x_215, x_221); +x_235 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_235, 0, x_225); +lean_ctor_set(x_235, 1, x_226); +lean_ctor_set(x_235, 2, x_227); +lean_ctor_set(x_235, 3, x_234); +lean_ctor_set(x_235, 4, x_229); +lean_ctor_set(x_235, 5, x_230); +lean_ctor_set(x_235, 6, x_231); +lean_ctor_set(x_235, 7, x_232); +lean_ctor_set(x_235, 8, x_233); +x_174 = x_221; +x_175 = x_235; +goto block_209; +} +} +else +{ +uint8_t x_236; +lean_dec(x_215); +lean_dec(x_2); +lean_dec(x_1); +x_236 = !lean_is_exclusive(x_219); +if (x_236 == 0) +{ +return x_219; +} +else +{ +lean_object* x_237; lean_object* x_238; lean_object* x_239; +x_237 = lean_ctor_get(x_219, 0); +x_238 = lean_ctor_get(x_219, 1); +lean_inc(x_238); +lean_inc(x_237); +lean_dec(x_219); +x_239 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_239, 0, x_237); +lean_ctor_set(x_239, 1, x_238); +return x_239; +} +} +} +else +{ +lean_object* x_240; +lean_dec(x_215); +x_240 = lean_ctor_get(x_218, 0); +lean_inc(x_240); +lean_dec(x_218); +x_174 = x_240; +x_175 = x_3; +goto block_209; +} +} +} +block_209: +{ +lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_176 = lean_box(0); +x_177 = l_Lean_Closure_mkLocalDecl(x_176, x_174, x_2, x_175); +lean_dec(x_2); +x_178 = !lean_is_exclusive(x_177); +if (x_178 == 0) +{ +lean_object* x_179; uint8_t x_180; +x_179 = lean_ctor_get(x_177, 1); +x_180 = !lean_is_exclusive(x_179); +if (x_180 == 0) +{ +lean_object* x_181; lean_object* x_182; +x_181 = lean_ctor_get(x_179, 8); +x_182 = lean_array_push(x_181, x_1); +lean_ctor_set(x_179, 8, x_182); +return x_177; +} +else +{ +lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; +x_183 = lean_ctor_get(x_179, 0); +x_184 = lean_ctor_get(x_179, 1); +x_185 = lean_ctor_get(x_179, 2); +x_186 = lean_ctor_get(x_179, 3); +x_187 = lean_ctor_get(x_179, 4); +x_188 = lean_ctor_get(x_179, 5); +x_189 = lean_ctor_get(x_179, 6); +x_190 = lean_ctor_get(x_179, 7); +x_191 = lean_ctor_get(x_179, 8); +lean_inc(x_191); +lean_inc(x_190); +lean_inc(x_189); +lean_inc(x_188); +lean_inc(x_187); +lean_inc(x_186); +lean_inc(x_185); +lean_inc(x_184); +lean_inc(x_183); +lean_dec(x_179); +x_192 = lean_array_push(x_191, x_1); +x_193 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_193, 0, x_183); +lean_ctor_set(x_193, 1, x_184); +lean_ctor_set(x_193, 2, x_185); +lean_ctor_set(x_193, 3, x_186); +lean_ctor_set(x_193, 4, x_187); +lean_ctor_set(x_193, 5, x_188); +lean_ctor_set(x_193, 6, x_189); +lean_ctor_set(x_193, 7, x_190); +lean_ctor_set(x_193, 8, x_192); +lean_ctor_set(x_177, 1, x_193); +return x_177; +} +} +else +{ +lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; +x_194 = lean_ctor_get(x_177, 1); +x_195 = lean_ctor_get(x_177, 0); +lean_inc(x_194); +lean_inc(x_195); +lean_dec(x_177); +x_196 = lean_ctor_get(x_194, 0); +lean_inc(x_196); +x_197 = lean_ctor_get(x_194, 1); +lean_inc(x_197); +x_198 = lean_ctor_get(x_194, 2); +lean_inc(x_198); +x_199 = lean_ctor_get(x_194, 3); +lean_inc(x_199); +x_200 = lean_ctor_get(x_194, 4); +lean_inc(x_200); +x_201 = lean_ctor_get(x_194, 5); +lean_inc(x_201); +x_202 = lean_ctor_get(x_194, 6); +lean_inc(x_202); +x_203 = lean_ctor_get(x_194, 7); +lean_inc(x_203); +x_204 = lean_ctor_get(x_194, 8); +lean_inc(x_204); +if (lean_is_exclusive(x_194)) { + lean_ctor_release(x_194, 0); + lean_ctor_release(x_194, 1); + lean_ctor_release(x_194, 2); + lean_ctor_release(x_194, 3); + lean_ctor_release(x_194, 4); + lean_ctor_release(x_194, 5); + lean_ctor_release(x_194, 6); + lean_ctor_release(x_194, 7); + lean_ctor_release(x_194, 8); + x_205 = x_194; +} else { + lean_dec_ref(x_194); + x_205 = lean_box(0); +} +x_206 = lean_array_push(x_204, x_1); +if (lean_is_scalar(x_205)) { + x_207 = lean_alloc_ctor(0, 9, 0); +} else { + x_207 = x_205; +} +lean_ctor_set(x_207, 0, x_196); +lean_ctor_set(x_207, 1, x_197); +lean_ctor_set(x_207, 2, x_198); +lean_ctor_set(x_207, 3, x_199); +lean_ctor_set(x_207, 4, x_200); +lean_ctor_set(x_207, 5, x_201); +lean_ctor_set(x_207, 6, x_202); +lean_ctor_set(x_207, 7, x_203); +lean_ctor_set(x_207, 8, x_206); +x_208 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_208, 0, x_195); +lean_ctor_set(x_208, 1, x_207); +return x_208; +} +} +} +case 3: +{ +lean_object* x_248; lean_object* x_249; uint8_t x_250; +x_248 = lean_ctor_get(x_1, 0); +lean_inc(x_248); +x_249 = l_Lean_Closure_collectLevel(x_248, x_2, x_3); +lean_dec(x_2); +x_250 = !lean_is_exclusive(x_249); +if (x_250 == 0) +{ +lean_object* x_251; lean_object* x_252; +x_251 = lean_ctor_get(x_249, 0); +x_252 = lean_expr_update_sort(x_1, x_251); +lean_ctor_set(x_249, 0, x_252); +return x_249; +} +else +{ +lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; +x_253 = lean_ctor_get(x_249, 0); +x_254 = lean_ctor_get(x_249, 1); +lean_inc(x_254); +lean_inc(x_253); +lean_dec(x_249); +x_255 = lean_expr_update_sort(x_1, x_253); +x_256 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_256, 0, x_255); +lean_ctor_set(x_256, 1, x_254); +return x_256; +} +} +case 4: +{ +lean_object* x_257; lean_object* x_258; uint8_t x_259; +x_257 = lean_ctor_get(x_1, 1); +lean_inc(x_257); +x_258 = l_List_mapM___main___at_Lean_Closure_collectExprAux___main___spec__1(x_257, x_2, x_3); +lean_dec(x_2); +x_259 = !lean_is_exclusive(x_258); +if (x_259 == 0) +{ +lean_object* x_260; lean_object* x_261; +x_260 = lean_ctor_get(x_258, 0); +x_261 = lean_expr_update_const(x_1, x_260); +lean_ctor_set(x_258, 0, x_261); +return x_258; +} +else +{ +lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; +x_262 = lean_ctor_get(x_258, 0); +x_263 = lean_ctor_get(x_258, 1); +lean_inc(x_263); +lean_inc(x_262); +lean_dec(x_258); +x_264 = lean_expr_update_const(x_1, x_262); +x_265 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_265, 0, x_264); +lean_ctor_set(x_265, 1, x_263); +return x_265; +} +} +case 5: +{ +lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_312; uint8_t x_338; +x_266 = lean_ctor_get(x_1, 0); +lean_inc(x_266); +x_267 = lean_ctor_get(x_1, 1); +lean_inc(x_267); +x_338 = l_Lean_Expr_hasLevelParam(x_266); +if (x_338 == 0) +{ +uint8_t x_339; +x_339 = l_Lean_Expr_hasFVar(x_266); +if (x_339 == 0) +{ +uint8_t x_340; +x_340 = l_Lean_Expr_hasMVar(x_266); +if (x_340 == 0) +{ +x_268 = x_266; +x_269 = x_3; +goto block_311; +} +else +{ +lean_object* x_341; +x_341 = lean_box(0); +x_312 = x_341; +goto block_337; +} +} +else +{ +lean_object* x_342; +x_342 = lean_box(0); +x_312 = x_342; +goto block_337; +} +} +else +{ +lean_object* x_343; +x_343 = lean_box(0); +x_312 = x_343; +goto block_337; +} +block_311: +{ +lean_object* x_270; lean_object* x_271; lean_object* x_279; uint8_t x_305; +x_305 = l_Lean_Expr_hasLevelParam(x_267); +if (x_305 == 0) +{ +uint8_t x_306; +x_306 = l_Lean_Expr_hasFVar(x_267); +if (x_306 == 0) +{ +uint8_t x_307; +x_307 = l_Lean_Expr_hasMVar(x_267); +if (x_307 == 0) +{ +lean_dec(x_2); +x_270 = x_267; +x_271 = x_269; +goto block_278; +} +else +{ +lean_object* x_308; +x_308 = lean_box(0); +x_279 = x_308; +goto block_304; +} +} +else +{ +lean_object* x_309; +x_309 = lean_box(0); +x_279 = x_309; +goto block_304; +} +} +else +{ +lean_object* x_310; +x_310 = lean_box(0); +x_279 = x_310; +goto block_304; +} +block_278: +{ +if (lean_obj_tag(x_1) == 5) +{ +lean_object* x_272; lean_object* x_273; +x_272 = lean_expr_update_app(x_1, x_268, x_270); +x_273 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_273, 0, x_272); +lean_ctor_set(x_273, 1, x_271); +return x_273; +} +else +{ +lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; +lean_dec(x_270); +lean_dec(x_268); +lean_dec(x_1); +x_274 = l_Lean_Expr_Inhabited; +x_275 = l_Lean_Expr_updateApp_x21___closed__1; +x_276 = lean_panic_fn(x_274, x_275); +x_277 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_277, 0, x_276); +lean_ctor_set(x_277, 1, x_271); +return x_277; +} +} +block_304: +{ +lean_object* x_280; lean_object* x_281; +lean_dec(x_279); +x_280 = lean_ctor_get(x_269, 3); +lean_inc(x_280); +x_281 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_280, x_267); +lean_dec(x_280); +if (lean_obj_tag(x_281) == 0) +{ +lean_object* x_282; +lean_inc(x_267); +x_282 = l_Lean_Closure_collectExprAux___main(x_267, x_2, x_269); +if (lean_obj_tag(x_282) == 0) +{ +lean_object* x_283; lean_object* x_284; uint8_t x_285; +x_283 = lean_ctor_get(x_282, 1); +lean_inc(x_283); +x_284 = lean_ctor_get(x_282, 0); +lean_inc(x_284); +lean_dec(x_282); +x_285 = !lean_is_exclusive(x_283); +if (x_285 == 0) +{ +lean_object* x_286; lean_object* x_287; +x_286 = lean_ctor_get(x_283, 3); +lean_inc(x_284); +x_287 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_286, x_267, x_284); +lean_ctor_set(x_283, 3, x_287); +x_270 = x_284; +x_271 = x_283; +goto block_278; +} +else +{ +lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; +x_288 = lean_ctor_get(x_283, 0); +x_289 = lean_ctor_get(x_283, 1); +x_290 = lean_ctor_get(x_283, 2); +x_291 = lean_ctor_get(x_283, 3); +x_292 = lean_ctor_get(x_283, 4); +x_293 = lean_ctor_get(x_283, 5); +x_294 = lean_ctor_get(x_283, 6); +x_295 = lean_ctor_get(x_283, 7); +x_296 = lean_ctor_get(x_283, 8); +lean_inc(x_296); +lean_inc(x_295); +lean_inc(x_294); +lean_inc(x_293); +lean_inc(x_292); +lean_inc(x_291); +lean_inc(x_290); +lean_inc(x_289); +lean_inc(x_288); +lean_dec(x_283); +lean_inc(x_284); +x_297 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_291, x_267, x_284); +x_298 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_298, 0, x_288); +lean_ctor_set(x_298, 1, x_289); +lean_ctor_set(x_298, 2, x_290); +lean_ctor_set(x_298, 3, x_297); +lean_ctor_set(x_298, 4, x_292); +lean_ctor_set(x_298, 5, x_293); +lean_ctor_set(x_298, 6, x_294); +lean_ctor_set(x_298, 7, x_295); +lean_ctor_set(x_298, 8, x_296); +x_270 = x_284; +x_271 = x_298; +goto block_278; +} +} +else +{ +uint8_t x_299; +lean_dec(x_268); +lean_dec(x_267); +lean_dec(x_1); +x_299 = !lean_is_exclusive(x_282); +if (x_299 == 0) +{ +return x_282; +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; +x_300 = lean_ctor_get(x_282, 0); +x_301 = lean_ctor_get(x_282, 1); +lean_inc(x_301); +lean_inc(x_300); +lean_dec(x_282); +x_302 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_302, 0, x_300); +lean_ctor_set(x_302, 1, x_301); +return x_302; +} +} +} +else +{ +lean_object* x_303; +lean_dec(x_267); +lean_dec(x_2); +x_303 = lean_ctor_get(x_281, 0); +lean_inc(x_303); +lean_dec(x_281); +x_270 = x_303; +x_271 = x_269; +goto block_278; +} +} +} +block_337: +{ +lean_object* x_313; lean_object* x_314; +lean_dec(x_312); +x_313 = lean_ctor_get(x_3, 3); +lean_inc(x_313); +x_314 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_313, x_266); +lean_dec(x_313); +if (lean_obj_tag(x_314) == 0) +{ +lean_object* x_315; +lean_inc(x_2); +lean_inc(x_266); +x_315 = l_Lean_Closure_collectExprAux___main(x_266, x_2, x_3); +if (lean_obj_tag(x_315) == 0) +{ +lean_object* x_316; lean_object* x_317; uint8_t x_318; +x_316 = lean_ctor_get(x_315, 1); +lean_inc(x_316); +x_317 = lean_ctor_get(x_315, 0); +lean_inc(x_317); +lean_dec(x_315); +x_318 = !lean_is_exclusive(x_316); +if (x_318 == 0) +{ +lean_object* x_319; lean_object* x_320; +x_319 = lean_ctor_get(x_316, 3); +lean_inc(x_317); +x_320 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_319, x_266, x_317); +lean_ctor_set(x_316, 3, x_320); +x_268 = x_317; +x_269 = x_316; +goto block_311; +} +else +{ +lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; +x_321 = lean_ctor_get(x_316, 0); +x_322 = lean_ctor_get(x_316, 1); +x_323 = lean_ctor_get(x_316, 2); +x_324 = lean_ctor_get(x_316, 3); +x_325 = lean_ctor_get(x_316, 4); +x_326 = lean_ctor_get(x_316, 5); +x_327 = lean_ctor_get(x_316, 6); +x_328 = lean_ctor_get(x_316, 7); +x_329 = lean_ctor_get(x_316, 8); +lean_inc(x_329); +lean_inc(x_328); +lean_inc(x_327); +lean_inc(x_326); +lean_inc(x_325); +lean_inc(x_324); +lean_inc(x_323); +lean_inc(x_322); +lean_inc(x_321); +lean_dec(x_316); +lean_inc(x_317); +x_330 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_324, x_266, x_317); +x_331 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_331, 0, x_321); +lean_ctor_set(x_331, 1, x_322); +lean_ctor_set(x_331, 2, x_323); +lean_ctor_set(x_331, 3, x_330); +lean_ctor_set(x_331, 4, x_325); +lean_ctor_set(x_331, 5, x_326); +lean_ctor_set(x_331, 6, x_327); +lean_ctor_set(x_331, 7, x_328); +lean_ctor_set(x_331, 8, x_329); +x_268 = x_317; +x_269 = x_331; +goto block_311; +} +} +else +{ +uint8_t x_332; +lean_dec(x_267); +lean_dec(x_266); +lean_dec(x_2); +lean_dec(x_1); +x_332 = !lean_is_exclusive(x_315); +if (x_332 == 0) +{ +return x_315; +} +else +{ +lean_object* x_333; lean_object* x_334; lean_object* x_335; +x_333 = lean_ctor_get(x_315, 0); +x_334 = lean_ctor_get(x_315, 1); +lean_inc(x_334); +lean_inc(x_333); +lean_dec(x_315); +x_335 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_335, 0, x_333); +lean_ctor_set(x_335, 1, x_334); +return x_335; +} +} +} +else +{ +lean_object* x_336; +lean_dec(x_266); +x_336 = lean_ctor_get(x_314, 0); +lean_inc(x_336); +lean_dec(x_314); +x_268 = x_336; +x_269 = x_3; +goto block_311; +} +} +} +case 6: +{ +lean_object* x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_392; uint8_t x_418; +x_344 = lean_ctor_get(x_1, 1); +lean_inc(x_344); +x_345 = lean_ctor_get(x_1, 2); +lean_inc(x_345); +x_418 = l_Lean_Expr_hasLevelParam(x_344); +if (x_418 == 0) +{ +uint8_t x_419; +x_419 = l_Lean_Expr_hasFVar(x_344); +if (x_419 == 0) +{ +uint8_t x_420; +x_420 = l_Lean_Expr_hasMVar(x_344); +if (x_420 == 0) +{ +x_346 = x_344; +x_347 = x_3; +goto block_391; +} +else +{ +lean_object* x_421; +x_421 = lean_box(0); +x_392 = x_421; +goto block_417; +} +} +else +{ +lean_object* x_422; +x_422 = lean_box(0); +x_392 = x_422; +goto block_417; +} +} +else +{ +lean_object* x_423; +x_423 = lean_box(0); +x_392 = x_423; +goto block_417; +} +block_391: +{ +lean_object* x_348; lean_object* x_349; lean_object* x_359; uint8_t x_385; +x_385 = l_Lean_Expr_hasLevelParam(x_345); +if (x_385 == 0) +{ +uint8_t x_386; +x_386 = l_Lean_Expr_hasFVar(x_345); +if (x_386 == 0) +{ +uint8_t x_387; +x_387 = l_Lean_Expr_hasMVar(x_345); +if (x_387 == 0) +{ +lean_dec(x_2); +x_348 = x_345; +x_349 = x_347; +goto block_358; +} +else +{ +lean_object* x_388; +x_388 = lean_box(0); +x_359 = x_388; +goto block_384; +} +} +else +{ +lean_object* x_389; +x_389 = lean_box(0); +x_359 = x_389; +goto block_384; +} +} +else +{ +lean_object* x_390; +x_390 = lean_box(0); +x_359 = x_390; +goto block_384; +} +block_358: +{ +if (lean_obj_tag(x_1) == 6) +{ +uint64_t x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; +x_350 = lean_ctor_get_uint64(x_1, sizeof(void*)*3); +x_351 = (uint8_t)((x_350 << 24) >> 61); +x_352 = lean_expr_update_lambda(x_1, x_351, x_346, x_348); +x_353 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_353, 0, x_352); +lean_ctor_set(x_353, 1, x_349); +return x_353; +} +else +{ +lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; +lean_dec(x_348); +lean_dec(x_346); +lean_dec(x_1); +x_354 = l_Lean_Expr_Inhabited; +x_355 = l_Lean_Expr_updateLambdaE_x21___closed__1; +x_356 = lean_panic_fn(x_354, x_355); +x_357 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_357, 0, x_356); +lean_ctor_set(x_357, 1, x_349); +return x_357; +} +} +block_384: +{ +lean_object* x_360; lean_object* x_361; +lean_dec(x_359); +x_360 = lean_ctor_get(x_347, 3); +lean_inc(x_360); +x_361 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_360, x_345); +lean_dec(x_360); +if (lean_obj_tag(x_361) == 0) +{ +lean_object* x_362; +lean_inc(x_345); +x_362 = l_Lean_Closure_collectExprAux___main(x_345, x_2, x_347); +if (lean_obj_tag(x_362) == 0) +{ +lean_object* x_363; lean_object* x_364; uint8_t x_365; +x_363 = lean_ctor_get(x_362, 1); +lean_inc(x_363); +x_364 = lean_ctor_get(x_362, 0); +lean_inc(x_364); +lean_dec(x_362); +x_365 = !lean_is_exclusive(x_363); +if (x_365 == 0) +{ +lean_object* x_366; lean_object* x_367; +x_366 = lean_ctor_get(x_363, 3); +lean_inc(x_364); +x_367 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_366, x_345, x_364); +lean_ctor_set(x_363, 3, x_367); +x_348 = x_364; +x_349 = x_363; +goto block_358; +} +else +{ +lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; +x_368 = lean_ctor_get(x_363, 0); +x_369 = lean_ctor_get(x_363, 1); +x_370 = lean_ctor_get(x_363, 2); +x_371 = lean_ctor_get(x_363, 3); +x_372 = lean_ctor_get(x_363, 4); +x_373 = lean_ctor_get(x_363, 5); +x_374 = lean_ctor_get(x_363, 6); +x_375 = lean_ctor_get(x_363, 7); +x_376 = lean_ctor_get(x_363, 8); +lean_inc(x_376); +lean_inc(x_375); +lean_inc(x_374); +lean_inc(x_373); +lean_inc(x_372); +lean_inc(x_371); +lean_inc(x_370); +lean_inc(x_369); +lean_inc(x_368); +lean_dec(x_363); +lean_inc(x_364); +x_377 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_371, x_345, x_364); +x_378 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_378, 0, x_368); +lean_ctor_set(x_378, 1, x_369); +lean_ctor_set(x_378, 2, x_370); +lean_ctor_set(x_378, 3, x_377); +lean_ctor_set(x_378, 4, x_372); +lean_ctor_set(x_378, 5, x_373); +lean_ctor_set(x_378, 6, x_374); +lean_ctor_set(x_378, 7, x_375); +lean_ctor_set(x_378, 8, x_376); +x_348 = x_364; +x_349 = x_378; +goto block_358; +} +} +else +{ +uint8_t x_379; +lean_dec(x_346); +lean_dec(x_345); +lean_dec(x_1); +x_379 = !lean_is_exclusive(x_362); +if (x_379 == 0) +{ +return x_362; +} +else +{ +lean_object* x_380; lean_object* x_381; lean_object* x_382; +x_380 = lean_ctor_get(x_362, 0); +x_381 = lean_ctor_get(x_362, 1); +lean_inc(x_381); +lean_inc(x_380); +lean_dec(x_362); +x_382 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_382, 0, x_380); +lean_ctor_set(x_382, 1, x_381); +return x_382; +} +} +} +else +{ +lean_object* x_383; +lean_dec(x_345); +lean_dec(x_2); +x_383 = lean_ctor_get(x_361, 0); +lean_inc(x_383); +lean_dec(x_361); +x_348 = x_383; +x_349 = x_347; +goto block_358; +} +} +} +block_417: +{ +lean_object* x_393; lean_object* x_394; +lean_dec(x_392); +x_393 = lean_ctor_get(x_3, 3); +lean_inc(x_393); +x_394 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_393, x_344); +lean_dec(x_393); +if (lean_obj_tag(x_394) == 0) +{ +lean_object* x_395; +lean_inc(x_2); +lean_inc(x_344); +x_395 = l_Lean_Closure_collectExprAux___main(x_344, x_2, x_3); +if (lean_obj_tag(x_395) == 0) +{ +lean_object* x_396; lean_object* x_397; uint8_t x_398; +x_396 = lean_ctor_get(x_395, 1); +lean_inc(x_396); +x_397 = lean_ctor_get(x_395, 0); +lean_inc(x_397); +lean_dec(x_395); +x_398 = !lean_is_exclusive(x_396); +if (x_398 == 0) +{ +lean_object* x_399; lean_object* x_400; +x_399 = lean_ctor_get(x_396, 3); +lean_inc(x_397); +x_400 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_399, x_344, x_397); +lean_ctor_set(x_396, 3, x_400); +x_346 = x_397; +x_347 = x_396; +goto block_391; +} +else +{ +lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; lean_object* x_410; lean_object* x_411; +x_401 = lean_ctor_get(x_396, 0); +x_402 = lean_ctor_get(x_396, 1); +x_403 = lean_ctor_get(x_396, 2); +x_404 = lean_ctor_get(x_396, 3); +x_405 = lean_ctor_get(x_396, 4); +x_406 = lean_ctor_get(x_396, 5); +x_407 = lean_ctor_get(x_396, 6); +x_408 = lean_ctor_get(x_396, 7); +x_409 = lean_ctor_get(x_396, 8); +lean_inc(x_409); +lean_inc(x_408); +lean_inc(x_407); +lean_inc(x_406); +lean_inc(x_405); +lean_inc(x_404); +lean_inc(x_403); +lean_inc(x_402); +lean_inc(x_401); +lean_dec(x_396); +lean_inc(x_397); +x_410 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_404, x_344, x_397); +x_411 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_411, 0, x_401); +lean_ctor_set(x_411, 1, x_402); +lean_ctor_set(x_411, 2, x_403); +lean_ctor_set(x_411, 3, x_410); +lean_ctor_set(x_411, 4, x_405); +lean_ctor_set(x_411, 5, x_406); +lean_ctor_set(x_411, 6, x_407); +lean_ctor_set(x_411, 7, x_408); +lean_ctor_set(x_411, 8, x_409); +x_346 = x_397; +x_347 = x_411; +goto block_391; +} +} +else +{ +uint8_t x_412; +lean_dec(x_345); +lean_dec(x_344); +lean_dec(x_2); +lean_dec(x_1); +x_412 = !lean_is_exclusive(x_395); +if (x_412 == 0) +{ +return x_395; +} +else +{ +lean_object* x_413; lean_object* x_414; lean_object* x_415; +x_413 = lean_ctor_get(x_395, 0); +x_414 = lean_ctor_get(x_395, 1); +lean_inc(x_414); +lean_inc(x_413); +lean_dec(x_395); +x_415 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_415, 0, x_413); +lean_ctor_set(x_415, 1, x_414); +return x_415; +} +} +} +else +{ +lean_object* x_416; +lean_dec(x_344); +x_416 = lean_ctor_get(x_394, 0); +lean_inc(x_416); +lean_dec(x_394); +x_346 = x_416; +x_347 = x_3; +goto block_391; +} +} +} +case 7: +{ +lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_472; uint8_t x_498; +x_424 = lean_ctor_get(x_1, 1); +lean_inc(x_424); +x_425 = lean_ctor_get(x_1, 2); +lean_inc(x_425); +x_498 = l_Lean_Expr_hasLevelParam(x_424); +if (x_498 == 0) +{ +uint8_t x_499; +x_499 = l_Lean_Expr_hasFVar(x_424); +if (x_499 == 0) +{ +uint8_t x_500; +x_500 = l_Lean_Expr_hasMVar(x_424); +if (x_500 == 0) +{ +x_426 = x_424; +x_427 = x_3; +goto block_471; +} +else +{ +lean_object* x_501; +x_501 = lean_box(0); +x_472 = x_501; +goto block_497; +} +} +else +{ +lean_object* x_502; +x_502 = lean_box(0); +x_472 = x_502; +goto block_497; +} +} +else +{ +lean_object* x_503; +x_503 = lean_box(0); +x_472 = x_503; +goto block_497; +} +block_471: +{ +lean_object* x_428; lean_object* x_429; lean_object* x_439; uint8_t x_465; +x_465 = l_Lean_Expr_hasLevelParam(x_425); +if (x_465 == 0) +{ +uint8_t x_466; +x_466 = l_Lean_Expr_hasFVar(x_425); +if (x_466 == 0) +{ +uint8_t x_467; +x_467 = l_Lean_Expr_hasMVar(x_425); +if (x_467 == 0) +{ +lean_dec(x_2); +x_428 = x_425; +x_429 = x_427; +goto block_438; +} +else +{ +lean_object* x_468; +x_468 = lean_box(0); +x_439 = x_468; +goto block_464; +} +} +else +{ +lean_object* x_469; +x_469 = lean_box(0); +x_439 = x_469; +goto block_464; +} +} +else +{ +lean_object* x_470; +x_470 = lean_box(0); +x_439 = x_470; +goto block_464; +} +block_438: +{ +if (lean_obj_tag(x_1) == 7) +{ +uint64_t x_430; uint8_t x_431; lean_object* x_432; lean_object* x_433; +x_430 = lean_ctor_get_uint64(x_1, sizeof(void*)*3); +x_431 = (uint8_t)((x_430 << 24) >> 61); +x_432 = lean_expr_update_forall(x_1, x_431, x_426, x_428); +x_433 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_433, 0, x_432); +lean_ctor_set(x_433, 1, x_429); +return x_433; +} +else +{ +lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; +lean_dec(x_428); +lean_dec(x_426); +lean_dec(x_1); +x_434 = l_Lean_Expr_Inhabited; +x_435 = l_Lean_Expr_updateForallE_x21___closed__1; +x_436 = lean_panic_fn(x_434, x_435); +x_437 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_437, 0, x_436); +lean_ctor_set(x_437, 1, x_429); +return x_437; +} +} +block_464: +{ +lean_object* x_440; lean_object* x_441; +lean_dec(x_439); +x_440 = lean_ctor_get(x_427, 3); +lean_inc(x_440); +x_441 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_440, x_425); +lean_dec(x_440); +if (lean_obj_tag(x_441) == 0) +{ +lean_object* x_442; +lean_inc(x_425); +x_442 = l_Lean_Closure_collectExprAux___main(x_425, x_2, x_427); +if (lean_obj_tag(x_442) == 0) +{ +lean_object* x_443; lean_object* x_444; uint8_t x_445; +x_443 = lean_ctor_get(x_442, 1); +lean_inc(x_443); +x_444 = lean_ctor_get(x_442, 0); +lean_inc(x_444); +lean_dec(x_442); +x_445 = !lean_is_exclusive(x_443); +if (x_445 == 0) +{ +lean_object* x_446; lean_object* x_447; +x_446 = lean_ctor_get(x_443, 3); +lean_inc(x_444); +x_447 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_446, x_425, x_444); +lean_ctor_set(x_443, 3, x_447); +x_428 = x_444; +x_429 = x_443; +goto block_438; +} +else +{ +lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; +x_448 = lean_ctor_get(x_443, 0); +x_449 = lean_ctor_get(x_443, 1); +x_450 = lean_ctor_get(x_443, 2); +x_451 = lean_ctor_get(x_443, 3); +x_452 = lean_ctor_get(x_443, 4); +x_453 = lean_ctor_get(x_443, 5); +x_454 = lean_ctor_get(x_443, 6); +x_455 = lean_ctor_get(x_443, 7); +x_456 = lean_ctor_get(x_443, 8); +lean_inc(x_456); +lean_inc(x_455); +lean_inc(x_454); +lean_inc(x_453); +lean_inc(x_452); +lean_inc(x_451); +lean_inc(x_450); +lean_inc(x_449); +lean_inc(x_448); +lean_dec(x_443); +lean_inc(x_444); +x_457 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_451, x_425, x_444); +x_458 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_458, 0, x_448); +lean_ctor_set(x_458, 1, x_449); +lean_ctor_set(x_458, 2, x_450); +lean_ctor_set(x_458, 3, x_457); +lean_ctor_set(x_458, 4, x_452); +lean_ctor_set(x_458, 5, x_453); +lean_ctor_set(x_458, 6, x_454); +lean_ctor_set(x_458, 7, x_455); +lean_ctor_set(x_458, 8, x_456); +x_428 = x_444; +x_429 = x_458; +goto block_438; +} +} +else +{ +uint8_t x_459; +lean_dec(x_426); +lean_dec(x_425); +lean_dec(x_1); +x_459 = !lean_is_exclusive(x_442); +if (x_459 == 0) +{ +return x_442; +} +else +{ +lean_object* x_460; lean_object* x_461; lean_object* x_462; +x_460 = lean_ctor_get(x_442, 0); +x_461 = lean_ctor_get(x_442, 1); +lean_inc(x_461); +lean_inc(x_460); +lean_dec(x_442); +x_462 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_462, 0, x_460); +lean_ctor_set(x_462, 1, x_461); +return x_462; +} +} +} +else +{ +lean_object* x_463; +lean_dec(x_425); +lean_dec(x_2); +x_463 = lean_ctor_get(x_441, 0); +lean_inc(x_463); +lean_dec(x_441); +x_428 = x_463; +x_429 = x_427; +goto block_438; +} +} +} +block_497: +{ +lean_object* x_473; lean_object* x_474; +lean_dec(x_472); +x_473 = lean_ctor_get(x_3, 3); +lean_inc(x_473); +x_474 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_473, x_424); +lean_dec(x_473); +if (lean_obj_tag(x_474) == 0) +{ +lean_object* x_475; +lean_inc(x_2); +lean_inc(x_424); +x_475 = l_Lean_Closure_collectExprAux___main(x_424, x_2, x_3); +if (lean_obj_tag(x_475) == 0) +{ +lean_object* x_476; lean_object* x_477; uint8_t x_478; +x_476 = lean_ctor_get(x_475, 1); +lean_inc(x_476); +x_477 = lean_ctor_get(x_475, 0); +lean_inc(x_477); +lean_dec(x_475); +x_478 = !lean_is_exclusive(x_476); +if (x_478 == 0) +{ +lean_object* x_479; lean_object* x_480; +x_479 = lean_ctor_get(x_476, 3); +lean_inc(x_477); +x_480 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_479, x_424, x_477); +lean_ctor_set(x_476, 3, x_480); +x_426 = x_477; +x_427 = x_476; +goto block_471; +} +else +{ +lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; +x_481 = lean_ctor_get(x_476, 0); +x_482 = lean_ctor_get(x_476, 1); +x_483 = lean_ctor_get(x_476, 2); +x_484 = lean_ctor_get(x_476, 3); +x_485 = lean_ctor_get(x_476, 4); +x_486 = lean_ctor_get(x_476, 5); +x_487 = lean_ctor_get(x_476, 6); +x_488 = lean_ctor_get(x_476, 7); +x_489 = lean_ctor_get(x_476, 8); +lean_inc(x_489); +lean_inc(x_488); +lean_inc(x_487); +lean_inc(x_486); +lean_inc(x_485); +lean_inc(x_484); +lean_inc(x_483); +lean_inc(x_482); +lean_inc(x_481); +lean_dec(x_476); +lean_inc(x_477); +x_490 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_484, x_424, x_477); +x_491 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_491, 0, x_481); +lean_ctor_set(x_491, 1, x_482); +lean_ctor_set(x_491, 2, x_483); +lean_ctor_set(x_491, 3, x_490); +lean_ctor_set(x_491, 4, x_485); +lean_ctor_set(x_491, 5, x_486); +lean_ctor_set(x_491, 6, x_487); +lean_ctor_set(x_491, 7, x_488); +lean_ctor_set(x_491, 8, x_489); +x_426 = x_477; +x_427 = x_491; +goto block_471; +} +} +else +{ +uint8_t x_492; +lean_dec(x_425); +lean_dec(x_424); +lean_dec(x_2); +lean_dec(x_1); +x_492 = !lean_is_exclusive(x_475); +if (x_492 == 0) +{ +return x_475; +} +else +{ +lean_object* x_493; lean_object* x_494; lean_object* x_495; +x_493 = lean_ctor_get(x_475, 0); +x_494 = lean_ctor_get(x_475, 1); +lean_inc(x_494); +lean_inc(x_493); +lean_dec(x_475); +x_495 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_495, 0, x_493); +lean_ctor_set(x_495, 1, x_494); +return x_495; +} +} +} +else +{ +lean_object* x_496; +lean_dec(x_424); +x_496 = lean_ctor_get(x_474, 0); +lean_inc(x_496); +lean_dec(x_474); +x_426 = x_496; +x_427 = x_3; +goto block_471; +} +} +} +case 8: +{ +lean_object* x_504; lean_object* x_505; lean_object* x_506; lean_object* x_507; lean_object* x_508; lean_object* x_586; uint8_t x_612; +x_504 = lean_ctor_get(x_1, 1); +lean_inc(x_504); +x_505 = lean_ctor_get(x_1, 2); +lean_inc(x_505); +x_506 = lean_ctor_get(x_1, 3); +lean_inc(x_506); +x_612 = l_Lean_Expr_hasLevelParam(x_504); +if (x_612 == 0) +{ +uint8_t x_613; +x_613 = l_Lean_Expr_hasFVar(x_504); +if (x_613 == 0) +{ +uint8_t x_614; +x_614 = l_Lean_Expr_hasMVar(x_504); +if (x_614 == 0) +{ +x_507 = x_504; +x_508 = x_3; +goto block_585; +} +else +{ +lean_object* x_615; +x_615 = lean_box(0); +x_586 = x_615; +goto block_611; +} +} +else +{ +lean_object* x_616; +x_616 = lean_box(0); +x_586 = x_616; +goto block_611; +} +} +else +{ +lean_object* x_617; +x_617 = lean_box(0); +x_586 = x_617; +goto block_611; +} +block_585: +{ +lean_object* x_509; lean_object* x_510; lean_object* x_553; uint8_t x_579; +x_579 = l_Lean_Expr_hasLevelParam(x_505); +if (x_579 == 0) +{ +uint8_t x_580; +x_580 = l_Lean_Expr_hasFVar(x_505); +if (x_580 == 0) +{ +uint8_t x_581; +x_581 = l_Lean_Expr_hasMVar(x_505); +if (x_581 == 0) +{ +x_509 = x_505; +x_510 = x_508; +goto block_552; +} +else +{ +lean_object* x_582; +x_582 = lean_box(0); +x_553 = x_582; +goto block_578; +} +} +else +{ +lean_object* x_583; +x_583 = lean_box(0); +x_553 = x_583; +goto block_578; +} +} +else +{ +lean_object* x_584; +x_584 = lean_box(0); +x_553 = x_584; +goto block_578; +} +block_552: +{ +lean_object* x_511; lean_object* x_512; lean_object* x_520; uint8_t x_546; +x_546 = l_Lean_Expr_hasLevelParam(x_506); +if (x_546 == 0) +{ +uint8_t x_547; +x_547 = l_Lean_Expr_hasFVar(x_506); +if (x_547 == 0) +{ +uint8_t x_548; +x_548 = l_Lean_Expr_hasMVar(x_506); +if (x_548 == 0) +{ +lean_dec(x_2); +x_511 = x_506; +x_512 = x_510; +goto block_519; +} +else +{ +lean_object* x_549; +x_549 = lean_box(0); +x_520 = x_549; +goto block_545; +} +} +else +{ +lean_object* x_550; +x_550 = lean_box(0); +x_520 = x_550; +goto block_545; +} +} +else +{ +lean_object* x_551; +x_551 = lean_box(0); +x_520 = x_551; +goto block_545; +} +block_519: +{ +if (lean_obj_tag(x_1) == 8) +{ +lean_object* x_513; lean_object* x_514; +x_513 = lean_expr_update_let(x_1, x_507, x_509, x_511); +x_514 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_514, 0, x_513); +lean_ctor_set(x_514, 1, x_512); +return x_514; +} +else +{ +lean_object* x_515; lean_object* x_516; lean_object* x_517; lean_object* x_518; +lean_dec(x_511); +lean_dec(x_509); +lean_dec(x_507); +lean_dec(x_1); +x_515 = l_Lean_Expr_Inhabited; +x_516 = l_Lean_Expr_updateLet_x21___closed__1; +x_517 = lean_panic_fn(x_515, x_516); +x_518 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_518, 0, x_517); +lean_ctor_set(x_518, 1, x_512); +return x_518; +} +} +block_545: +{ +lean_object* x_521; lean_object* x_522; +lean_dec(x_520); +x_521 = lean_ctor_get(x_510, 3); +lean_inc(x_521); +x_522 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_521, x_506); +lean_dec(x_521); +if (lean_obj_tag(x_522) == 0) +{ +lean_object* x_523; +lean_inc(x_506); +x_523 = l_Lean_Closure_collectExprAux___main(x_506, x_2, x_510); +if (lean_obj_tag(x_523) == 0) +{ +lean_object* x_524; lean_object* x_525; uint8_t x_526; +x_524 = lean_ctor_get(x_523, 1); +lean_inc(x_524); +x_525 = lean_ctor_get(x_523, 0); +lean_inc(x_525); +lean_dec(x_523); +x_526 = !lean_is_exclusive(x_524); +if (x_526 == 0) +{ +lean_object* x_527; lean_object* x_528; +x_527 = lean_ctor_get(x_524, 3); +lean_inc(x_525); +x_528 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_527, x_506, x_525); +lean_ctor_set(x_524, 3, x_528); +x_511 = x_525; +x_512 = x_524; +goto block_519; +} +else +{ +lean_object* x_529; lean_object* x_530; lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; +x_529 = lean_ctor_get(x_524, 0); +x_530 = lean_ctor_get(x_524, 1); +x_531 = lean_ctor_get(x_524, 2); +x_532 = lean_ctor_get(x_524, 3); +x_533 = lean_ctor_get(x_524, 4); +x_534 = lean_ctor_get(x_524, 5); +x_535 = lean_ctor_get(x_524, 6); +x_536 = lean_ctor_get(x_524, 7); +x_537 = lean_ctor_get(x_524, 8); +lean_inc(x_537); +lean_inc(x_536); +lean_inc(x_535); +lean_inc(x_534); +lean_inc(x_533); +lean_inc(x_532); +lean_inc(x_531); +lean_inc(x_530); +lean_inc(x_529); +lean_dec(x_524); +lean_inc(x_525); +x_538 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_532, x_506, x_525); +x_539 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_539, 0, x_529); +lean_ctor_set(x_539, 1, x_530); +lean_ctor_set(x_539, 2, x_531); +lean_ctor_set(x_539, 3, x_538); +lean_ctor_set(x_539, 4, x_533); +lean_ctor_set(x_539, 5, x_534); +lean_ctor_set(x_539, 6, x_535); +lean_ctor_set(x_539, 7, x_536); +lean_ctor_set(x_539, 8, x_537); +x_511 = x_525; +x_512 = x_539; +goto block_519; +} +} +else +{ +uint8_t x_540; +lean_dec(x_509); +lean_dec(x_507); +lean_dec(x_506); +lean_dec(x_1); +x_540 = !lean_is_exclusive(x_523); +if (x_540 == 0) +{ +return x_523; +} +else +{ +lean_object* x_541; lean_object* x_542; lean_object* x_543; +x_541 = lean_ctor_get(x_523, 0); +x_542 = lean_ctor_get(x_523, 1); +lean_inc(x_542); +lean_inc(x_541); +lean_dec(x_523); +x_543 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_543, 0, x_541); +lean_ctor_set(x_543, 1, x_542); +return x_543; +} +} +} +else +{ +lean_object* x_544; +lean_dec(x_506); +lean_dec(x_2); +x_544 = lean_ctor_get(x_522, 0); +lean_inc(x_544); +lean_dec(x_522); +x_511 = x_544; +x_512 = x_510; +goto block_519; +} +} +} +block_578: +{ +lean_object* x_554; lean_object* x_555; +lean_dec(x_553); +x_554 = lean_ctor_get(x_508, 3); +lean_inc(x_554); +x_555 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_554, x_505); +lean_dec(x_554); +if (lean_obj_tag(x_555) == 0) +{ +lean_object* x_556; +lean_inc(x_2); +lean_inc(x_505); +x_556 = l_Lean_Closure_collectExprAux___main(x_505, x_2, x_508); +if (lean_obj_tag(x_556) == 0) +{ +lean_object* x_557; lean_object* x_558; uint8_t x_559; +x_557 = lean_ctor_get(x_556, 1); +lean_inc(x_557); +x_558 = lean_ctor_get(x_556, 0); +lean_inc(x_558); +lean_dec(x_556); +x_559 = !lean_is_exclusive(x_557); +if (x_559 == 0) +{ +lean_object* x_560; lean_object* x_561; +x_560 = lean_ctor_get(x_557, 3); +lean_inc(x_558); +x_561 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_560, x_505, x_558); +lean_ctor_set(x_557, 3, x_561); +x_509 = x_558; +x_510 = x_557; +goto block_552; +} +else +{ +lean_object* x_562; lean_object* x_563; lean_object* x_564; lean_object* x_565; lean_object* x_566; lean_object* x_567; lean_object* x_568; lean_object* x_569; lean_object* x_570; lean_object* x_571; lean_object* x_572; +x_562 = lean_ctor_get(x_557, 0); +x_563 = lean_ctor_get(x_557, 1); +x_564 = lean_ctor_get(x_557, 2); +x_565 = lean_ctor_get(x_557, 3); +x_566 = lean_ctor_get(x_557, 4); +x_567 = lean_ctor_get(x_557, 5); +x_568 = lean_ctor_get(x_557, 6); +x_569 = lean_ctor_get(x_557, 7); +x_570 = lean_ctor_get(x_557, 8); +lean_inc(x_570); +lean_inc(x_569); +lean_inc(x_568); +lean_inc(x_567); +lean_inc(x_566); +lean_inc(x_565); +lean_inc(x_564); +lean_inc(x_563); +lean_inc(x_562); +lean_dec(x_557); +lean_inc(x_558); +x_571 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_565, x_505, x_558); +x_572 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_572, 0, x_562); +lean_ctor_set(x_572, 1, x_563); +lean_ctor_set(x_572, 2, x_564); +lean_ctor_set(x_572, 3, x_571); +lean_ctor_set(x_572, 4, x_566); +lean_ctor_set(x_572, 5, x_567); +lean_ctor_set(x_572, 6, x_568); +lean_ctor_set(x_572, 7, x_569); +lean_ctor_set(x_572, 8, x_570); +x_509 = x_558; +x_510 = x_572; +goto block_552; +} +} +else +{ +uint8_t x_573; +lean_dec(x_507); +lean_dec(x_506); +lean_dec(x_505); +lean_dec(x_2); +lean_dec(x_1); +x_573 = !lean_is_exclusive(x_556); +if (x_573 == 0) +{ +return x_556; +} +else +{ +lean_object* x_574; lean_object* x_575; lean_object* x_576; +x_574 = lean_ctor_get(x_556, 0); +x_575 = lean_ctor_get(x_556, 1); +lean_inc(x_575); +lean_inc(x_574); +lean_dec(x_556); +x_576 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_576, 0, x_574); +lean_ctor_set(x_576, 1, x_575); +return x_576; +} +} +} +else +{ +lean_object* x_577; +lean_dec(x_505); +x_577 = lean_ctor_get(x_555, 0); +lean_inc(x_577); +lean_dec(x_555); +x_509 = x_577; +x_510 = x_508; +goto block_552; +} +} +} +block_611: +{ +lean_object* x_587; lean_object* x_588; +lean_dec(x_586); +x_587 = lean_ctor_get(x_3, 3); +lean_inc(x_587); +x_588 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_587, x_504); +lean_dec(x_587); +if (lean_obj_tag(x_588) == 0) +{ +lean_object* x_589; +lean_inc(x_2); +lean_inc(x_504); +x_589 = l_Lean_Closure_collectExprAux___main(x_504, x_2, x_3); +if (lean_obj_tag(x_589) == 0) +{ +lean_object* x_590; lean_object* x_591; uint8_t x_592; +x_590 = lean_ctor_get(x_589, 1); +lean_inc(x_590); +x_591 = lean_ctor_get(x_589, 0); +lean_inc(x_591); +lean_dec(x_589); +x_592 = !lean_is_exclusive(x_590); +if (x_592 == 0) +{ +lean_object* x_593; lean_object* x_594; +x_593 = lean_ctor_get(x_590, 3); +lean_inc(x_591); +x_594 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_593, x_504, x_591); +lean_ctor_set(x_590, 3, x_594); +x_507 = x_591; +x_508 = x_590; +goto block_585; +} +else +{ +lean_object* x_595; lean_object* x_596; lean_object* x_597; lean_object* x_598; lean_object* x_599; lean_object* x_600; lean_object* x_601; lean_object* x_602; lean_object* x_603; lean_object* x_604; lean_object* x_605; +x_595 = lean_ctor_get(x_590, 0); +x_596 = lean_ctor_get(x_590, 1); +x_597 = lean_ctor_get(x_590, 2); +x_598 = lean_ctor_get(x_590, 3); +x_599 = lean_ctor_get(x_590, 4); +x_600 = lean_ctor_get(x_590, 5); +x_601 = lean_ctor_get(x_590, 6); +x_602 = lean_ctor_get(x_590, 7); +x_603 = lean_ctor_get(x_590, 8); +lean_inc(x_603); +lean_inc(x_602); +lean_inc(x_601); +lean_inc(x_600); +lean_inc(x_599); +lean_inc(x_598); +lean_inc(x_597); +lean_inc(x_596); +lean_inc(x_595); +lean_dec(x_590); +lean_inc(x_591); +x_604 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_598, x_504, x_591); +x_605 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_605, 0, x_595); +lean_ctor_set(x_605, 1, x_596); +lean_ctor_set(x_605, 2, x_597); +lean_ctor_set(x_605, 3, x_604); +lean_ctor_set(x_605, 4, x_599); +lean_ctor_set(x_605, 5, x_600); +lean_ctor_set(x_605, 6, x_601); +lean_ctor_set(x_605, 7, x_602); +lean_ctor_set(x_605, 8, x_603); +x_507 = x_591; +x_508 = x_605; +goto block_585; +} +} +else +{ +uint8_t x_606; +lean_dec(x_506); +lean_dec(x_505); +lean_dec(x_504); +lean_dec(x_2); +lean_dec(x_1); +x_606 = !lean_is_exclusive(x_589); +if (x_606 == 0) +{ +return x_589; +} +else +{ +lean_object* x_607; lean_object* x_608; lean_object* x_609; +x_607 = lean_ctor_get(x_589, 0); +x_608 = lean_ctor_get(x_589, 1); +lean_inc(x_608); +lean_inc(x_607); +lean_dec(x_589); +x_609 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_609, 0, x_607); +lean_ctor_set(x_609, 1, x_608); +return x_609; +} +} +} +else +{ +lean_object* x_610; +lean_dec(x_504); +x_610 = lean_ctor_get(x_588, 0); +lean_inc(x_610); +lean_dec(x_588); +x_507 = x_610; +x_508 = x_3; +goto block_585; +} +} +} +case 10: +{ +lean_object* x_618; lean_object* x_619; uint8_t x_645; +x_618 = lean_ctor_get(x_1, 1); +lean_inc(x_618); +x_645 = l_Lean_Expr_hasLevelParam(x_618); +if (x_645 == 0) +{ +uint8_t x_646; +x_646 = l_Lean_Expr_hasFVar(x_618); +if (x_646 == 0) +{ +uint8_t x_647; +x_647 = l_Lean_Expr_hasMVar(x_618); +if (x_647 == 0) +{ +lean_dec(x_2); +x_4 = x_618; +x_5 = x_3; +goto block_12; +} +else +{ +lean_object* x_648; +x_648 = lean_box(0); +x_619 = x_648; +goto block_644; +} +} +else +{ +lean_object* x_649; +x_649 = lean_box(0); +x_619 = x_649; +goto block_644; +} +} +else +{ +lean_object* x_650; +x_650 = lean_box(0); +x_619 = x_650; +goto block_644; +} +block_644: +{ +lean_object* x_620; lean_object* x_621; +lean_dec(x_619); +x_620 = lean_ctor_get(x_3, 3); +lean_inc(x_620); +x_621 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_620, x_618); +lean_dec(x_620); +if (lean_obj_tag(x_621) == 0) +{ +lean_object* x_622; +lean_inc(x_618); +x_622 = l_Lean_Closure_collectExprAux___main(x_618, x_2, x_3); +if (lean_obj_tag(x_622) == 0) +{ +lean_object* x_623; lean_object* x_624; uint8_t x_625; +x_623 = lean_ctor_get(x_622, 1); +lean_inc(x_623); +x_624 = lean_ctor_get(x_622, 0); +lean_inc(x_624); +lean_dec(x_622); +x_625 = !lean_is_exclusive(x_623); +if (x_625 == 0) +{ +lean_object* x_626; lean_object* x_627; +x_626 = lean_ctor_get(x_623, 3); +lean_inc(x_624); +x_627 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_626, x_618, x_624); +lean_ctor_set(x_623, 3, x_627); +x_4 = x_624; +x_5 = x_623; +goto block_12; +} +else +{ +lean_object* x_628; lean_object* x_629; lean_object* x_630; lean_object* x_631; lean_object* x_632; lean_object* x_633; lean_object* x_634; lean_object* x_635; lean_object* x_636; lean_object* x_637; lean_object* x_638; +x_628 = lean_ctor_get(x_623, 0); +x_629 = lean_ctor_get(x_623, 1); +x_630 = lean_ctor_get(x_623, 2); +x_631 = lean_ctor_get(x_623, 3); +x_632 = lean_ctor_get(x_623, 4); +x_633 = lean_ctor_get(x_623, 5); +x_634 = lean_ctor_get(x_623, 6); +x_635 = lean_ctor_get(x_623, 7); +x_636 = lean_ctor_get(x_623, 8); +lean_inc(x_636); +lean_inc(x_635); +lean_inc(x_634); +lean_inc(x_633); +lean_inc(x_632); +lean_inc(x_631); +lean_inc(x_630); +lean_inc(x_629); +lean_inc(x_628); +lean_dec(x_623); +lean_inc(x_624); +x_637 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_631, x_618, x_624); +x_638 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_638, 0, x_628); +lean_ctor_set(x_638, 1, x_629); +lean_ctor_set(x_638, 2, x_630); +lean_ctor_set(x_638, 3, x_637); +lean_ctor_set(x_638, 4, x_632); +lean_ctor_set(x_638, 5, x_633); +lean_ctor_set(x_638, 6, x_634); +lean_ctor_set(x_638, 7, x_635); +lean_ctor_set(x_638, 8, x_636); +x_4 = x_624; +x_5 = x_638; +goto block_12; +} +} +else +{ +uint8_t x_639; +lean_dec(x_618); +lean_dec(x_1); +x_639 = !lean_is_exclusive(x_622); +if (x_639 == 0) +{ +return x_622; +} +else +{ +lean_object* x_640; lean_object* x_641; lean_object* x_642; +x_640 = lean_ctor_get(x_622, 0); +x_641 = lean_ctor_get(x_622, 1); +lean_inc(x_641); +lean_inc(x_640); +lean_dec(x_622); +x_642 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_642, 0, x_640); +lean_ctor_set(x_642, 1, x_641); +return x_642; +} +} +} +else +{ +lean_object* x_643; +lean_dec(x_618); +lean_dec(x_2); +x_643 = lean_ctor_get(x_621, 0); +lean_inc(x_643); +lean_dec(x_621); +x_4 = x_643; +x_5 = x_3; +goto block_12; +} +} +} +case 11: +{ +lean_object* x_651; lean_object* x_652; uint8_t x_678; +x_651 = lean_ctor_get(x_1, 2); +lean_inc(x_651); +x_678 = l_Lean_Expr_hasLevelParam(x_651); +if (x_678 == 0) +{ +uint8_t x_679; +x_679 = l_Lean_Expr_hasFVar(x_651); +if (x_679 == 0) +{ +uint8_t x_680; +x_680 = l_Lean_Expr_hasMVar(x_651); +if (x_680 == 0) +{ +lean_dec(x_2); +x_13 = x_651; +x_14 = x_3; +goto block_21; +} +else +{ +lean_object* x_681; +x_681 = lean_box(0); +x_652 = x_681; +goto block_677; +} +} +else +{ +lean_object* x_682; +x_682 = lean_box(0); +x_652 = x_682; +goto block_677; +} +} +else +{ +lean_object* x_683; +x_683 = lean_box(0); +x_652 = x_683; +goto block_677; +} +block_677: +{ +lean_object* x_653; lean_object* x_654; +lean_dec(x_652); +x_653 = lean_ctor_get(x_3, 3); +lean_inc(x_653); +x_654 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_653, x_651); +lean_dec(x_653); +if (lean_obj_tag(x_654) == 0) +{ +lean_object* x_655; +lean_inc(x_651); +x_655 = l_Lean_Closure_collectExprAux___main(x_651, x_2, x_3); +if (lean_obj_tag(x_655) == 0) +{ +lean_object* x_656; lean_object* x_657; uint8_t x_658; +x_656 = lean_ctor_get(x_655, 1); +lean_inc(x_656); +x_657 = lean_ctor_get(x_655, 0); +lean_inc(x_657); +lean_dec(x_655); +x_658 = !lean_is_exclusive(x_656); +if (x_658 == 0) +{ +lean_object* x_659; lean_object* x_660; +x_659 = lean_ctor_get(x_656, 3); +lean_inc(x_657); +x_660 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_659, x_651, x_657); +lean_ctor_set(x_656, 3, x_660); +x_13 = x_657; +x_14 = x_656; +goto block_21; +} +else +{ +lean_object* x_661; lean_object* x_662; lean_object* x_663; lean_object* x_664; lean_object* x_665; lean_object* x_666; lean_object* x_667; lean_object* x_668; lean_object* x_669; lean_object* x_670; lean_object* x_671; +x_661 = lean_ctor_get(x_656, 0); +x_662 = lean_ctor_get(x_656, 1); +x_663 = lean_ctor_get(x_656, 2); +x_664 = lean_ctor_get(x_656, 3); +x_665 = lean_ctor_get(x_656, 4); +x_666 = lean_ctor_get(x_656, 5); +x_667 = lean_ctor_get(x_656, 6); +x_668 = lean_ctor_get(x_656, 7); +x_669 = lean_ctor_get(x_656, 8); +lean_inc(x_669); +lean_inc(x_668); +lean_inc(x_667); +lean_inc(x_666); +lean_inc(x_665); +lean_inc(x_664); +lean_inc(x_663); +lean_inc(x_662); +lean_inc(x_661); +lean_dec(x_656); +lean_inc(x_657); +x_670 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_664, x_651, x_657); +x_671 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_671, 0, x_661); +lean_ctor_set(x_671, 1, x_662); +lean_ctor_set(x_671, 2, x_663); +lean_ctor_set(x_671, 3, x_670); +lean_ctor_set(x_671, 4, x_665); +lean_ctor_set(x_671, 5, x_666); +lean_ctor_set(x_671, 6, x_667); +lean_ctor_set(x_671, 7, x_668); +lean_ctor_set(x_671, 8, x_669); +x_13 = x_657; +x_14 = x_671; +goto block_21; +} +} +else +{ +uint8_t x_672; +lean_dec(x_651); +lean_dec(x_1); +x_672 = !lean_is_exclusive(x_655); +if (x_672 == 0) +{ +return x_655; +} +else +{ +lean_object* x_673; lean_object* x_674; lean_object* x_675; +x_673 = lean_ctor_get(x_655, 0); +x_674 = lean_ctor_get(x_655, 1); +lean_inc(x_674); +lean_inc(x_673); +lean_dec(x_655); +x_675 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_675, 0, x_673); +lean_ctor_set(x_675, 1, x_674); +return x_675; +} +} +} +else +{ +lean_object* x_676; +lean_dec(x_651); +lean_dec(x_2); +x_676 = lean_ctor_get(x_654, 0); +lean_inc(x_676); +lean_dec(x_654); +x_13 = x_676; +x_14 = x_3; +goto block_21; +} +} +} +default: +{ +lean_object* x_684; +lean_dec(x_2); +x_684 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_684, 0, x_1); +lean_ctor_set(x_684, 1, x_3); +return x_684; +} +} +block_12: +{ +if (lean_obj_tag(x_1) == 10) +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_expr_update_mdata(x_1, x_4); +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; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_4); +lean_dec(x_1); +x_8 = l_Lean_Expr_Inhabited; +x_9 = l_Lean_Expr_updateMData_x21___closed__2; +x_10 = lean_panic_fn(x_8, x_9); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_5); +return x_11; +} +} +block_21: +{ +if (lean_obj_tag(x_1) == 11) +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_expr_update_proj(x_1, x_13); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_14); +return x_16; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_dec(x_13); +lean_dec(x_1); +x_17 = l_Lean_Expr_Inhabited; +x_18 = l_Lean_Expr_updateProj_x21___closed__2; +x_19 = lean_panic_fn(x_17, x_18); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_14); +return x_20; +} +} +} +} +lean_object* l_List_mapM___main___at_Lean_Closure_collectExprAux___main___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_List_mapM___main___at_Lean_Closure_collectExprAux___main___spec__1(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +lean_object* l_Lean_Closure_collectExprAux(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_Closure_collectExprAux___main(x_1, x_2, x_3); +return x_4; +} +} +lean_object* l_Lean_Closure_collectExpr(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_48; +x_48 = l_Lean_Expr_hasLevelParam(x_1); +if (x_48 == 0) +{ +uint8_t x_49; +x_49 = l_Lean_Expr_hasFVar(x_1); +if (x_49 == 0) +{ +uint8_t x_50; +x_50 = l_Lean_Expr_hasMVar(x_1); +if (x_50 == 0) +{ +lean_object* x_51; +lean_dec(x_2); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_1); +lean_ctor_set(x_51, 1, x_3); +return x_51; +} +else +{ +lean_object* x_52; +x_52 = lean_box(0); +x_4 = x_52; +goto block_47; +} +} +else +{ +lean_object* x_53; +x_53 = lean_box(0); +x_4 = x_53; +goto block_47; +} +} +else +{ +lean_object* x_54; +x_54 = lean_box(0); +x_4 = x_54; +goto block_47; +} +block_47: +{ +lean_object* x_5; lean_object* x_6; +lean_dec(x_4); +x_5 = lean_ctor_get(x_3, 3); +lean_inc(x_5); +x_6 = l_HashMapImp_find_x3f___at_Lean_Closure_visitExpr___spec__1(x_5, x_1); +lean_dec(x_5); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +lean_inc(x_1); +x_7 = l_Lean_Closure_collectExprAux___main(x_1, x_2, x_3); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_7, 1); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_7, 0); +x_12 = lean_ctor_get(x_9, 3); +lean_inc(x_11); +x_13 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_12, x_1, x_11); +lean_ctor_set(x_9, 3, x_13); +return x_7; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_14 = lean_ctor_get(x_7, 0); +x_15 = lean_ctor_get(x_9, 0); +x_16 = lean_ctor_get(x_9, 1); +x_17 = lean_ctor_get(x_9, 2); +x_18 = lean_ctor_get(x_9, 3); +x_19 = lean_ctor_get(x_9, 4); +x_20 = lean_ctor_get(x_9, 5); +x_21 = lean_ctor_get(x_9, 6); +x_22 = lean_ctor_get(x_9, 7); +x_23 = lean_ctor_get(x_9, 8); +lean_inc(x_23); +lean_inc(x_22); +lean_inc(x_21); +lean_inc(x_20); +lean_inc(x_19); +lean_inc(x_18); +lean_inc(x_17); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_9); +lean_inc(x_14); +x_24 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_18, x_1, x_14); +x_25 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_25, 0, x_15); +lean_ctor_set(x_25, 1, x_16); +lean_ctor_set(x_25, 2, x_17); +lean_ctor_set(x_25, 3, x_24); +lean_ctor_set(x_25, 4, x_19); +lean_ctor_set(x_25, 5, x_20); +lean_ctor_set(x_25, 6, x_21); +lean_ctor_set(x_25, 7, x_22); +lean_ctor_set(x_25, 8, x_23); +lean_ctor_set(x_7, 1, x_25); +return x_7; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_26 = lean_ctor_get(x_7, 1); +x_27 = lean_ctor_get(x_7, 0); +lean_inc(x_26); +lean_inc(x_27); +lean_dec(x_7); +x_28 = lean_ctor_get(x_26, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_26, 1); +lean_inc(x_29); +x_30 = lean_ctor_get(x_26, 2); +lean_inc(x_30); +x_31 = lean_ctor_get(x_26, 3); +lean_inc(x_31); +x_32 = lean_ctor_get(x_26, 4); +lean_inc(x_32); +x_33 = lean_ctor_get(x_26, 5); +lean_inc(x_33); +x_34 = lean_ctor_get(x_26, 6); +lean_inc(x_34); +x_35 = lean_ctor_get(x_26, 7); +lean_inc(x_35); +x_36 = lean_ctor_get(x_26, 8); +lean_inc(x_36); +if (lean_is_exclusive(x_26)) { + lean_ctor_release(x_26, 0); + lean_ctor_release(x_26, 1); + lean_ctor_release(x_26, 2); + lean_ctor_release(x_26, 3); + lean_ctor_release(x_26, 4); + lean_ctor_release(x_26, 5); + lean_ctor_release(x_26, 6); + lean_ctor_release(x_26, 7); + lean_ctor_release(x_26, 8); + x_37 = x_26; +} else { + lean_dec_ref(x_26); + x_37 = lean_box(0); +} +lean_inc(x_27); +x_38 = l_HashMapImp_insert___at_Lean_Closure_visitExpr___spec__3(x_31, x_1, x_27); +if (lean_is_scalar(x_37)) { + x_39 = lean_alloc_ctor(0, 9, 0); +} else { + x_39 = x_37; +} +lean_ctor_set(x_39, 0, x_28); +lean_ctor_set(x_39, 1, x_29); +lean_ctor_set(x_39, 2, x_30); +lean_ctor_set(x_39, 3, x_38); +lean_ctor_set(x_39, 4, x_32); +lean_ctor_set(x_39, 5, x_33); +lean_ctor_set(x_39, 6, x_34); +lean_ctor_set(x_39, 7, x_35); +lean_ctor_set(x_39, 8, x_36); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_27); +lean_ctor_set(x_40, 1, x_39); +return x_40; +} +} +else +{ +uint8_t x_41; +lean_dec(x_1); +x_41 = !lean_is_exclusive(x_7); +if (x_41 == 0) +{ +return x_7; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_42 = lean_ctor_get(x_7, 0); +x_43 = lean_ctor_get(x_7, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_7); +x_44 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set(x_44, 1, x_43); +return x_44; +} +} +} +else +{ +lean_object* x_45; lean_object* x_46; +lean_dec(x_2); +lean_dec(x_1); +x_45 = lean_ctor_get(x_6, 0); +lean_inc(x_45); +lean_dec(x_6); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_3); +return x_46; +} +} +} +} +lean_object* l_ShareCommonT_withShareCommon___at_Lean_Closure_mkClosure___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_state_sharecommon(x_2, x_1); +return x_3; +} +} +lean_object* l_mkHashMap___at_Lean_Closure_mkClosure___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_mkHashMapImp___rarg(x_1); +return x_2; +} +} +lean_object* l_mkHashMap___at_Lean_Closure_mkClosure___spec__3(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_mkHashMapImp___rarg(x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Closure_mkClosure___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string("_closure"); +return x_1; +} +} +lean_object* _init_l_Lean_Closure_mkClosure___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lean_Closure_mkClosure___closed__1; +x_3 = lean_name_mk_string(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Closure_mkClosure___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_Closure_mkClosure___closed__2; +x_2 = lean_unsigned_to_nat(1u); +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_Closure_mkClosure___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(8u); +x_2 = l_mkHashMapImp___rarg(x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Closure_mkClosure___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(8u); +x_2 = l_mkHashMapImp___rarg(x_1); +return x_2; +} +} +lean_object* _init_l_Lean_Closure_mkClosure___closed__6() { +_start: +{ +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; +x_1 = l_Lean_LocalContext_Inhabited___closed__2; +x_2 = l_Lean_Closure_mkClosure___closed__3; +x_3 = l_Lean_Closure_mkClosure___closed__4; +x_4 = l_Lean_Closure_mkClosure___closed__5; +x_5 = l_Array_empty___closed__1; +x_6 = lean_unsigned_to_nat(1u); +x_7 = lean_alloc_ctor(0, 9, 0); +lean_ctor_set(x_7, 0, x_1); +lean_ctor_set(x_7, 1, x_2); +lean_ctor_set(x_7, 2, x_3); +lean_ctor_set(x_7, 3, x_4); +lean_ctor_set(x_7, 4, x_5); +lean_ctor_set(x_7, 5, x_6); +lean_ctor_set(x_7, 6, x_5); +lean_ctor_set(x_7, 7, x_6); +lean_ctor_set(x_7, 8, x_5); +return x_7; +} +} +lean_object* l_Lean_Closure_mkClosure(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_5 = l_ShareCommon_State_empty; +x_6 = lean_state_sharecommon(x_5, x_3); +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_state_sharecommon(x_8, x_4); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_1); +lean_ctor_set(x_30, 1, x_2); +x_31 = l_Lean_Closure_mkClosure___closed__6; +lean_inc(x_30); +x_32 = l_Lean_Closure_collectExpr(x_7, x_30, x_31); +if (lean_obj_tag(x_32) == 0) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_32, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_32, 1); +lean_inc(x_34); +lean_dec(x_32); +x_35 = l_Lean_Closure_collectExpr(x_11, x_30, x_34); +if (lean_obj_tag(x_35) == 0) +{ +uint8_t x_36; +x_36 = !lean_is_exclusive(x_35); +if (x_36 == 0) +{ +lean_object* x_37; +x_37 = lean_ctor_get(x_35, 0); +lean_ctor_set(x_9, 1, x_37); +lean_ctor_set(x_9, 0, x_33); +lean_ctor_set(x_35, 0, x_9); +x_13 = x_35; +goto block_29; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_35, 0); +x_39 = lean_ctor_get(x_35, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_35); +lean_ctor_set(x_9, 1, x_38); +lean_ctor_set(x_9, 0, x_33); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_9); +lean_ctor_set(x_40, 1, x_39); +x_13 = x_40; +goto block_29; +} +} +else +{ +uint8_t x_41; +lean_dec(x_33); +lean_free_object(x_9); +x_41 = !lean_is_exclusive(x_35); +if (x_41 == 0) +{ +x_13 = x_35; +goto block_29; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_42 = lean_ctor_get(x_35, 0); +x_43 = lean_ctor_get(x_35, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_35); +x_44 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set(x_44, 1, x_43); +x_13 = x_44; +goto block_29; +} +} +} +else +{ +uint8_t x_45; +lean_dec(x_30); +lean_free_object(x_9); +lean_dec(x_11); +x_45 = !lean_is_exclusive(x_32); +if (x_45 == 0) +{ +x_13 = x_32; +goto block_29; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_32, 0); +x_47 = lean_ctor_get(x_32, 1); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_32); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_47); +x_13 = x_48; +goto block_29; +} +} +block_29: +{ +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; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_13, 1); +lean_inc(x_15); +lean_dec(x_13); +x_16 = lean_ctor_get(x_14, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_14, 1); +lean_inc(x_17); +lean_dec(x_14); +x_18 = lean_ctor_get(x_15, 0); +lean_inc(x_18); +x_19 = l_Lean_LocalContext_getFVars(x_18); +lean_inc(x_18); +x_20 = l_Lean_LocalContext_mkForall(x_18, x_19, x_16); +lean_dec(x_16); +x_21 = l_Lean_LocalContext_mkLambda(x_18, x_19, x_17); +lean_dec(x_17); +lean_dec(x_19); +x_22 = lean_ctor_get(x_15, 4); +lean_inc(x_22); +x_23 = lean_ctor_get(x_15, 6); +lean_inc(x_23); +x_24 = lean_ctor_get(x_15, 8); +lean_inc(x_24); +lean_dec(x_15); +x_25 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_25, 0, x_22); +lean_ctor_set(x_25, 1, x_20); +lean_ctor_set(x_25, 2, x_21); +lean_ctor_set(x_25, 3, x_23); +lean_ctor_set(x_25, 4, x_24); +x_26 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_26, 0, x_25); +return x_26; +} +else +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_13, 0); +lean_inc(x_27); +lean_dec(x_13); +x_28 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_28, 0, x_27); +return x_28; +} +} +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_49 = lean_ctor_get(x_9, 0); +lean_inc(x_49); +lean_dec(x_9); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_1); +lean_ctor_set(x_67, 1, x_2); +x_68 = l_Lean_Closure_mkClosure___closed__6; +lean_inc(x_67); +x_69 = l_Lean_Closure_collectExpr(x_7, x_67, x_68); +if (lean_obj_tag(x_69) == 0) +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_69, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_69, 1); +lean_inc(x_71); +lean_dec(x_69); +x_72 = l_Lean_Closure_collectExpr(x_49, x_67, x_71); +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; +x_73 = lean_ctor_get(x_72, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_72, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_72)) { + lean_ctor_release(x_72, 0); + lean_ctor_release(x_72, 1); + x_75 = x_72; +} else { + lean_dec_ref(x_72); + x_75 = lean_box(0); +} +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_70); +lean_ctor_set(x_76, 1, x_73); +if (lean_is_scalar(x_75)) { + x_77 = lean_alloc_ctor(0, 2, 0); +} else { + x_77 = x_75; +} +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_74); +x_50 = x_77; +goto block_66; +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +lean_dec(x_70); +x_78 = lean_ctor_get(x_72, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_72, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_72)) { + lean_ctor_release(x_72, 0); + lean_ctor_release(x_72, 1); + x_80 = x_72; +} else { + lean_dec_ref(x_72); + x_80 = lean_box(0); +} +if (lean_is_scalar(x_80)) { + x_81 = lean_alloc_ctor(1, 2, 0); +} else { + x_81 = x_80; +} +lean_ctor_set(x_81, 0, x_78); +lean_ctor_set(x_81, 1, x_79); +x_50 = x_81; +goto block_66; +} +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +lean_dec(x_67); +lean_dec(x_49); +x_82 = lean_ctor_get(x_69, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_69, 1); +lean_inc(x_83); +if (lean_is_exclusive(x_69)) { + lean_ctor_release(x_69, 0); + lean_ctor_release(x_69, 1); + x_84 = x_69; +} else { + lean_dec_ref(x_69); + x_84 = lean_box(0); +} +if (lean_is_scalar(x_84)) { + x_85 = lean_alloc_ctor(1, 2, 0); +} else { + x_85 = x_84; +} +lean_ctor_set(x_85, 0, x_82); +lean_ctor_set(x_85, 1, x_83); +x_50 = x_85; +goto block_66; +} +block_66: +{ +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 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_51 = lean_ctor_get(x_50, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_50, 1); +lean_inc(x_52); +lean_dec(x_50); +x_53 = lean_ctor_get(x_51, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_51, 1); +lean_inc(x_54); +lean_dec(x_51); +x_55 = lean_ctor_get(x_52, 0); +lean_inc(x_55); +x_56 = l_Lean_LocalContext_getFVars(x_55); +lean_inc(x_55); +x_57 = l_Lean_LocalContext_mkForall(x_55, x_56, x_53); +lean_dec(x_53); +x_58 = l_Lean_LocalContext_mkLambda(x_55, x_56, x_54); +lean_dec(x_54); +lean_dec(x_56); +x_59 = lean_ctor_get(x_52, 4); +lean_inc(x_59); +x_60 = lean_ctor_get(x_52, 6); +lean_inc(x_60); +x_61 = lean_ctor_get(x_52, 8); +lean_inc(x_61); +lean_dec(x_52); +x_62 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_62, 0, x_59); +lean_ctor_set(x_62, 1, x_57); +lean_ctor_set(x_62, 2, x_58); +lean_ctor_set(x_62, 3, x_60); +lean_ctor_set(x_62, 4, x_61); +x_63 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_63, 0, x_62); +return x_63; +} +else +{ +lean_object* x_64; lean_object* x_65; +x_64 = lean_ctor_get(x_50, 0); +lean_inc(x_64); +lean_dec(x_50); +x_65 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_65, 0, x_64); +return x_65; +} +} +} +} +} +lean_object* l_Lean_mkAuxDefinition(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lean_Closure_mkClosure(x_3, x_4, x_6, x_7); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +lean_dec(x_5); +lean_dec(x_1); +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_8, 0); +x_11 = lean_alloc_ctor(11, 1, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_8, 0, x_11); +return x_8; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_8, 0); +lean_inc(x_12); +lean_dec(x_8); +x_13 = lean_alloc_ctor(11, 1, 0); +lean_ctor_set(x_13, 0, x_12); +x_14 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_14, 0, x_13); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint32_t x_22; uint32_t x_23; uint32_t x_24; lean_object* x_25; uint8_t x_26; +x_15 = lean_ctor_get(x_8, 0); +lean_inc(x_15); +lean_dec(x_8); +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +x_17 = l_Array_toList___rarg(x_16); +lean_dec(x_16); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_inc(x_18); +lean_inc(x_5); +x_19 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_19, 0, x_5); +lean_ctor_set(x_19, 1, x_17); +lean_ctor_set(x_19, 2, x_18); +x_20 = lean_ctor_get(x_15, 2); +lean_inc(x_20); +lean_inc(x_20); +lean_inc(x_1); +x_21 = l_Lean_getMaxHeight(x_1, x_20); +x_22 = lean_unbox_uint32(x_21); +lean_dec(x_21); +x_23 = 1; +x_24 = x_22 + x_23; +x_25 = lean_alloc_ctor(2, 0, 4); +lean_ctor_set_uint32(x_25, 0, x_24); +lean_inc(x_1); +x_26 = l_Lean_Environment_hasUnsafe(x_1, x_18); +if (x_26 == 0) +{ +uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_inc(x_20); +lean_inc(x_1); +x_27 = l_Lean_Environment_hasUnsafe(x_1, x_20); +x_28 = lean_alloc_ctor(0, 3, 1); +lean_ctor_set(x_28, 0, x_19); +lean_ctor_set(x_28, 1, x_20); +lean_ctor_set(x_28, 2, x_25); +lean_ctor_set_uint8(x_28, sizeof(void*)*3, x_27); +x_29 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_29, 0, x_28); +x_30 = l_Lean_Environment_addAndCompile(x_1, x_2, x_29); +lean_dec(x_29); +if (lean_obj_tag(x_30) == 0) +{ +uint8_t x_31; +lean_dec(x_15); +lean_dec(x_5); +x_31 = !lean_is_exclusive(x_30); +if (x_31 == 0) +{ +return x_30; +} +else +{ +lean_object* x_32; lean_object* x_33; +x_32 = lean_ctor_get(x_30, 0); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_33, 0, x_32); +return x_33; +} +} +else +{ +uint8_t x_34; +x_34 = !lean_is_exclusive(x_30); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_35 = lean_ctor_get(x_30, 0); +x_36 = lean_ctor_get(x_15, 3); +lean_inc(x_36); +x_37 = l_Array_toList___rarg(x_36); +lean_dec(x_36); +x_38 = l_Lean_mkConst(x_5, x_37); +x_39 = lean_ctor_get(x_15, 4); +lean_inc(x_39); +lean_dec(x_15); +x_40 = lean_unsigned_to_nat(0u); +x_41 = l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(x_39, x_39, x_40, x_38); +lean_dec(x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_35); +lean_ctor_set(x_30, 0, x_42); +return x_30; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_43 = lean_ctor_get(x_30, 0); +lean_inc(x_43); +lean_dec(x_30); +x_44 = lean_ctor_get(x_15, 3); +lean_inc(x_44); +x_45 = l_Array_toList___rarg(x_44); +lean_dec(x_44); +x_46 = l_Lean_mkConst(x_5, x_45); +x_47 = lean_ctor_get(x_15, 4); +lean_inc(x_47); +lean_dec(x_15); +x_48 = lean_unsigned_to_nat(0u); +x_49 = l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(x_47, x_47, x_48, x_46); +lean_dec(x_47); +x_50 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set(x_50, 1, x_43); +x_51 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_51, 0, x_50); +return x_51; +} +} +} +else +{ +uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = 1; +x_53 = lean_alloc_ctor(0, 3, 1); +lean_ctor_set(x_53, 0, x_19); +lean_ctor_set(x_53, 1, x_20); +lean_ctor_set(x_53, 2, x_25); +lean_ctor_set_uint8(x_53, sizeof(void*)*3, x_52); +x_54 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_54, 0, x_53); +x_55 = l_Lean_Environment_addAndCompile(x_1, x_2, x_54); +lean_dec(x_54); +if (lean_obj_tag(x_55) == 0) +{ +uint8_t x_56; +lean_dec(x_15); +lean_dec(x_5); +x_56 = !lean_is_exclusive(x_55); +if (x_56 == 0) +{ +return x_55; +} +else +{ +lean_object* x_57; lean_object* x_58; +x_57 = lean_ctor_get(x_55, 0); +lean_inc(x_57); +lean_dec(x_55); +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +return x_58; +} +} +else +{ +uint8_t x_59; +x_59 = !lean_is_exclusive(x_55); +if (x_59 == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_60 = lean_ctor_get(x_55, 0); +x_61 = lean_ctor_get(x_15, 3); +lean_inc(x_61); +x_62 = l_Array_toList___rarg(x_61); +lean_dec(x_61); +x_63 = l_Lean_mkConst(x_5, x_62); +x_64 = lean_ctor_get(x_15, 4); +lean_inc(x_64); +lean_dec(x_15); +x_65 = lean_unsigned_to_nat(0u); +x_66 = l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(x_64, x_64, x_65, x_63); +lean_dec(x_64); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_66); +lean_ctor_set(x_67, 1, x_60); +lean_ctor_set(x_55, 0, x_67); +return x_55; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_68 = lean_ctor_get(x_55, 0); +lean_inc(x_68); +lean_dec(x_55); +x_69 = lean_ctor_get(x_15, 3); +lean_inc(x_69); +x_70 = l_Array_toList___rarg(x_69); +lean_dec(x_69); +x_71 = l_Lean_mkConst(x_5, x_70); +x_72 = lean_ctor_get(x_15, 4); +lean_inc(x_72); +lean_dec(x_15); +x_73 = lean_unsigned_to_nat(0u); +x_74 = l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(x_72, x_72, x_73, x_71); +lean_dec(x_72); +x_75 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_68); +x_76 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_76, 0, x_75); +return x_76; +} +} +} +} +} +} +lean_object* l_Lean_mkAuxDefinition___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lean_mkAuxDefinition(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_2); +return x_8; +} +} +lean_object* initialize_Init_Default(lean_object*); +lean_object* initialize_Init_Lean_MetavarContext(lean_object*); +lean_object* initialize_Init_Lean_Environment(lean_object*); +lean_object* initialize_Init_Lean_Util_FoldConsts(lean_object*); +static bool _G_initialized = false; +lean_object* initialize_Init_Lean_Util_Closure(lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_mk_io_result(lean_box(0)); +_G_initialized = true; +res = initialize_Init_Default(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Init_Lean_MetavarContext(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Init_Lean_Environment(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Init_Lean_Util_FoldConsts(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lean_Closure_mkNewLevelParam___closed__1 = _init_l_Lean_Closure_mkNewLevelParam___closed__1(); +lean_mark_persistent(l_Lean_Closure_mkNewLevelParam___closed__1); +l_Lean_Closure_mkNewLevelParam___closed__2 = _init_l_Lean_Closure_mkNewLevelParam___closed__2(); +lean_mark_persistent(l_Lean_Closure_mkNewLevelParam___closed__2); +l_Lean_Closure_mkNextUserName___rarg___closed__1 = _init_l_Lean_Closure_mkNextUserName___rarg___closed__1(); +lean_mark_persistent(l_Lean_Closure_mkNextUserName___rarg___closed__1); +l_Lean_Closure_mkNextUserName___rarg___closed__2 = _init_l_Lean_Closure_mkNextUserName___rarg___closed__2(); +lean_mark_persistent(l_Lean_Closure_mkNextUserName___rarg___closed__2); +l_Lean_Closure_mkClosure___closed__1 = _init_l_Lean_Closure_mkClosure___closed__1(); +lean_mark_persistent(l_Lean_Closure_mkClosure___closed__1); +l_Lean_Closure_mkClosure___closed__2 = _init_l_Lean_Closure_mkClosure___closed__2(); +lean_mark_persistent(l_Lean_Closure_mkClosure___closed__2); +l_Lean_Closure_mkClosure___closed__3 = _init_l_Lean_Closure_mkClosure___closed__3(); +lean_mark_persistent(l_Lean_Closure_mkClosure___closed__3); +l_Lean_Closure_mkClosure___closed__4 = _init_l_Lean_Closure_mkClosure___closed__4(); +lean_mark_persistent(l_Lean_Closure_mkClosure___closed__4); +l_Lean_Closure_mkClosure___closed__5 = _init_l_Lean_Closure_mkClosure___closed__5(); +lean_mark_persistent(l_Lean_Closure_mkClosure___closed__5); +l_Lean_Closure_mkClosure___closed__6 = _init_l_Lean_Closure_mkClosure___closed__6(); +lean_mark_persistent(l_Lean_Closure_mkClosure___closed__6); +return lean_mk_io_result(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Init/Lean/Util/FoldConsts.c b/stage0/stdlib/Init/Lean/Util/FoldConsts.c index 2a4794cfc2..437ac0ec92 100644 --- a/stage0/stdlib/Init/Lean/Util/FoldConsts.c +++ b/stage0/stdlib/Init/Lean/Util/FoldConsts.c @@ -25,17 +25,16 @@ lean_object* l_Lean_Expr_FoldConstsImpl_fold___main(lean_object*); lean_object* l_Lean_Expr_FoldConstsImpl_fold___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_FoldConstsImpl_fold___main___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_FoldConstsImpl_fold___rarg(lean_object*, size_t, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Expr_FindImpl_initCache___closed__1; uint8_t l_UInt32_decLt(uint32_t, uint32_t); lean_object* l_Lean_Expr_FoldConstsImpl_initCache___closed__1; lean_object* l_Lean_Expr_foldConsts___rarg___boxed(lean_object*, lean_object*); lean_object* l_Lean_getMaxHeight(lean_object*, lean_object*); -lean_object* l_Lean_Expr_FoldConstsImpl_initCache___closed__2; extern lean_object* l_HashSet_Inhabited___closed__1; lean_object* l_Lean_Expr_foldConsts___boxed(lean_object*, lean_object*); size_t l_USize_mod(size_t, size_t); size_t lean_ptr_addr(lean_object*); lean_object* l_Lean_Expr_FoldConstsImpl_fold(lean_object*); -lean_object* lean_mk_array(lean_object*, lean_object*); lean_object* l_Lean_Expr_FoldConstsImpl_visited(lean_object*, size_t, lean_object*); lean_object* l_Lean_Expr_FoldConstsImpl_initCache; lean_object* l_Lean_Expr_FoldConstsImpl_fold___main___at_Lean_getMaxHeight___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -433,17 +432,7 @@ lean_object* _init_l_Lean_Expr_FoldConstsImpl_initCache___closed__1() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = lean_unsigned_to_nat(8192u); -x_2 = lean_box(0); -x_3 = lean_mk_array(x_1, x_2); -return x_3; -} -} -lean_object* _init_l_Lean_Expr_FoldConstsImpl_initCache___closed__2() { -_start: -{ -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Expr_FoldConstsImpl_initCache___closed__1; +x_1 = l_Lean_Expr_FindImpl_initCache___closed__1; x_2 = l_HashSet_Inhabited___closed__1; x_3 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_3, 0, x_1); @@ -455,7 +444,7 @@ lean_object* _init_l_Lean_Expr_FoldConstsImpl_initCache() { _start: { lean_object* x_1; -x_1 = l_Lean_Expr_FoldConstsImpl_initCache___closed__2; +x_1 = l_Lean_Expr_FoldConstsImpl_initCache___closed__1; return x_1; } } @@ -964,8 +953,6 @@ lean_dec_ref(res); l_Lean_Expr_FoldConstsImpl_cacheSize = _init_l_Lean_Expr_FoldConstsImpl_cacheSize(); l_Lean_Expr_FoldConstsImpl_initCache___closed__1 = _init_l_Lean_Expr_FoldConstsImpl_initCache___closed__1(); lean_mark_persistent(l_Lean_Expr_FoldConstsImpl_initCache___closed__1); -l_Lean_Expr_FoldConstsImpl_initCache___closed__2 = _init_l_Lean_Expr_FoldConstsImpl_initCache___closed__2(); -lean_mark_persistent(l_Lean_Expr_FoldConstsImpl_initCache___closed__2); l_Lean_Expr_FoldConstsImpl_initCache = _init_l_Lean_Expr_FoldConstsImpl_initCache(); lean_mark_persistent(l_Lean_Expr_FoldConstsImpl_initCache); return lean_mk_io_result(lean_box(0)); diff --git a/stage0/stdlib/Init/Lean/Util/WHNF.c b/stage0/stdlib/Init/Lean/Util/WHNF.c index 9de0b67eaf..f082a034a1 100644 --- a/stage0/stdlib/Init/Lean/Util/WHNF.c +++ b/stage0/stdlib/Init/Lean/Util/WHNF.c @@ -16,7 +16,6 @@ extern "C" { lean_object* lean_string_data(lean_object*); lean_object* l___private_Init_Lean_Util_WHNF_8__deltaBetaDefinition(lean_object*); lean_object* l_Lean_WHNF_reduceQuotRec___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_listToExpr___rarg___closed__9; lean_object* l___private_Init_Lean_Util_WHNF_3__getRecRuleFor___boxed(lean_object*, lean_object*); lean_object* l___private_Init_Lean_Util_WHNF_4__toCtorWhenK___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_getStuckMVar_x3f___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*); @@ -38,10 +37,10 @@ lean_object* l_Lean_WHNF_toCtorIfLit___closed__1; uint8_t lean_name_eq(lean_object*, lean_object*); lean_object* l_Lean_WHNF_whnfMain___main(lean_object*); lean_object* l___private_Init_Lean_Util_WHNF_1__getFirstCtor___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_Literal_type___closed__5; lean_object* l_Lean_WHNF_getStuckMVar_x3f___main___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_reduceQuotRec___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_toCtorIfLit___closed__5; +extern lean_object* l_Lean_Substring_HasQuote___closed__2; lean_object* l_Lean_WHNF_toCtorIfLit___closed__3; lean_object* l_Lean_WHNF_isRecStuck_x3f___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_whnfCore___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -75,6 +74,7 @@ lean_object* l_Lean_RecursorVal_getMajorIdx(lean_object*); lean_object* l___private_Init_Lean_Util_WHNF_9__whnfCoreUnstuck(lean_object*); lean_object* l_Lean_WHNF_whnfCore___main___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_array_fget(lean_object*, lean_object*); +extern lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__7; uint8_t lean_nat_dec_eq(lean_object*, lean_object*); lean_object* l_Lean_List_toExprAux___main___at_Lean_WHNF_toCtorIfLit___spec__1___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_reduceQuotRec___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -83,6 +83,7 @@ extern lean_object* l_Lean_charToExpr___lambda__1___closed__5; lean_object* l___private_Init_Lean_Util_WHNF_7__deltaDefinition___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_nat_sub(lean_object*, lean_object*); lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*); +extern lean_object* l_Lean_listToExpr___rarg___closed__5; lean_object* l___private_Init_Lean_Util_WHNF_4__toCtorWhenK___rarg___lambda__4___closed__1; lean_object* l_Lean_WHNF_toCtorIfLit___closed__8; uint8_t l_Lean_Expr_hasExprMVar(lean_object*); @@ -103,6 +104,7 @@ lean_object* l_Lean_Syntax_mreplace___main___rarg___lambda__1(lean_object*, lean lean_object* l_Lean_WHNF_whnfCore(lean_object*); uint8_t l_Lean_ConstantInfo_hasValue(lean_object*); lean_object* l___private_Init_Lean_Util_WHNF_9__whnfCoreUnstuck___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_WHNF_toCtorIfLit___closed__13; lean_object* l_Lean_WHNF_unfoldDefinitionAux___rarg___lambda__1(lean_object*, lean_object*); lean_object* l_Lean_WHNF_toCtorIfLit___closed__4; extern lean_object* l_Lean_Literal_type___closed__2; @@ -130,6 +132,7 @@ lean_object* l_Lean_WHNF_toCtorIfLit___closed__10; lean_object* l___private_Init_Lean_Util_WHNF_9__whnfCoreUnstuck___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Util_WHNF_5__isIdRhsApp___closed__2; lean_object* l_Lean_WHNF_unfoldDefinitionAux___rarg___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lean_Prod_hasQuote___rarg___closed__3; lean_object* l___private_Init_Lean_Util_WHNF_4__toCtorWhenK___rarg___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Util_WHNF_2__mkNullaryCtor___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_instantiate_value_lparams(lean_object*, lean_object*); @@ -157,8 +160,8 @@ lean_object* l_Lean_WHNF_isQuotRecStuck_x3f___rarg(lean_object*, lean_object*, l lean_object* l___private_Init_Lean_Util_WHNF_8__deltaBetaDefinition___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_isQuotRecStuck_x3f___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_mkSmartUnfoldingNameFor(lean_object*); -extern lean_object* l_Lean_prodToExpr___rarg___lambda__1___closed__3; lean_object* l_Lean_WHNF_whnfCore___main___rarg___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_WHNF_toCtorIfLit___closed__12; extern lean_object* l_Lean_Expr_Inhabited; lean_object* l_Lean_WHNF_whnfEasyCases(lean_object*); lean_object* lean_mk_array(lean_object*, lean_object*); @@ -169,6 +172,7 @@ lean_object* l_Lean_WHNF_isQuotRecStuck_x3f(lean_object*); lean_object* l_Lean_WHNF_isRecStuck_x3f(lean_object*); lean_object* l_Lean_WHNF_whnfMain___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Util_WHNF_4__toCtorWhenK(lean_object*); +extern lean_object* l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__4; lean_object* l_Lean_WHNF_unfoldDefinitionAux___rarg___lambda__4(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_mkNatLit(lean_object*); lean_object* l_Lean_WHNF_whnfCore___main___rarg___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -191,7 +195,6 @@ lean_object* l_Lean_WHNF_reduceQuotRec___rarg(lean_object*, lean_object*, lean_o lean_object* l_Lean_WHNF_whnfEasyCases___main___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Init_Lean_Util_WHNF_9__whnfCoreUnstuck___main___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_unfoldDefinitionAux___rarg___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_listToExpr___rarg___closed__6; lean_object* l_Array_anyRangeMAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_WHNF_whnfEasyCases___main(lean_object*); uint8_t lean_nat_dec_lt(lean_object*, lean_object*); @@ -694,8 +697,8 @@ lean_object* _init_l_Lean_WHNF_toCtorIfLit___closed__7() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Literal_type___closed__5; -x_2 = l_Lean_prodToExpr___rarg___lambda__1___closed__3; +x_1 = l_Lean_Substring_HasQuote___closed__2; +x_2 = l_Lean_Prod_hasQuote___rarg___closed__3; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } @@ -724,9 +727,9 @@ lean_object* _init_l_Lean_WHNF_toCtorIfLit___closed__10() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_listToExpr___rarg___closed__6; -x_2 = l_Lean_WHNF_toCtorIfLit___closed__9; -x_3 = l_Lean_mkApp(x_1, x_2); +x_1 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__4; +x_2 = l_Lean_listToExpr___rarg___closed__5; +x_3 = l_Lean_mkConst(x_1, x_2); return x_3; } } @@ -734,7 +737,27 @@ lean_object* _init_l_Lean_WHNF_toCtorIfLit___closed__11() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_listToExpr___rarg___closed__9; +x_1 = l_Lean_WHNF_toCtorIfLit___closed__10; +x_2 = l_Lean_WHNF_toCtorIfLit___closed__9; +x_3 = l_Lean_mkApp(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_WHNF_toCtorIfLit___closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Init_Lean_Syntax_8__quoteList___main___rarg___closed__7; +x_2 = l_Lean_listToExpr___rarg___closed__5; +x_3 = l_Lean_mkConst(x_1, x_2); +return x_3; +} +} +lean_object* _init_l_Lean_WHNF_toCtorIfLit___closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lean_WHNF_toCtorIfLit___closed__12; x_2 = l_Lean_WHNF_toCtorIfLit___closed__9; x_3 = l_Lean_mkApp(x_1, x_2); return x_3; @@ -783,8 +806,8 @@ x_12 = lean_ctor_get(x_2, 0); lean_inc(x_12); lean_dec(x_2); x_13 = lean_string_data(x_12); -x_14 = l_Lean_WHNF_toCtorIfLit___closed__10; -x_15 = l_Lean_WHNF_toCtorIfLit___closed__11; +x_14 = l_Lean_WHNF_toCtorIfLit___closed__11; +x_15 = l_Lean_WHNF_toCtorIfLit___closed__13; x_16 = l_Lean_List_toExprAux___main___at_Lean_WHNF_toCtorIfLit___spec__1(x_14, x_15, x_13); x_17 = l_Lean_WHNF_toCtorIfLit___closed__8; x_18 = l_Lean_mkApp(x_17, x_16); @@ -4107,6 +4130,10 @@ l_Lean_WHNF_toCtorIfLit___closed__10 = _init_l_Lean_WHNF_toCtorIfLit___closed__1 lean_mark_persistent(l_Lean_WHNF_toCtorIfLit___closed__10); l_Lean_WHNF_toCtorIfLit___closed__11 = _init_l_Lean_WHNF_toCtorIfLit___closed__11(); lean_mark_persistent(l_Lean_WHNF_toCtorIfLit___closed__11); +l_Lean_WHNF_toCtorIfLit___closed__12 = _init_l_Lean_WHNF_toCtorIfLit___closed__12(); +lean_mark_persistent(l_Lean_WHNF_toCtorIfLit___closed__12); +l_Lean_WHNF_toCtorIfLit___closed__13 = _init_l_Lean_WHNF_toCtorIfLit___closed__13(); +lean_mark_persistent(l_Lean_WHNF_toCtorIfLit___closed__13); l___private_Init_Lean_Util_WHNF_4__toCtorWhenK___rarg___lambda__4___closed__1 = _init_l___private_Init_Lean_Util_WHNF_4__toCtorWhenK___rarg___lambda__4___closed__1(); lean_mark_persistent(l___private_Init_Lean_Util_WHNF_4__toCtorWhenK___rarg___lambda__4___closed__1); l___private_Init_Lean_Util_WHNF_5__isIdRhsApp___closed__1 = _init_l___private_Init_Lean_Util_WHNF_5__isIdRhsApp___closed__1(); diff --git a/stage0/stdlib/Init/System/IO.c b/stage0/stdlib/Init/System/IO.c index 7f5bc861fc..e062602c57 100644 --- a/stage0/stdlib/Init/System/IO.c +++ b/stage0/stdlib/Init/System/IO.c @@ -14,14 +14,15 @@ extern "C" { #endif lean_object* l_IO_FS_Handle_putStrLn___rarg(lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_IOUnit_HasEval(lean_object*, lean_object*); lean_object* l___private_Init_System_IO_1__putStr(lean_object*, lean_object*); lean_object* l_allocprof___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_IO_mkRef___boxed(lean_object*, lean_object*); +lean_object* l_IO_print___at_Lean_HasRepr_hasEval___spec__2___boxed(lean_object*, lean_object*); lean_object* l_IO_Ref_modify___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_IO_appPath___rarg___closed__1; lean_object* lean_io_prim_handle_get_line(lean_object*, lean_object*); lean_object* lean_io_timeit(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_IO_HasEval___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_io_prim_handle_is_eof(lean_object*, lean_object*); lean_object* l_IO_Prim_iterate___main(lean_object*, lean_object*); lean_object* l_IO_Prim_iterate___main___at_IO_FS_Handle_readToEnd___spec__4(lean_object*, lean_object*, lean_object*); @@ -31,14 +32,18 @@ lean_object* l_IO_Prim_getEnv___boxed(lean_object*, lean_object*); lean_object* lean_io_prim_put_str(lean_object*, lean_object*); lean_object* l_IO_Prim_iterate___at_IO_FS_Handle_readToEnd___spec__3___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_IO_println(lean_object*); +lean_object* l_Lean_Unit_hasEval(lean_object*); lean_object* l_IO_Prim_fopenFlags___closed__12; lean_object* l_EIO_Monad___closed__1; lean_object* l_IO_FS_Handle_read___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Unit_hasEval___rarg___boxed(lean_object*, lean_object*); lean_object* l_IO_FS_withFile___rarg(lean_object*, uint8_t, lean_object*, lean_object*); lean_object* lean_io_is_dir(lean_object*, lean_object*); +lean_object* l_IO_print___at_Lean_HasRepr_hasEval___spec__2(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_putStr___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_IO_Prim_readTextFile___boxed(lean_object*, lean_object*); lean_object* lean_io_prim_handle_put_str(lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_hasEval___spec__3___boxed(lean_object*, lean_object*); lean_object* l_IO_getEnv___rarg(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_getLine___rarg(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_mk___boxed(lean_object*, lean_object*); @@ -52,6 +57,7 @@ lean_object* lean_io_ref_get(lean_object*, lean_object*); lean_object* l_IO_print(lean_object*, lean_object*); lean_object* l_IO_Prim_Ref_set___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_IO_FS_Handle_flush___rarg(lean_object*, lean_object*); +extern lean_object* l_Unit_HasRepr___closed__1; lean_object* l_IO_Ref_get___boxed(lean_object*, lean_object*); lean_object* l_IO_Ref_modify___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_IO_Prim_Handle_mk___boxed(lean_object*, lean_object*, lean_object*); @@ -64,6 +70,7 @@ lean_object* l_EIO_MonadExcept___closed__1; uint32_t l_IO_AccessRight_flags___closed__6; lean_object* l_IO_FS_Handle_readToEnd___rarg(lean_object*, lean_object*); extern lean_object* l_String_splitAux___main___closed__1; +lean_object* l_Lean_Unit_hasEval___boxed(lean_object*); lean_object* l_IO_isDir(lean_object*, lean_object*); lean_object* l_IO_Ref_swap___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_EIO_Inhabited(lean_object*, lean_object*); @@ -71,17 +78,16 @@ lean_object* l_IO_FS_Handle_putStr___boxed(lean_object*, lean_object*); lean_object* l_EIO_adaptExcept___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_IO_Prim_fopenFlags___closed__11; lean_object* l_IO_FS_Handle_getByte(lean_object*, lean_object*); -lean_object* l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_HasEval___spec__3___boxed(lean_object*, lean_object*); lean_object* lean_io_getenv(lean_object*, lean_object*); uint32_t l_IO_AccessRight_flags___closed__13; lean_object* l_IO_FS_Handle_isEof___at_IO_FS_Handle_readToEnd___spec__1(lean_object*, lean_object*); lean_object* l_IO_setAccessRights(lean_object*, lean_object*, lean_object*); lean_object* l_IO_Ref_get___rarg(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_HasRepr_HasEval(lean_object*); lean_object* l_IO_Prim_iterate___at_IO_FS_Handle_readToEnd___spec__3(lean_object*, lean_object*, lean_object*); lean_object* l_IO_FS_Handle_putByte___rarg___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_IO_readTextFile___rarg(lean_object*, lean_object*); lean_object* l_IO_Prim_Handle_isEof___boxed(lean_object*, lean_object*); +lean_object* l_Lean_HasRepr_hasEval___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_IO_FS_Handle_getLine___boxed(lean_object*, lean_object*); uint32_t l_IO_AccessRight_flags___closed__8; lean_object* l_EIO_Inhabited___rarg(lean_object*); @@ -102,11 +108,11 @@ lean_object* l_IO_Ref_set___boxed(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_putByte(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_read___rarg___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_IO_Prim_liftIO___rarg(lean_object*, lean_object*); +lean_object* l_IO_println___at_Lean_HasRepr_hasEval___spec__1(lean_object*, lean_object*); uint32_t l_IO_AccessRight_flags___closed__4; lean_object* l_EIO_MonadExcept(lean_object*); lean_object* l_IO_Prim_fopenFlags___closed__10; lean_object* l_IO_Ref_reset___rarg(lean_object*, lean_object*, lean_object*); -lean_object* l_IO_println___at_Lean_HasRepr_HasEval___spec__1(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_write___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_IO_realPath___boxed(lean_object*, lean_object*); lean_object* lean_io_realpath(lean_object*, lean_object*); @@ -125,7 +131,7 @@ lean_object* l_IO_FS_Handle_getByte___rarg(lean_object*, lean_object*); lean_object* l_IO_Prim_getLine___boxed(lean_object*); lean_object* l_IO_println___rarg___closed__1; lean_object* l_IO_initializing___boxed(lean_object*); -lean_object* l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_HasEval___spec__3(lean_object*, lean_object*); +lean_object* l_IO_println___at_Lean_HasRepr_hasEval___spec__1___boxed(lean_object*, lean_object*); lean_object* l_IO_Prim_iterate(lean_object*, lean_object*); lean_object* l_IO_Prim_iterate___rarg(lean_object*, lean_object*, lean_object*); lean_object* lean_io_prim_handle_write_byte(lean_object*, uint8_t, lean_object*); @@ -155,6 +161,7 @@ lean_object* l_IO_Prim_putStr___boxed(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_putByte___rarg(lean_object*, lean_object*, uint8_t); lean_object* l_IO_ofExcept___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_IO_Prim_fileExists___boxed(lean_object*, lean_object*); +lean_object* l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_hasEval___spec__3(lean_object*, lean_object*); lean_object* l_IO_FS_readFile___rarg___lambda__1(lean_object*, lean_object*); lean_object* l_IO_realPath(lean_object*, lean_object*); lean_object* lean_io_prim_handle_write(lean_object*, lean_object*, lean_object*); @@ -169,14 +176,12 @@ lean_object* l_IO_Prim_setAccessRights___boxed(lean_object*, lean_object*, lean_ lean_object* l_IO_isDir___rarg(lean_object*, lean_object*); lean_object* l_IO_getEnv(lean_object*, lean_object*); lean_object* l_IO_Prim_Handle_getByte___boxed(lean_object*, lean_object*); -lean_object* l_IO_print___at_Lean_HasRepr_HasEval___spec__2(lean_object*, lean_object*); lean_object* l_IO_lazyPure(lean_object*); lean_object* l_IO_FS_Handle_isEof___at_IO_FS_Handle_readToEnd___spec__1___boxed(lean_object*, lean_object*); lean_object* l_EStateM_Monad(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_mk___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_MonadExcept_orelse___at_EIO_HasOrelse___spec__1___rarg(lean_object*, lean_object*, lean_object*); lean_object* lean_io_ref_ptr_eq(lean_object*, lean_object*, lean_object*); -lean_object* l_IO_println___at_Lean_HasRepr_HasEval___spec__1___boxed(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_write___boxed(lean_object*, lean_object*); lean_object* l_IO_Prim_fopenFlags___closed__5; lean_object* l_IO_Prim_fopenFlags___closed__14; @@ -188,7 +193,6 @@ lean_object* l_IO_Prim_fopenFlags___closed__3; lean_object* lean_io_ref_swap(lean_object*, lean_object*, lean_object*); lean_object* l_IO_getEnv___boxed(lean_object*, lean_object*); lean_object* l_IO_print___boxed(lean_object*, lean_object*); -lean_object* l_IO_print___at_Lean_HasRepr_HasEval___spec__2___boxed(lean_object*, lean_object*); lean_object* l_IO_Ref_swap(lean_object*, lean_object*); lean_object* l_IO_Ref_ptrEq(lean_object*, lean_object*); lean_object* l_IO_FS_Handle_putStrLn(lean_object*); @@ -201,11 +205,11 @@ lean_object* l_IO_FS_Handle_read___rarg(lean_object*, lean_object*, lean_object* lean_object* l_IO_Ref_reset___boxed(lean_object*, lean_object*); lean_object* l_EStateM_MonadExcept___rarg(lean_object*); lean_object* l_IO_Prim_Handle_putByte___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_HasRepr_HasEval___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_EIO_MonadExcept___closed__2; lean_object* lean_io_prim_read_text_file(lean_object*, lean_object*); uint32_t l_IO_AccessRight_flags___closed__10; lean_object* l_IO_FS_Handle_getByte___boxed(lean_object*, lean_object*); +lean_object* l_Lean_Unit_hasEval___rarg(uint8_t, lean_object*); lean_object* lean_io_prim_handle_flush(lean_object*, lean_object*); uint32_t l_UInt32_lor(uint32_t, uint32_t); lean_object* l_IO_Prim_fopenFlags___closed__4; @@ -224,7 +228,7 @@ lean_object* l_EIO_Monad(lean_object*); lean_object* l___private_Init_System_IO_1__putStr___boxed(lean_object*, lean_object*); lean_object* l_IO_Prim_fopenFlags___closed__8; lean_object* l_IO_Prim_Handle_putStr___boxed(lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_IO_HasEval___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_IO_HasEval___rarg(lean_object*, lean_object*, uint8_t, lean_object*); lean_object* l_timeit___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_io_app_dir(lean_object*); lean_object* l_IO_FS_Handle_isEof___rarg(lean_object*, lean_object*); @@ -232,6 +236,7 @@ lean_object* l_IO_FS_Handle_flush(lean_object*, lean_object*); uint32_t l_IO_AccessRight_flags___closed__12; lean_object* l_IO_Prim_fopenFlags___boxed(lean_object*, lean_object*); lean_object* l_IO_mkRef___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_HasRepr_hasEval___rarg(lean_object*, lean_object*, uint8_t, lean_object*); lean_object* l_IO_Prim_fopenFlags___closed__1; lean_object* l_IO_Prim_mkRef___boxed(lean_object*, lean_object*, lean_object*); lean_object* l_IO_FS_withFile___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -259,6 +264,7 @@ uint32_t l_IO_AccessRight_flags___closed__3; lean_object* l_IO_FS_withFile(lean_object*); lean_object* l_IO_Prim_Handle_flush___boxed(lean_object*, lean_object*); lean_object* l_IO_Ref_reset(lean_object*, lean_object*); +lean_object* l_Lean_HasRepr_hasEval(lean_object*); lean_object* l_EIO_adaptExcept___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { _start: { @@ -2618,7 +2624,7 @@ lean_dec(x_5); return x_6; } } -lean_object* l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_HasEval___spec__3(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_hasEval___spec__3(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; @@ -2626,7 +2632,7 @@ x_3 = lean_io_prim_put_str(x_1, x_2); return x_3; } } -lean_object* l_IO_print___at_Lean_HasRepr_HasEval___spec__2(lean_object* x_1, lean_object* x_2) { +lean_object* l_IO_print___at_Lean_HasRepr_hasEval___spec__2(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; @@ -2634,7 +2640,7 @@ x_3 = lean_io_prim_put_str(x_1, x_2); return x_3; } } -lean_object* l_IO_println___at_Lean_HasRepr_HasEval___spec__1(lean_object* x_1, lean_object* x_2) { +lean_object* l_IO_println___at_Lean_HasRepr_hasEval___spec__1(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; @@ -2673,88 +2679,148 @@ return x_10; } } } -lean_object* l_Lean_HasRepr_HasEval___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_HasRepr_hasEval___rarg(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4) { _start: { -lean_object* x_4; lean_object* x_5; -x_4 = lean_apply_1(x_1, x_2); -x_5 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_4, x_3); -lean_dec(x_4); -return x_5; +lean_object* x_5; lean_object* x_6; +x_5 = lean_apply_1(x_1, x_2); +x_6 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_5, x_4); +lean_dec(x_5); +return x_6; } } -lean_object* l_Lean_HasRepr_HasEval(lean_object* x_1) { +lean_object* l_Lean_HasRepr_hasEval(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l_Lean_HasRepr_HasEval___rarg), 3, 0); +x_2 = lean_alloc_closure((void*)(l_Lean_HasRepr_hasEval___rarg___boxed), 4, 0); return x_2; } } -lean_object* l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_HasEval___spec__3___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_hasEval___spec__3___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_HasEval___spec__3(x_1, x_2); +x_3 = l___private_Init_System_IO_1__putStr___at_Lean_HasRepr_hasEval___spec__3(x_1, x_2); lean_dec(x_1); return x_3; } } -lean_object* l_IO_print___at_Lean_HasRepr_HasEval___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_IO_print___at_Lean_HasRepr_hasEval___spec__2___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = l_IO_print___at_Lean_HasRepr_HasEval___spec__2(x_1, x_2); +x_3 = l_IO_print___at_Lean_HasRepr_hasEval___spec__2(x_1, x_2); lean_dec(x_1); return x_3; } } -lean_object* l_IO_println___at_Lean_HasRepr_HasEval___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +lean_object* l_IO_println___at_Lean_HasRepr_hasEval___spec__1___boxed(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; -x_3 = l_IO_println___at_Lean_HasRepr_HasEval___spec__1(x_1, x_2); +x_3 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_1, x_2); lean_dec(x_1); return x_3; } } -lean_object* l_Lean_IO_HasEval___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +lean_object* l_Lean_HasRepr_hasEval___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_4; -x_4 = lean_apply_1(x_2, x_3); -if (lean_obj_tag(x_4) == 0) -{ -lean_object* x_5; lean_object* x_6; lean_object* x_7; -x_5 = lean_ctor_get(x_4, 0); -lean_inc(x_5); -x_6 = lean_ctor_get(x_4, 1); -lean_inc(x_6); -lean_dec(x_4); -x_7 = lean_apply_2(x_1, x_5, x_6); -return x_7; +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_3); +lean_dec(x_3); +x_6 = l_Lean_HasRepr_hasEval___rarg(x_1, x_2, x_5, x_4); +return x_6; } -else +} +lean_object* l_Lean_Unit_hasEval___rarg(uint8_t x_1, lean_object* x_2) { +_start: { -uint8_t x_8; -lean_dec(x_1); -x_8 = !lean_is_exclusive(x_4); -if (x_8 == 0) +if (x_1 == 0) { +lean_object* x_3; lean_object* x_4; +x_3 = l_Unit_HasRepr___closed__1; +x_4 = l_IO_println___at_Lean_HasRepr_hasEval___spec__1(x_3, x_2); return x_4; } else { -lean_object* x_9; lean_object* x_10; lean_object* x_11; -x_9 = lean_ctor_get(x_4, 0); -x_10 = lean_ctor_get(x_4, 1); -lean_inc(x_10); -lean_inc(x_9); -lean_dec(x_4); -x_11 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_11, 0, x_9); -lean_ctor_set(x_11, 1, x_10); -return x_11; +lean_object* x_5; lean_object* x_6; +x_5 = lean_box(0); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_2); +return x_6; +} +} +} +lean_object* l_Lean_Unit_hasEval(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Unit_hasEval___rarg___boxed), 2, 0); +return x_2; +} +} +lean_object* l_Lean_Unit_hasEval___rarg___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = lean_unbox(x_1); +lean_dec(x_1); +x_4 = l_Lean_Unit_hasEval___rarg(x_3, x_2); +return x_4; +} +} +lean_object* l_Lean_Unit_hasEval___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_Unit_hasEval(x_1); +lean_dec(x_1); +return x_2; +} +} +lean_object* l_Lean_IO_HasEval___rarg(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_apply_1(x_2, x_4); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +lean_dec(x_5); +x_8 = 1; +x_9 = lean_box(x_8); +x_10 = lean_apply_3(x_1, x_6, x_9, x_7); +return x_10; +} +else +{ +uint8_t x_11; +lean_dec(x_1); +x_11 = !lean_is_exclusive(x_5); +if (x_11 == 0) +{ +return x_5; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_5, 0); +x_13 = lean_ctor_get(x_5, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_5); +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; } } } @@ -2763,16 +2829,18 @@ lean_object* l_Lean_IO_HasEval(lean_object* x_1) { _start: { lean_object* x_2; -x_2 = lean_alloc_closure((void*)(l_Lean_IO_HasEval___rarg), 3, 0); +x_2 = lean_alloc_closure((void*)(l_Lean_IO_HasEval___rarg___boxed), 4, 0); return x_2; } } -lean_object* l_Lean_IOUnit_HasEval(lean_object* x_1, lean_object* x_2) { +lean_object* l_Lean_IO_HasEval___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_3; -x_3 = lean_apply_1(x_1, x_2); -return x_3; +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_3); +lean_dec(x_3); +x_6 = l_Lean_IO_HasEval___rarg(x_1, x_2, x_5, x_4); +return x_6; } } lean_object* initialize_Init_Control_EState(lean_object*); diff --git a/stage0/stdlib/Init/System/IOError.c b/stage0/stdlib/Init/System/IOError.c index e3514441bd..8429828ab1 100644 --- a/stage0/stdlib/Init/System/IOError.c +++ b/stage0/stdlib/Init/System/IOError.c @@ -89,7 +89,7 @@ lean_object* l_IO_Error_fopenErrorToString___closed__2; lean_object* l_IO_Error_toString___closed__10; lean_object* lean_mk_io_error_no_such_thing(uint32_t, lean_object*); lean_object* lean_mk_io_error_inappropriate_type(uint32_t, lean_object*); -lean_object* lean_mk_io_error_eof; +lean_object* lean_mk_io_error_eof(lean_object*); lean_object* l_IO_Error_toString___closed__13; lean_object* l_IO_Error_mkIllegalOperation___boxed(lean_object*, lean_object*); lean_object* lean_uint32_to_nat(uint32_t); @@ -105,12 +105,13 @@ lean_ctor_set(x_2, 0, x_1); return x_2; } } -lean_object* _init_lean_mk_io_error_eof() { +lean_object* lean_mk_io_error_eof(lean_object* x_1) { _start: { -lean_object* x_1; -x_1 = lean_box(17); -return x_1; +lean_object* x_2; +lean_dec(x_1); +x_2 = lean_box(17); +return x_2; } } lean_object* lean_mk_io_error_inappropriate_type_file(lean_object* x_1, uint32_t x_2, lean_object* x_3) { @@ -1317,8 +1318,6 @@ lean_dec_ref(res); res = initialize_Init_Data_String_Basic(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); -lean_mk_io_error_eof = _init_lean_mk_io_error_eof(); -lean_mark_persistent(lean_mk_io_error_eof); l___private_Init_System_IOError_1__downCaseFirst___closed__1 = _init_l___private_Init_System_IOError_1__downCaseFirst___closed__1(); lean_mark_persistent(l___private_Init_System_IOError_1__downCaseFirst___closed__1); l_IO_Error_fopenErrorToString___closed__1 = _init_l_IO_Error_fopenErrorToString___closed__1();