chore: update stage0

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

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

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

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
 

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

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

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      := "<TermElabM>",
@@ -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
 

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 -/

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⟩

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

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 :=

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

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

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
 

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

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⟩

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           => "<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

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

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

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 :=

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 {

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:
 {

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:
 {

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();

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();

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;
 }

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);

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();

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);

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;
 }

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;
 }
 }
 }

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;
 }
 }
 }

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);

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);

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);

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;
 }

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)
 {

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*);

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;
 }
 }

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);

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);

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;

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;
 }
 }

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;
 }

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);

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();

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) {

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;
 }

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();

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;
 }
 }

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);

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;
 }
 }
 }

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();

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);

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;
 }

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);

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;
 }

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);

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();

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) {

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;
 }

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;
 }

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;
 }

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();

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));

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();

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*);

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();