chore: update stage0

stage0/src/Init/Notation.lean

@@ -201,47 +201,117 @@ macro_rules
     else
       `(%[ $elems,* | List.nil ])
 
--- TODO: should be `infix:50 " matches " => fun e p => match e with | p => true | _ => false`
-macro:50 e:term:51 " matches " p:term:51 : term =>
-  `(match $e:term with | $p:term => true | _ => false)
+notation:50 e:51 " matches " p:51 => match e with | p => true | _ => false
 
 namespace Parser.Tactic
+/--
+Introduce one or more hypotheses, optionally naming and/or pattern-matching them.
+For each hypothesis to be introduced, the remaining main goal's target type must be a `let` or function type.
+* `intro` by itself introduces one anonymous hypothesis, which can be accessed by e.g. `assumption`.
+* `intro x y` introduces two hypotheses and names them. Individual hypotheses can be anonymized via `_`,
+  or matched against a pattern:
+  ```lean
+  -- ... ⊢ α × β → ...
+  intro (a, b)
+  -- ..., a : α, b : β ⊢ ...
+  ```
+* Alternatively, `intro` can be combined with pattern matching much like `fun`:
+  ```lean
+  intro
+  | n + 1, 0 => tac
+  | ...
+  ```
+-/
 syntax (name := intro) "intro " notFollowedBy("|") (colGt term:max)* : tactic
+/-- `intros x...` behaves like `intro x...`, but then keeps introducing (anonymous) hypotheses until goal is not of a function type. -/
 syntax (name := intros) "intros " (colGt (ident <|> "_"))* : tactic
+/--
+`rename t => x` renames the most recent hypothesis whose type matches `t` (which may contain placeholders) to `x`,
+or fails if no such hypothesis could be found. -/
 syntax (name := rename) "rename " term " => " ident : tactic
+/-- `revert x...` is the inverse of `intro x...`: it moves the given hypotheses into the main goal's target type. -/
 syntax (name := revert) "revert " (colGt ident)+ : tactic
+/-- `clear x...` removes the given hypotheses, or fails if there are remaining references to a hypothesis. -/
 syntax (name := clear) "clear " (colGt ident)+ : tactic
+/--
+`subst x...` substitutes each `x` with `e` in the goal if there is a hypothesis of type `x = e` or `e = x`.
+If `x` is itself a hypothesis of type `y = e` or `e = y`, `y` is substituted instead. -/
 syntax (name := subst) "subst " (colGt ident)+ : tactic
+/--
+`assumption` tries to solve the main goal using a hypothesis of compatible type, or else fails.
+Note also the `‹t›` term notation, which is a shorthand for `show t by assumption`. -/
 syntax (name := assumption) "assumption" : tactic
+/--
+`contradiction` closes the main goal if its hypotheses are "trivially contradictory".
+```lean
+example (h : False) : p := by contradiction  -- inductive type/family with no applicable constructors
+example (h : none = some true) : p := by contradiction  -- injectivity of constructors
+example (h : 2 + 2 = 3) : p := by contradiction  -- decidable false proposition
+example (h : p) (h' : ¬ p) : q := by contradiction
+example (x : Nat) (h : x ≠ x) : p := by contradiction
+```
+-/
 syntax (name := contradiction) "contradiction" : tactic
+/--
+`apply e` tries to match the current goal against the conclusion of `e`'s type.
+If it succeeds, then the tactic returns as many subgoals as the number of premises that
+have not been fixed by type inference or type class resolution.
+Non-dependent premises are added before dependent ones.
+
+The `apply` tactic uses higher-order pattern matching, type class resolution, and first-order unification with dependent types.
+-/
 syntax (name := apply) "apply " term : tactic
+/--
+`exact e` closes the main goal if its target type matches that of `e`.
+-/
 syntax (name := exact) "exact " term : tactic
+/--
+`refine e` behaves like `exact e`, except that named (`?x`) or unnamed (`?_`) holes in `e` that are not solved
+by unification with the main goal's target type are converted into new goals, using the hole's name, if any, as the goal case name.
+-/
 syntax (name := refine) "refine " term : tactic
+/-- `refine' e` behaves like `refine e`, except that unsolved placeholders (`_`) and implicit parameters are also converted into new goals. -/
 syntax (name := refine') "refine' " term : tactic
+/-- If the main goal's target type is an inductive type, `constructor` solves it with the first matching constructor, or else fails. -/
 syntax (name := constructor) "constructor" : tactic
+/--
+`case tag => tac` focuses on the goal with case name `tag` and solves it using `tac`, or else fails.
+`case tag x₁ ... xₙ => tac` additionally renames the `n` most recent hypotheses with inaccessible names to the given names. -/
 syntax (name := case) "case " ident (ident <|> "_")* " => " tacticSeq : tactic
+/-- `allGoals tac` runs `tac` on each goal, concatenating the resulting goals, if any. -/
 syntax (name := allGoals) "allGoals " tacticSeq : tactic
+/--
+`focus tac` focuses on the main goal, suppressing all other goals, and runs `tac` on it.
+Usually `· tac`, which enforces that the goal is closed by `tac`, should be preferred. -/
 syntax (name := focus) "focus " tacticSeq : tactic
+/-- `skip` does nothing. -/
 syntax (name := skip) "skip" : tactic
+/-- `done` succeeds iff there are no remaining goals. -/
 syntax (name := done) "done" : tactic
 syntax (name := traceState) "traceState" : tactic
 syntax (name := failIfSuccess) "failIfSuccess " tacticSeq : tactic
+/--
+`generalize [h :] e = x` replaces all occurrences of the term `e` in the main goal with a fresh hypothesis `x`.
+If `h` is given, `h : e = x` is introduced as well. -/
 syntax (name := generalize) "generalize " atomic(ident " : ")? term:51 " = " ident : tactic
 syntax (name := paren) "(" tacticSeq ")" : tactic
 syntax (name := withReducible) "withReducible " tacticSeq : tactic
 syntax (name := withReducibleAndInstances) "withReducibleAndInstances " tacticSeq : tactic
+/-- `first | tac | ...` runs each `tac` until one succeeds, or else fails. -/
 syntax (name := first) "first " withPosition((group(colGe "|" tacticSeq))+) : tactic
 syntax (name := rotateLeft) "rotateLeft" (num)? : tactic
 syntax (name := rotateRight) "rotateRight" (num)? : tactic
+/-- `try tac` runs `tac` and succeeds even if `tac` failed. -/
 macro "try " t:tacticSeq : tactic => `(first | $t | skip)
+/-- `tac <;> tac'` runs `tac` on the main goal and `tac'` on each produced goal, concatenating all goals produced by `tac'`. -/
 macro:1 x:tactic " <;> " y:tactic:0 : tactic => `(tactic| focus ($x:tactic; allGoals $y:tactic))
 
-syntax ("·" <|> ".") tacticSeq : tactic
-macro_rules
-  | `(tactic| ·%$dot $ts:tacticSeq) => `(tactic| {%$dot ($ts:tacticSeq) })
-
+/-- `· tac` focuses on the main goal and tries to solve it using `tac`, or else fails. -/
+macro dot:("·" <|> ".") ts:tacticSeq : tactic => `(tactic| {%$dot ($ts:tacticSeq) })
 
+/-- `rfl` is a shorthand for `exact rfl`. -/
 macro "rfl" : tactic => `(exact rfl)
+/-- `admit` is a shorthand for `exact sorry`. -/
 macro "admit" : tactic => `(exact sorry)
 macro "inferInstance" : tactic => `(exact inferInstance)
 

stage0/src/Lean/Compiler/NameMangling.lean

@@ -4,9 +4,10 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Author: Leonardo de Moura
 -/
 import Lean.Data.Name
-namespace Lean
 
-private def String.mangleAux : Nat → String.Iterator → String → String
+namespace String
+
+private def mangleAux : Nat → String.Iterator → String → String
   | 0,   it, r => r
   | i+1, it, r =>
     let c := it.curr
@@ -14,25 +15,36 @@ private def String.mangleAux : Nat → String.Iterator → String → String
       mangleAux i it.next (r.push c)
     else if c = '_' then
       mangleAux i it.next (r ++ "__")
-    else if c.toNat < 255 then
+    else if c.toNat < 0x100 then
       let n := c.toNat
       let r := r ++ "_x"
-      let r := r.push $ Nat.digitChar (n / 16)
-      let r := r.push $ Nat.digitChar (n % 16)
+      let r := r.push $ Nat.digitChar (n / 0x10)
+      let r := r.push $ Nat.digitChar (n % 0x10)
+      mangleAux i it.next r
+    else if c.toNat < 0x10000 then
+      let n := c.toNat
+      let r := r ++ "_u"
+      let r := r.push $ Nat.digitChar (n / 0x1000)
+      let n := n % 0x1000
+      let r := r.push $ Nat.digitChar (n / 0x100)
+      let n := n % 0x100
+      let r := r.push $ Nat.digitChar (n / 0x10)
+      let r := r.push $ Nat.digitChar (n % 0x10)
       mangleAux i it.next r
     else
       let n := c.toNat
-      let r := r ++ "_u"
-      let r := r.push $ Nat.digitChar (n / 4096)
-      let n := n % 4096
-      let r := r.push $ Nat.digitChar (n / 256)
-      let n := n % 256
-      let r := r.push $ Nat.digitChar (n / 16)
-      let r := r.push $ Nat.digitChar (n % 16)
+      let r := r ++ "_U"
+      let ds := Nat.toDigits 16 n
+      let r := Nat.repeat (·.push '0') (8 - ds.length) r
+      let r := ds.foldl (fun r c => r.push c) r
       mangleAux i it.next r
 
-def String.mangle (s : String) : String :=
-  String.mangleAux s.length s.mkIterator ""
+def mangle (s : String) : String :=
+  mangleAux s.length s.mkIterator ""
+
+end String
+
+namespace Lean
 
 private def Name.mangleAux : Name → String
   | Name.anonymous => ""

stage0/src/Lean/Data/Position.lean

@@ -29,6 +29,11 @@ structure FileMap where
   lines     : Array Nat
   deriving Inhabited
 
+class MonadFileMap (m : Type → Type) where
+  getFileMap : m FileMap
+
+export MonadFileMap (getFileMap)
+
 namespace FileMap
 
 partial def ofString (s : String) : FileMap :=

stage0/src/Lean/Elab.lean

@@ -29,3 +29,11 @@ import Lean.Elab.Deriving
 import Lean.Elab.DeclarationRange
 import Lean.Elab.Extra
 import Lean.Elab.GenInjective
+import Lean.Elab.BuiltinTerm
+import Lean.Elab.Arg
+import Lean.Elab.PatternVar
+import Lean.Elab.ElabRules
+import Lean.Elab.Macro
+import Lean.Elab.Notation
+import Lean.Elab.Mixfix
+import Lean.Elab.MacroRules

stage0/src/Lean/Elab/App.lean

@@ -8,6 +8,7 @@ import Lean.Parser.Term
 import Lean.Elab.Term
 import Lean.Elab.Binders
 import Lean.Elab.SyntheticMVars
+import Lean.Elab.Arg
 
 namespace Lean.Elab.Term
 open Meta
@@ -18,25 +19,10 @@ builtin_initialize elabWithoutExpectedTypeAttr : TagAttribute ←
 def hasElabWithoutExpectedType (env : Environment) (declName : Name) : Bool :=
   elabWithoutExpectedTypeAttr.hasTag env declName
 
-/--
-  Auxiliary inductive datatype for combining unelaborated syntax
-  and already elaborated expressions. It is used to elaborate applications. -/
-inductive Arg where
-  | stx  (val : Syntax)
-  | expr (val : Expr)
-  deriving Inhabited
-
 instance : ToString Arg := ⟨fun
   | Arg.stx  val => toString val
   | Arg.expr val => toString val⟩
 
-/-- Named arguments created using the notation `(x := val)` -/
-structure NamedArg where
-  ref  : Syntax := Syntax.missing
-  name : Name
-  val  : Arg
-  deriving Inhabited
-
 instance : ToString NamedArg where
   toString s := "(" ++ toString s.name ++ " := " ++ toString s.val ++ ")"
 
@@ -45,14 +31,6 @@ def throwInvalidNamedArg {α} (namedArg : NamedArg) (fn? : Option Name) : TermEl
     | some fn => throwError "invalid argument name '{namedArg.name}' for function '{fn}'"
     | none    => throwError "invalid argument name '{namedArg.name}' for function"
 
-/--
-  Add a new named argument to `namedArgs`, and throw an error if it already contains a named argument
-  with the same name. -/
-def addNamedArg (namedArgs : Array NamedArg) (namedArg : NamedArg) : TermElabM (Array NamedArg) := do
-  if namedArgs.any (namedArg.name == ·.name) then
-    throwError "argument '{namedArg.name}' was already set"
-  return namedArgs.push namedArg
-
 private def ensureArgType (f : Expr) (arg : Expr) (expectedType : Expr) : TermElabM Expr := do
   let argType ← inferType arg
   ensureHasTypeAux expectedType argType arg f
@@ -900,31 +878,6 @@ private def elabAppAux (f : Syntax) (namedArgs : Array NamedArg) (args : Array A
     else
       withRef f <| mergeFailures candidates
 
-partial def expandArgs (args : Array Syntax) (pattern := false) : TermElabM (Array NamedArg × Array Arg × Bool) := do
-  let (args, ellipsis) :=
-    if args.isEmpty then
-      (args, false)
-    else if args.back.isOfKind ``Lean.Parser.Term.ellipsis then
-      (args.pop, true)
-    else
-      (args, false)
-  let (namedArgs, args) ← args.foldlM (init := (#[], #[])) fun (namedArgs, args) stx => do
-    if stx.getKind == ``Lean.Parser.Term.namedArgument then
-      -- trailing_tparser try ("(" >> ident >> " := ") >> termParser >> ")"
-      let name := stx[1].getId.eraseMacroScopes
-      let val  := stx[3]
-      let namedArgs ← addNamedArg namedArgs { ref := stx, name := name, val := Arg.stx val }
-      return (namedArgs, args)
-    else if stx.getKind == ``Lean.Parser.Term.ellipsis then
-      throwErrorAt stx "unexpected '..'"
-    else
-      return (namedArgs, args.push $ Arg.stx stx)
-  return (namedArgs, args, ellipsis)
-
-def expandApp (stx : Syntax) (pattern := false) : TermElabM (Syntax × Array NamedArg × Array Arg × Bool) := do
-  let (namedArgs, args, ellipsis) ← expandArgs stx[1].getArgs
-  return (stx[0], namedArgs, args, ellipsis)
-
 @[builtinTermElab app] def elabApp : TermElab := fun stx expectedType? =>
   withoutPostponingUniverseConstraints do
     let (f, namedArgs, args, ellipsis) ← expandApp stx

stage0/src/Lean/Elab/Arg.lean

@@ -0,0 +1,58 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.Term
+
+namespace Lean.Elab.Term
+
+/--
+  Auxiliary inductive datatype for combining unelaborated syntax
+  and already elaborated expressions. It is used to elaborate applications. -/
+inductive Arg where
+  | stx  (val : Syntax)
+  | expr (val : Expr)
+  deriving Inhabited
+
+/-- Named arguments created using the notation `(x := val)` -/
+structure NamedArg where
+  ref  : Syntax := Syntax.missing
+  name : Name
+  val  : Arg
+  deriving Inhabited
+
+/--
+  Add a new named argument to `namedArgs`, and throw an error if it already contains a named argument
+  with the same name. -/
+def addNamedArg (namedArgs : Array NamedArg) (namedArg : NamedArg) : TermElabM (Array NamedArg) := do
+  if namedArgs.any (namedArg.name == ·.name) then
+    throwError "argument '{namedArg.name}' was already set"
+  return namedArgs.push namedArg
+
+partial def expandArgs (args : Array Syntax) (pattern := false) : TermElabM (Array NamedArg × Array Arg × Bool) := do
+  let (args, ellipsis) :=
+    if args.isEmpty then
+      (args, false)
+    else if args.back.isOfKind ``Lean.Parser.Term.ellipsis then
+      (args.pop, true)
+    else
+      (args, false)
+  let (namedArgs, args) ← args.foldlM (init := (#[], #[])) fun (namedArgs, args) stx => do
+    if stx.getKind == ``Lean.Parser.Term.namedArgument then
+      -- trailing_tparser try ("(" >> ident >> " := ") >> termParser >> ")"
+      let name := stx[1].getId.eraseMacroScopes
+      let val  := stx[3]
+      let namedArgs ← addNamedArg namedArgs { ref := stx, name := name, val := Arg.stx val }
+      return (namedArgs, args)
+    else if stx.getKind == ``Lean.Parser.Term.ellipsis then
+      throwErrorAt stx "unexpected '..'"
+    else
+      return (namedArgs, args.push $ Arg.stx stx)
+  return (namedArgs, args, ellipsis)
+
+def expandApp (stx : Syntax) (pattern := false) : TermElabM (Syntax × Array NamedArg × Array Arg × Bool) := do
+  let (namedArgs, args, ellipsis) ← expandArgs stx[1].getArgs
+  return (stx[0], namedArgs, args, ellipsis)
+
+end Lean.Elab.Term

stage0/src/Lean/Elab/Binders.lean

@@ -5,6 +5,7 @@ Authors: Leonardo de Moura
 -/
 import Lean.Elab.Quotation.Precheck
 import Lean.Elab.Term
+import Lean.Elab.BindersUtil
 import Lean.Parser.Term
 
 namespace Lean.Elab.Term
@@ -101,19 +102,6 @@ private def getBinderIds (ids : Syntax) : TermElabM (Array Syntax) :=
     else
       throwErrorAt id "identifier or `_` expected"
 
-/-
-  Recall that
-  ```
-  def typeSpec := leading_parser " : " >> termParser
-  def optType : Parser := optional typeSpec
-  ```
--/
-def expandOptType (ref : Syntax) (optType : Syntax) : Syntax :=
-  if optType.isNone then
-    mkHole ref
-  else
-    optType[0][1]
-
 private def matchBinder (stx : Syntax) : TermElabM (Array BinderView) := do
   let k := stx.getKind
   if k == `Lean.Parser.Term.simpleBinder then
@@ -195,7 +183,7 @@ def elabBinders {α} (binders : Array Syntax) (k : Array Expr → TermElabM α)
     else
       elabBindersAux binders k
 
-@[inline] def elabBinder {α} (binder : Syntax) (x : Expr → TermElabM α) : TermElabM α :=
+def elabBinder {α} (binder : Syntax) (x : Expr → TermElabM α) : TermElabM α :=
   elabBinders #[binder] fun fvars => x fvars[0]
 
 @[builtinTermElab «forall»] def elabForall : TermElab := fun stx _ =>
@@ -206,9 +194,13 @@ def elabBinders {α} (binders : Array Syntax) (k : Array Expr → TermElabM α)
       mkForallFVars xs e
   | _ => throwUnsupportedSyntax
 
-@[builtinTermElab arrow] def elabArrow : TermElab :=
-  adaptExpander fun stx => match stx with
-  | `($dom:term -> $rng) => `(forall (a : $dom), $rng)
+@[builtinTermElab arrow] def elabArrow : TermElab := fun stx _ =>
+  match stx with
+  | `($dom:term -> $rng) => do
+    -- elaborate independently from each other
+    let dom ← elabType dom
+    let rng ← elabType rng
+    mkForall (← MonadQuotation.addMacroScope `a) BinderInfo.default dom rng
   | _                    => throwUnsupportedSyntax
 
 @[builtinTermElab depArrow] def elabDepArrow : TermElab := fun stx _ =>

stage0/src/Lean/Elab/BindersUtil.lean

@@ -0,0 +1,20 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+namespace Lean.Elab.Term
+/-
+  Recall that
+  ```
+  def typeSpec := leading_parser " : " >> termParser
+  def optType : Parser := optional typeSpec
+  ```
+-/
+def expandOptType (ref : Syntax) (optType : Syntax) : Syntax :=
+  if optType.isNone then
+    mkHole ref
+  else
+    optType[0][1]
+
+end Lean.Elab.Term

stage0/src/Lean/Elab/BuiltinTerm.lean

@@ -0,0 +1,200 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.Term
+
+namespace Lean.Elab.Term
+open Meta
+
+@[builtinTermElab «prop»] def elabProp : TermElab := fun _ _ =>
+  return mkSort levelZero
+
+private def elabOptLevel (stx : Syntax) : TermElabM Level :=
+  if stx.isNone then
+    pure levelZero
+  else
+    elabLevel stx[0]
+
+@[builtinTermElab «sort»] def elabSort : TermElab := fun stx _ =>
+  return mkSort (← elabOptLevel stx[1])
+
+@[builtinTermElab «type»] def elabTypeStx : TermElab := fun stx _ =>
+  return mkSort (mkLevelSucc (← elabOptLevel stx[1]))
+
+/-
+ the method `resolveName` adds a completion point for it using the given
+    expected type. Thus, we propagate the expected type if `stx[0]` is an identifier.
+    It doesn't "hurt" if the identifier can be resolved because the expected type is not used in this case.
+    Recall that if the name resolution fails a synthetic sorry is returned.-/
+
+@[builtinTermElab «pipeCompletion»] def elabPipeCompletion : TermElab := fun stx expectedType? => do
+  let e ← elabTerm stx[0] none
+  unless e.isSorry do
+    addDotCompletionInfo stx e expectedType?
+  throwErrorAt stx[1] "invalid field notation, identifier or numeral expected"
+
+@[builtinTermElab «completion»] def elabCompletion : TermElab := fun stx expectedType? => do
+  /- `ident.` is ambiguous in Lean, we may try to be completing a declaration name or access a "field". -/
+  if stx[0].isIdent then
+    /- If we can elaborate the identifier successfully, we assume it a dot-completion. Otherwise, we treat it as
+       identifier completion with a dangling `.`.
+       Recall that the server falls back to identifier completion when dot-completion fails. -/
+    let s ← saveState
+    try
+      let e ← elabTerm stx[0] none
+      addDotCompletionInfo stx e expectedType?
+    catch _ =>
+      s.restore
+      addCompletionInfo <| CompletionInfo.id stx stx[0].getId (danglingDot := true) (← getLCtx) expectedType?
+    throwErrorAt stx[1] "invalid field notation, identifier or numeral expected"
+  else
+    elabPipeCompletion stx expectedType?
+
+@[builtinTermElab «hole»] def elabHole : TermElab := fun stx expectedType? => do
+  let mvar ← mkFreshExprMVar expectedType?
+  registerMVarErrorHoleInfo mvar.mvarId! stx
+  pure mvar
+
+@[builtinTermElab «syntheticHole»] def elabSyntheticHole : TermElab := fun stx expectedType? => do
+  let arg  := stx[1]
+  let userName := if arg.isIdent then arg.getId else Name.anonymous
+  let mkNewHole : Unit → TermElabM Expr := fun _ => do
+    let mvar ← mkFreshExprMVar expectedType? MetavarKind.syntheticOpaque userName
+    registerMVarErrorHoleInfo mvar.mvarId! stx
+    pure mvar
+  if userName.isAnonymous then
+    mkNewHole ()
+  else
+    let mctx ← getMCtx
+    match mctx.findUserName? userName with
+    | none => mkNewHole ()
+    | some mvarId =>
+      let mvar := mkMVar mvarId
+      let mvarDecl ← getMVarDecl mvarId
+      let lctx ← getLCtx
+      if mvarDecl.lctx.isSubPrefixOf lctx then
+        pure mvar
+      else match mctx.getExprAssignment? mvarId with
+      | some val =>
+        let val ← instantiateMVars val
+        if mctx.isWellFormed lctx val then
+          pure val
+        else
+          withLCtx mvarDecl.lctx mvarDecl.localInstances do
+            throwError "synthetic hole has already been defined and assigned to value incompatible with the current context{indentExpr val}"
+      | none =>
+        if mctx.isDelayedAssigned mvarId then
+          -- We can try to improve this case if needed.
+          throwError "synthetic hole has already beend defined and delayed assigned with an incompatible local context"
+        else if lctx.isSubPrefixOf mvarDecl.lctx then
+          let mvarNew ← mkNewHole ()
+          modifyMCtx fun mctx => mctx.assignExpr mvarId mvarNew
+          pure mvarNew
+        else
+          throwError "synthetic hole has already been defined with an incompatible local context"
+
+private def mkTacticMVar (type : Expr) (tacticCode : Syntax) : TermElabM Expr := do
+  let mvar ← mkFreshExprMVar type MetavarKind.syntheticOpaque
+  let mvarId := mvar.mvarId!
+  let ref ← getRef
+  let declName? ← getDeclName?
+  registerSyntheticMVar ref mvarId <| SyntheticMVarKind.tactic tacticCode (← saveContext)
+  return mvar
+
+@[builtinTermElab byTactic] def elabByTactic : TermElab := fun stx expectedType? =>
+  match expectedType? with
+  | some expectedType => mkTacticMVar expectedType stx
+  | none => throwError ("invalid 'by' tactic, expected type has not been provided")
+
+@[builtinTermElab noImplicitLambda] def elabNoImplicitLambda : TermElab := fun stx expectedType? =>
+  elabTerm stx[1] (mkNoImplicitLambdaAnnotation <$> expectedType?)
+
+@[builtinTermElab cdot] def elabBadCDot : TermElab := fun stx _ =>
+  throwError "invalid occurrence of `·` notation, it must be surrounded by parentheses (e.g. `(· + 1)`)"
+
+@[builtinTermElab strLit] def elabStrLit : TermElab := fun stx _ => do
+  match stx.isStrLit? with
+  | some val => pure $ mkStrLit val
+  | none     => throwIllFormedSyntax
+
+private def mkFreshTypeMVarFor (expectedType? : Option Expr) : TermElabM Expr := do
+  let typeMVar ← mkFreshTypeMVar MetavarKind.synthetic
+  match expectedType? with
+  | some expectedType => discard <| isDefEq expectedType typeMVar
+  | _                 => pure ()
+  return typeMVar
+
+@[builtinTermElab numLit] def elabNumLit : TermElab := fun stx expectedType? => do
+  let val ← match stx.isNatLit? with
+    | some val => pure val
+    | none     => throwIllFormedSyntax
+  let typeMVar ← mkFreshTypeMVarFor expectedType?
+  let u ← getDecLevel typeMVar
+  let mvar ← mkInstMVar (mkApp2 (Lean.mkConst ``OfNat [u]) typeMVar (mkNatLit val))
+  let r := mkApp3 (Lean.mkConst ``OfNat.ofNat [u]) typeMVar (mkNatLit val) mvar
+  registerMVarErrorImplicitArgInfo mvar.mvarId! stx r
+  return r
+
+@[builtinTermElab rawNatLit] def elabRawNatLit : TermElab :=  fun stx expectedType? => do
+  match stx[1].isNatLit? with
+  | some val => return mkNatLit val
+  | none     => throwIllFormedSyntax
+
+@[builtinTermElab scientificLit]
+def elabScientificLit : TermElab := fun stx expectedType? => do
+  match stx.isScientificLit? with
+  | none        => throwIllFormedSyntax
+  | some (m, sign, e) =>
+    let typeMVar ← mkFreshTypeMVarFor expectedType?
+    let u ← getDecLevel typeMVar
+    let mvar ← mkInstMVar (mkApp (Lean.mkConst ``OfScientific [u]) typeMVar)
+    return mkApp5 (Lean.mkConst ``OfScientific.ofScientific [u]) typeMVar mvar (mkNatLit m) (toExpr sign) (mkNatLit e)
+
+@[builtinTermElab charLit] def elabCharLit : TermElab := fun stx _ => do
+  match stx.isCharLit? with
+  | some val => return mkApp (Lean.mkConst ``Char.ofNat) (mkNatLit val.toNat)
+  | none     => throwIllFormedSyntax
+
+@[builtinTermElab quotedName] def elabQuotedName : TermElab := fun stx _ =>
+  match stx[0].isNameLit? with
+  | some val => pure $ toExpr val
+  | none     => throwIllFormedSyntax
+
+@[builtinTermElab doubleQuotedName] def elabDoubleQuotedName : TermElab := fun stx _ => do
+  match stx[1].isNameLit? with
+  | some val => toExpr (← resolveGlobalConstNoOverloadWithInfo stx[1] val)
+  | none     => throwIllFormedSyntax
+
+@[builtinTermElab typeOf] def elabTypeOf : TermElab := fun stx _ => do
+  inferType (← elabTerm stx[1] none)
+
+@[builtinTermElab ensureTypeOf] def elabEnsureTypeOf : TermElab := fun stx expectedType? =>
+  match stx[2].isStrLit? with
+  | none     => throwIllFormedSyntax
+  | some msg => do
+    let refTerm ← elabTerm stx[1] none
+    let refTermType ← inferType refTerm
+    elabTermEnsuringType stx[3] refTermType (errorMsgHeader? := msg)
+
+@[builtinTermElab ensureExpectedType] def elabEnsureExpectedType : TermElab := fun stx expectedType? =>
+  match stx[1].isStrLit? with
+  | none     => throwIllFormedSyntax
+  | some msg => elabTermEnsuringType stx[2] expectedType? (errorMsgHeader? := msg)
+
+@[builtinTermElab «open»] def elabOpen : TermElab := fun stx expectedType? => do
+  try
+    pushScope
+    let openDecls ← elabOpenDecl stx[1]
+    withTheReader Core.Context (fun ctx => { ctx with openDecls := openDecls }) do
+      elabTerm stx[3] expectedType?
+  finally
+    popScope
+
+@[builtinTermElab «set_option»] def elabSetOption : TermElab := fun stx expectedType? => do
+  let options ← Elab.elabSetOption stx[1] stx[2]
+  withTheReader Core.Context (fun ctx => { ctx with maxRecDepth := maxRecDepth.get options, options := options }) do
+    elabTerm stx[4] expectedType?
+
+end Lean.Elab.Term

stage0/src/Lean/Elab/Command.lean

@@ -177,7 +177,7 @@ def runLinters (stx : Syntax) : CommandElabM Unit := do
 protected def getCurrMacroScope : CommandElabM Nat  := do pure (← read).currMacroScope
 protected def getMainModule     : CommandElabM Name := do pure (← getEnv).mainModule
 
-@[inline] protected def withFreshMacroScope {α} (x : CommandElabM α) : CommandElabM α := do
+protected def withFreshMacroScope {α} (x : CommandElabM α) : CommandElabM α := do
   let fresh ← modifyGet (fun st => (st.nextMacroScope, { st with nextMacroScope := st.nextMacroScope + 1 }))
   withReader (fun ctx => { ctx with currMacroScope := fresh }) x
 
@@ -212,25 +212,19 @@ private def mkInfoTree (elaborator : Name) (stx : Syntax) (trees : Std.Persisten
   let s ← get
   let scope := s.scopes.head!
   let tree := InfoTree.node (Info.ofCommandInfo { elaborator, stx }) trees
-  let tree := InfoTree.context {
+  return InfoTree.context {
     env := s.env, fileMap := ctx.fileMap, mctx := {}, currNamespace := scope.currNamespace, openDecls := scope.openDecls, options := scope.opts
   } tree
-  if checkTraceOption (← getOptions) `Elab.info then
-    let fmt ← tree.format
-    trace[Elab.info] fmt
-  return tree
 
 private def elabCommandUsing (s : State) (stx : Syntax) : List (KeyedDeclsAttribute.AttributeEntry CommandElab) → CommandElabM Unit
   | []                => throwError "unexpected syntax{indentD stx}"
   | (elabFn::elabFns) =>
     catchInternalId unsupportedSyntaxExceptionId
-      (do
-        withInfoTreeContext (mkInfoTree := mkInfoTree elabFn.decl stx) <| elabFn.value stx
-        addTraceAsMessages)
-      (fun _ => do set s; addTraceAsMessages; elabCommandUsing s stx elabFns)
+      (withInfoTreeContext (mkInfoTree := mkInfoTree elabFn.decl stx) <| elabFn.value stx)
+      (fun _ => do set s; elabCommandUsing s stx elabFns)
 
 /- Elaborate `x` with `stx` on the macro stack -/
-@[inline] def withMacroExpansion {α} (beforeStx afterStx : Syntax) (x : CommandElabM α) : CommandElabM α :=
+def withMacroExpansion {α} (beforeStx afterStx : Syntax) (x : CommandElabM α) : CommandElabM α :=
   withReader (fun ctx => { ctx with macroStack := { before := beforeStx, after := afterStx } :: ctx.macroStack }) x
 
 instance : MonadMacroAdapter CommandElabM where
@@ -248,7 +242,7 @@ register_builtin_option showPartialSyntaxErrors : Bool := {
   descr    := "show elaboration errors from partial syntax trees (i.e. after parser recovery)"
 }
 
-@[inline] def withLogging (x : CommandElabM Unit) : CommandElabM Unit := do
+def withLogging (x : CommandElabM Unit) : CommandElabM Unit := do
   try
     x
   catch ex => match ex with
@@ -263,9 +257,7 @@ register_builtin_option showPartialSyntaxErrors : Bool := {
 builtin_initialize registerTraceClass `Elab.command
 
 partial def elabCommand (stx : Syntax) : CommandElabM Unit := do
-  let initMsgs ← modifyGet fun st => (st.messages, { st with messages := {} })
   withLogging <| withRef stx <| withIncRecDepth <| withFreshMacroScope do
-    runLinters stx
     match stx with
     | Syntax.node k args =>
       if k == nullKind then
@@ -285,13 +277,36 @@ partial def elabCommand (stx : Syntax) : CommandElabM Unit := do
           | []      => throwError "elaboration function for '{k}' has not been implemented"
           | elabFns => elabCommandUsing s stx elabFns
     | _ => throwError "unexpected command"
+
+/--
+`elabCommand` wrapper that should be used for the initial invocation, not for recursive calls after
+macro expansion etc.
+-/
+def elabCommandTopLevel (stx : Syntax) : CommandElabM Unit := withRef stx do
+  let initMsgs ← modifyGet fun st => (st.messages, { st with messages := {} })
+  let initInfoTrees ← getResetInfoTrees
+  withLogging do
+    runLinters stx
+  -- We should *not* factor out `elabCommand`'s `withLogging` to here since it would make its error
+  -- recovery more coarse. In particular, If `c` in `set_option ... in $c` fails, the remaining
+  -- `end` command of the `in` macro would be skipped and the option would be leaked to the outside!
+  elabCommand stx
+
+  -- note the order: first process current messages & info trees, then add back old messages & trees,
+  -- then convert new traces to messages
   let mut msgs ← (← get).messages
   -- `stx.hasMissing` should imply `initMsgs.hasErrors`, but the latter should be cheaper to check in general
   if !showPartialSyntaxErrors.get (← getOptions) && initMsgs.hasErrors && stx.hasMissing then
     -- discard elaboration errors, except for a few important and unlikely misleading ones, on parse error
     msgs := ⟨msgs.msgs.filter fun msg =>
       msg.data.hasTag `Elab.synthPlaceholder || msg.data.hasTag `Tactic.unsolvedGoals⟩
-  modify ({ · with messages := initMsgs ++ msgs })
+  for tree in (← getInfoTrees) do
+    trace[Elab.info] (← tree.format)
+  modify fun st => { st with
+    messages := initMsgs ++ msgs
+    infoState := { st.infoState with trees := initInfoTrees ++ st.infoState.trees }
+  }
+  addTraceAsMessages
 
 /-- Adapt a syntax transformation to a regular, command-producing elaborator. -/
 def adaptExpander (exp : Syntax → CommandElabM Syntax) : CommandElab := fun stx => do
@@ -341,21 +356,17 @@ def liftTermElabM {α} (declName? : Option Name) (x : TermElabM α) : CommandEla
   let scope := s.scopes.head!
   -- We execute `x` with an empty message log. Thus, `x` cannot modify/view messages produced by previous commands.
   -- This is useful for implementing `runTermElabM` where we use `Term.resetMessageLog`
+  let x : TermElabM _  := withSaveInfoContext x
   let x : MetaM _      := (observing x).run (mkTermContext ctx s declName?) (mkTermState scope s)
   let x : CoreM _      := x.run mkMetaContext {}
   let x : EIO _ _      := x.run (mkCoreContext ctx s heartbeats) { env := s.env, ngen := s.ngen, nextMacroScope := s.nextMacroScope }
   let (((ea, termS), metaS), coreS) ← liftEIO x
-  let infoTrees        := termS.infoState.trees.map fun tree =>
-    let tree := tree.substitute termS.infoState.assignment
-    InfoTree.context {
-      env := coreS.env, fileMap := ctx.fileMap, mctx := metaS.mctx, currNamespace := scope.currNamespace, openDecls := scope.openDecls, options := scope.opts
-    } tree
   modify fun s => { s with
     env             := coreS.env
     messages        := addTraceAsMessagesCore ctx (s.messages ++ termS.messages) coreS.traceState
     nextMacroScope  := coreS.nextMacroScope
     ngen            := coreS.ngen
-    infoState.trees := s.infoState.trees.append infoTrees
+    infoState.trees := s.infoState.trees.append termS.infoState.trees
   }
   match ea with
   | Except.ok a     => pure a
@@ -455,13 +466,13 @@ private def popScopes (numScopes : Nat) : CommandElabM Unit :=
       addCompletionInfo <| CompletionInfo.endSection stx (scopes.map fun scope => scope.header)
       throwError "invalid 'end', name mismatch"
 
-@[inline] def withNamespace {α} (ns : Name) (elabFn : CommandElabM α) : CommandElabM α := do
+def withNamespace {α} (ns : Name) (elabFn : CommandElabM α) : CommandElabM α := do
   addNamespace ns
   let a ← elabFn
   modify fun s => { s with scopes := s.scopes.drop ns.getNumParts }
   pure a
 
-@[specialize] def modifyScope (f : Scope → Scope) : CommandElabM Unit :=
+def modifyScope (f : Scope → Scope) : CommandElabM Unit :=
   modify fun s => { s with
     scopes := match s.scopes with
       | h::t => f h :: t

stage0/src/Lean/Elab/DeclUtil.lean

@@ -28,7 +28,7 @@ def forallTelescopeCompatibleAux {α} (k : Array Expr → Expr → Expr → Meta
 
 /-- Given two forall-expressions `type₁` and `type₂`, ensure the first `numParams` parameters are compatible, and
     then execute `k` with the parameters and remaining types. -/
-@[inline] def forallTelescopeCompatible {α m} [Monad m] [MonadControlT MetaM m] (type₁ type₂ : Expr) (numParams : Nat) (k : Array Expr → Expr → Expr → m α) : m α :=
+def forallTelescopeCompatible {α m} [Monad m] [MonadControlT MetaM m] (type₁ type₂ : Expr) (numParams : Nat) (k : Array Expr → Expr → Expr → m α) : m α :=
   controlAt MetaM fun runInBase =>
     forallTelescopeCompatibleAux (fun xs type₁ type₂ => runInBase $ k xs type₁ type₂) numParams type₁ type₂ #[]
 

stage0/src/Lean/Elab/Do.lean

@@ -4,8 +4,8 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
 import Lean.Elab.Term
-import Lean.Elab.Binders
-import Lean.Elab.Match
+import Lean.Elab.BindersUtil
+import Lean.Elab.PatternVar
 import Lean.Elab.Quotation.Util
 import Lean.Parser.Do
 
@@ -231,8 +231,8 @@ partial def CodeBlocl.toMessageData (codeBlock : CodeBlock) : MessageData :=
   loop codeBlock.code
 
 /- Return true if the give code contains an exit point that satisfies `p` -/
-@[inline] partial def hasExitPointPred (c : Code) (p : Code → Bool) : Bool :=
-  let rec @[specialize] loop : Code → Bool
+partial def hasExitPointPred (c : Code) (p : Code → Bool) : Bool :=
+  let rec loop : Code → Bool
     | Code.decl _ _ k           => loop k
     | Code.reassign _ _ k       => loop k
     | Code.joinpoint _ _ b k    => loop b || loop k
@@ -1142,7 +1142,7 @@ structure Context where
 
 abbrev M := ReaderT Context TermElabM
 
-@[inline] def withNewMutableVars {α} (newVars : Array Name) (mutable : Bool) (x : M α) : M α :=
+def withNewMutableVars {α} (newVars : Array Name) (mutable : Bool) (x : M α) : M α :=
   withReader (fun ctx => if mutable then { ctx with mutableVars := insertVars ctx.mutableVars newVars } else ctx) x
 
 def checkReassignable (xs : Array Name) : M Unit := do
@@ -1161,7 +1161,7 @@ def checkNotShadowingMutable (xs : Array Name) : M Unit := do
     if ctx.mutableVars.contains x then
       throwInvalidShadowing x
 
-@[inline] def withFor {α} (x : M α) : M α :=
+def withFor {α} (x : M α) : M α :=
   withReader (fun ctx => { ctx with insideFor := true }) x
 
 structure ToForInTermResult where

stage0/src/Lean/Elab/ElabRules.lean

@@ -0,0 +1,97 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.MacroArgUtil
+
+namespace Lean.Elab.Command
+open Lean.Syntax
+open Lean.Parser.Term hiding macroArg
+
+def withExpectedType (expectedType? : Option Expr) (x : Expr → TermElabM Expr) : TermElabM Expr := do
+  Term.tryPostponeIfNoneOrMVar expectedType?
+  let some expectedType ← pure expectedType?
+    | throwError "expected type must be known"
+  x expectedType
+
+def elabElabRulesAux (doc? : Option Syntax) (attrKind : Syntax) (k : SyntaxNodeKind) (cat? expty? : Option Syntax) (alts : Array Syntax) : CommandElabM Syntax := do
+  let alts ← alts.mapM fun alt => match alt with
+    | `(matchAltExpr| | $pats,* => $rhs) => do
+      let pat := pats.elemsAndSeps[0]
+      if !pat.isQuot then
+        throwUnsupportedSyntax
+      let quoted := getQuotContent pat
+      let k' := quoted.getKind
+      if checkRuleKind k' k then
+        pure alt
+      else if k' == choiceKind then
+         match quoted.getArgs.find? fun quotAlt => checkRuleKind quotAlt.getKind k with
+         | none        => throwErrorAt alt "invalid elab_rules alternative, expected syntax node kind '{k}'"
+         | some quoted =>
+           let pat := pat.setArg 1 quoted
+           let pats := pats.elemsAndSeps.set! 0 pat
+           `(matchAltExpr| | $pats,* => $rhs)
+      else
+        throwErrorAt alt "invalid elab_rules alternative, unexpected syntax node kind '{k'}'"
+    | _ => throwUnsupportedSyntax
+  let catName ← match cat?, expty? with
+    | some cat, _ => cat.getId
+    | _, some _   => `term
+    -- TODO: infer category from quotation kind, possibly even kind of quoted syntax?
+    | _, _        => throwError "invalid elab_rules command, specify category using `elab_rules : <cat> ...`"
+  if let some expId := expty? then
+    if catName == `term then
+      `($[$doc?:docComment]? @[termElab $(← mkIdentFromRef k):ident] def elabFn : Lean.Elab.Term.TermElab :=
+        fun stx expectedType? => Lean.Elab.Command.withExpectedType expectedType? fun $expId => match stx with
+          $alts:matchAlt* | _ => throwUnsupportedSyntax)
+    else
+      throwErrorAt expId "syntax category '{catName}' does not support expected type specification"
+  else if catName == `term then
+    `($[$doc?:docComment]? @[termElab $(← mkIdentFromRef k):ident] def elabFn : Lean.Elab.Term.TermElab :=
+      fun stx _ => match stx with
+        $alts:matchAlt* | _ => throwUnsupportedSyntax)
+  else if catName == `command then
+    `($[$doc?:docComment]? @[commandElab $(← mkIdentFromRef k):ident] def elabFn : Lean.Elab.Command.CommandElab :=
+      fun $alts:matchAlt* | _ => throwUnsupportedSyntax)
+  else if catName == `tactic then
+    `($[$doc?:docComment]? @[tactic $(← mkIdentFromRef k):ident] def elabFn : Lean.Elab.Tactic.Tactic :=
+      fun $alts:matchAlt* | _ => throwUnsupportedSyntax)
+  else
+    -- We considered making the command extensible and support new user-defined categories. We think it is unnecessary.
+    -- If users want this feature, they add their own `elab_rules` macro that uses this one as a fallback.
+    throwError "unsupported syntax category '{catName}'"
+
+@[builtinCommandElab «elab_rules»] def elabElabRules : CommandElab :=
+  adaptExpander fun stx => match stx with
+  | `($[$doc?:docComment]? $attrKind:attrKind elab_rules $[: $cat?]? $[<= $expty?]? $alts:matchAlt*) =>
+    expandNoKindMacroRulesAux alts "elab_rules" fun kind? alts =>
+      `($[$doc?:docComment]? $attrKind:attrKind elab_rules $[(kind := $(mkIdent <$> kind?))]? $[: $cat?]? $[<= $expty?]? $alts:matchAlt*)
+  | `($[$doc?:docComment]? $attrKind:attrKind elab_rules (kind := $kind) $[: $cat?]? $[<= $expty?]? $alts:matchAlt*) =>
+    do elabElabRulesAux doc? attrKind (← resolveSyntaxKind kind.getId) cat? expty? alts
+  | _  => throwUnsupportedSyntax
+
+@[builtinMacro Lean.Parser.Command.elab]
+def expandElab : Macro
+  | `($[$doc?:docComment]? $attrKind:attrKind
+    elab$[:$prec?]? $[(name := $name?)]? $[(priority := $prio?)]? $head:macroArg $args:macroArg* :
+      $cat $[<= $expectedType?]? => $rhs) => do
+    let prio    ← evalOptPrio prio?
+    let catName := cat.getId
+    -- build parser
+    let stxPart  ← expandMacroArgIntoSyntaxItem head
+    let stxParts ← args.mapM expandMacroArgIntoSyntaxItem
+    let stxParts := #[stxPart] ++ stxParts
+    -- name
+    let name ← match name? with
+      | some name => pure name.getId
+      | none => mkNameFromParserSyntax cat.getId (mkNullNode stxParts)
+    -- build pattern for syntax `match`
+    let patHead ← expandMacroArgIntoPattern head
+    let patArgs ← args.mapM expandMacroArgIntoPattern
+    let pat := Syntax.node ((← Macro.getCurrNamespace) ++ name) (#[patHead] ++ patArgs)
+    `($[$doc?:docComment]? $attrKind:attrKind syntax$[:$prec?]? (name := $(← mkIdentFromRef name)) (priority := $(quote prio)) $[$stxParts]* : $cat
+      $[$doc?:docComment]? elab_rules : $cat $[<= $expectedType?]? | `($pat) => $rhs)
+  | _ => Macro.throwUnsupported
+
+end Lean.Elab.Command

stage0/src/Lean/Elab/Frontend.lean

@@ -36,7 +36,7 @@ def elabCommandAtFrontend (stx : Syntax) : FrontendM Unit := do
     let infoTreeEnabled := (← getInfoState).enabled
     if checkTraceOption (← getOptions) `Elab.info then
       enableInfoTree
-    Command.elabCommand stx
+    Command.elabCommandTopLevel stx
     enableInfoTree infoTreeEnabled
 
 def updateCmdPos : FrontendM Unit := do

stage0/src/Lean/Elab/InfoTree.lean

@@ -257,7 +257,7 @@ variable [Monad m] [MonadInfoTree m]
 @[inline] private def modifyInfoTrees (f : PersistentArray InfoTree → PersistentArray InfoTree) : m Unit :=
   modifyInfoState fun s => { s with trees := f s.trees }
 
-private def getResetInfoTrees : m (PersistentArray InfoTree) := do
+def getResetInfoTrees : m (PersistentArray InfoTree) := do
   let trees := (← getInfoState).trees
   modifyInfoTrees fun _ => {}
   return trees
@@ -287,7 +287,7 @@ def resolveGlobalConstWithInfos [MonadResolveName m] [MonadEnv m] [MonadError m]
       pushInfoLeaf <| Info.ofTermInfo { elaborator := Name.anonymous, lctx := LocalContext.empty, expr := (← mkConstWithLevelParams n), stx, expectedType? }
   return ns
 
-@[inline] def withInfoContext' [MonadFinally m] (x : m α) (mkInfo : α → m (Sum Info MVarId)) : m α := do
+def withInfoContext' [MonadFinally m] (x : m α) (mkInfo : α → m (Sum Info MVarId)) : m α := do
   if (← getInfoState).enabled then
     let treesSaved ← getResetInfoTrees
     Prod.fst <$> MonadFinally.tryFinally' x fun a? => do
@@ -302,7 +302,7 @@ def resolveGlobalConstWithInfos [MonadResolveName m] [MonadEnv m] [MonadError m]
   else
     x
 
-@[inline] def withInfoTreeContext [MonadFinally m] (x : m α) (mkInfoTree : PersistentArray InfoTree → m InfoTree) : m α := do
+def withInfoTreeContext [MonadFinally m] (x : m α) (mkInfoTree : PersistentArray InfoTree → m InfoTree) : m α := do
   if (← getInfoState).enabled then
     let treesSaved ← getResetInfoTrees
     Prod.fst <$> MonadFinally.tryFinally' x fun _ => do
@@ -315,6 +315,20 @@ def resolveGlobalConstWithInfos [MonadResolveName m] [MonadEnv m] [MonadError m]
 @[inline] def withInfoContext [MonadFinally m] (x : m α) (mkInfo : m Info) : m α := do
   withInfoTreeContext x (fun trees => do return InfoTree.node (← mkInfo) trees)
 
+def withSaveInfoContext [MonadFinally m] [MonadEnv m] [MonadOptions m] [MonadMCtx m] [MonadResolveName m] [MonadFileMap m] (x : m α) : m α := do
+  if (← getInfoState).enabled then
+    let treesSaved ← getResetInfoTrees
+    Prod.fst <$> MonadFinally.tryFinally' x fun _ => do
+      let st    ← getInfoState
+      let trees ← st.trees.mapM fun tree => do
+        let tree := tree.substitute st.assignment
+        InfoTree.context {
+          env := (← getEnv), fileMap := (← getFileMap), mctx := (← getMCtx), currNamespace := (← getCurrNamespace), openDecls := (← getOpenDecls), options := (← getOptions)
+        } tree
+      modifyInfoTrees fun _ => treesSaved ++ trees
+  else
+    x
+
 def getInfoHoleIdAssignment? (mvarId : MVarId) : m (Option InfoTree) :=
   return (← getInfoState).assignment[mvarId]
 

stage0/src/Lean/Elab/Log.lean

@@ -9,11 +9,6 @@ import Lean.Elab.Exception
 
 namespace Lean.Elab
 
-class MonadFileMap (m : Type → Type) where
-  getFileMap  : m FileMap
-
-export MonadFileMap (getFileMap)
-
 class MonadLog (m : Type → Type) extends MonadFileMap m where
   getRef       : m Syntax
   getFileName  : m String

stage0/src/Lean/Elab/Macro.lean

@@ -0,0 +1,46 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.MacroArgUtil
+
+namespace Lean.Elab.Command
+open Lean.Syntax
+open Lean.Parser.Term hiding macroArg
+open Lean.Parser.Command
+
+@[builtinMacro Lean.Parser.Command.macro] def expandMacro : Macro
+  | `($[$doc?:docComment]? $attrKind:attrKind
+      macro$[:$prec?]? $[(name := $name?)]? $[(priority := $prio?)]? $head:macroArg $args:macroArg* :
+        $cat => $rhs) => do
+    let prio  ← evalOptPrio prio?
+    -- build parser
+    let stxPart  ← expandMacroArgIntoSyntaxItem head
+    let stxParts ← args.mapM expandMacroArgIntoSyntaxItem
+    let stxParts := #[stxPart] ++ stxParts
+    -- name
+    let name ← match name? with
+      | some name => pure name.getId
+      | none => mkNameFromParserSyntax cat.getId (mkNullNode stxParts)
+    -- build macro rules
+    let patHead ← expandMacroArgIntoPattern head
+    let patArgs ← args.mapM expandMacroArgIntoPattern
+    /- The command `syntax [<kind>] ...` adds the current namespace to the syntax node kind.
+      So, we must include current namespace when we create a pattern for the following `macro_rules` commands. -/
+    let pat := Syntax.node ((← Macro.getCurrNamespace) ++ name) (#[patHead] ++ patArgs)
+    let stxCmd ← `($[$doc?:docComment]? $attrKind:attrKind
+      syntax$[:$prec?]? (name := $(← mkIdentFromRef name)) (priority := $(quote prio)) $[$stxParts]* : $cat)
+    let macroRulesCmd ←
+      if rhs.getArgs.size == 1 then
+        -- `rhs` is a `term`
+        let rhs := rhs[0]
+        `($[$doc?:docComment]? macro_rules | `($pat) => $rhs)
+      else
+        -- `rhs` is of the form `` `( $body ) ``
+        let rhsBody := rhs[1]
+        `($[$doc?:docComment]? macro_rules | `($pat) => `($rhsBody))
+    return mkNullNode #[stxCmd, macroRulesCmd]
+  | _ => Macro.throwUnsupported
+
+end Lean.Elab.Command

stage0/src/Lean/Elab/MacroArgUtil.lean

@@ -0,0 +1,42 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.Syntax
+
+namespace Lean.Elab.Command
+open Lean.Syntax
+open Lean.Parser.Term hiding macroArg
+open Lean.Parser.Command
+
+/- Convert `macro` argument into a `syntax` command item -/
+def expandMacroArgIntoSyntaxItem : Macro
+  | `(macroArg|$id:ident:$stx)    => stx
+  -- can't match against `$s:strLit%$id` because the latter part would be interpreted as an antiquotation on the token
+  -- `strLit`.
+  | `(macroArg|$s:macroArgSymbol) => `(stx|$(s[0]):strLit)
+  | _                             => Macro.throwUnsupported
+
+/- Convert `macro` arg into a pattern element -/
+def expandMacroArgIntoPattern (stx : Syntax) : MacroM Syntax := do
+  match (← expandMacros stx) with
+  | `(macroArg|$id:ident:optional($stx)) =>
+    mkSplicePat `optional id "?"
+  | `(macroArg|$id:ident:many($stx)) =>
+    mkSplicePat `many id "*"
+  | `(macroArg|$id:ident:many1($stx)) =>
+    mkSplicePat `many id "*"
+  | `(macroArg|$id:ident:sepBy($stx, $sep:strLit $[, $stxsep]? $[, allowTrailingSep]?)) =>
+    mkSplicePat `sepBy id ((isStrLit? sep).get! ++ "*")
+  | `(macroArg|$id:ident:sepBy1($stx, $sep:strLit $[, $stxsep]? $[, allowTrailingSep]?)) =>
+    mkSplicePat `sepBy id ((isStrLit? sep).get! ++ "*")
+  | `(macroArg|$id:ident:$stx) => mkAntiquotNode id
+  | `(macroArg|$s:strLit) => strLitToPattern s
+  -- `"tk"%id` ~> `"tk"%$id`
+  | `(macroArg|$s:macroArgSymbol) => mkNode `token_antiquot #[← strLitToPattern s[0], mkAtom "%", mkAtom "$", s[1][1]]
+  | _                          => Macro.throwUnsupported
+  where mkSplicePat kind id suffix :=
+    mkNullNode #[mkAntiquotSuffixSpliceNode kind (mkAntiquotNode id) suffix]
+
+end Lean.Elab.Command

stage0/src/Lean/Elab/MacroRules.lean

@@ -0,0 +1,51 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.Syntax
+
+namespace Lean.Elab.Command
+open Lean.Syntax
+open Lean.Parser.Term hiding macroArg
+open Lean.Parser.Command
+
+/-
+  Remark: `k` is the user provided kind with the current namespace included.
+  Recall that syntax node kinds contain the current namespace.
+-/
+def elabMacroRulesAux (doc? : Option Syntax) (attrKind : Syntax) (k : SyntaxNodeKind) (alts : Array Syntax) : CommandElabM Syntax := do
+  let alts ← alts.mapM fun alt => match alt with
+    | `(matchAltExpr| | $pats,* => $rhs) => do
+      let pat := pats.elemsAndSeps[0]
+      if !pat.isQuot then
+        throwUnsupportedSyntax
+      let quoted := getQuotContent pat
+      let k' := quoted.getKind
+      if checkRuleKind k' k then
+        pure alt
+      else if k' == choiceKind then
+         match quoted.getArgs.find? fun quotAlt => checkRuleKind quotAlt.getKind k with
+         | none        => throwErrorAt alt "invalid macro_rules alternative, expected syntax node kind '{k}'"
+         | some quoted =>
+           let pat := pat.setArg 1 quoted
+           let pats := pats.elemsAndSeps.set! 0 pat
+           `(matchAltExpr| | $pats,* => $rhs)
+      else
+        throwErrorAt alt "invalid macro_rules alternative, unexpected syntax node kind '{k'}'"
+    | _ => throwUnsupportedSyntax
+  `($[$doc?:docComment]? @[$attrKind:attrKind macro $(Lean.mkIdent k)] def myMacro : Macro :=
+     fun $alts:matchAlt* | _ => throw Lean.Macro.Exception.unsupportedSyntax)
+
+@[builtinCommandElab «macro_rules»] def elabMacroRules : CommandElab :=
+  adaptExpander fun stx => match stx with
+  | `($[$doc?:docComment]? $attrKind:attrKind macro_rules $alts:matchAlt*) =>
+    expandNoKindMacroRulesAux alts "macro_rules" fun kind? alts =>
+      `($[$doc?:docComment]? $attrKind:attrKind macro_rules $[(kind := $(mkIdent <$> kind?))]? $alts:matchAlt*)
+  | `($[$doc?:docComment]? $attrKind:attrKind macro_rules (kind := $kind) | $x:ident => $rhs) =>
+    `($[$doc?:docComment]? @[$attrKind:attrKind macro $kind] def myMacro : Macro := fun $x:ident => $rhs)
+  | `($[$doc?:docComment]? $attrKind:attrKind macro_rules (kind := $kind) $alts:matchAlt*) =>
+    do elabMacroRulesAux doc? attrKind (← resolveSyntaxKind kind.getId) alts
+  | _  => throwUnsupportedSyntax
+
+end Lean.Elab.Command

stage0/src/Lean/Elab/Match.lean

@@ -9,28 +9,14 @@ import Lean.Meta.Match.Match
 import Lean.Meta.SortLocalDecls
 import Lean.Meta.GeneralizeVars
 import Lean.Elab.SyntheticMVars
-import Lean.Elab.App
+import Lean.Elab.Arg
 import Lean.Parser.Term
+import Lean.Elab.PatternVar
 
 namespace Lean.Elab.Term
 open Meta
 open Lean.Parser.Term
 
-/- This modules assumes "match"-expressions use the following syntax.
-
-```lean
-def matchDiscr := leading_parser optional (try (ident >> checkNoWsBefore "no space before ':'" >> ":")) >> termParser
-
-def «match» := leading_parser:leadPrec "match " >> sepBy1 matchDiscr ", " >> optType >> " with " >> matchAlts
-```
--/
-
-structure MatchAltView where
-  ref      : Syntax
-  patterns : Array Syntax
-  rhs      : Syntax
-  deriving Inhabited
-
 private def expandSimpleMatch (stx discr lhsVar rhs : Syntax) (expectedType? : Option Expr) : TermElabM Expr := do
   let newStx ← `(let $lhsVar := $discr; $rhs)
   withMacroExpansion stx newStx <| elabTerm newStx expectedType?
@@ -180,29 +166,8 @@ private def getMatchAlts : Syntax → Array MatchAltView
       | _ => none
   | _ => #[]
 
-inductive PatternVar where
-  | localVar     (userName : Name)
-  -- anonymous variables (`_`) are encoded using metavariables
-  | anonymousVar (mvarId   : MVarId)
-
-instance : ToString PatternVar := ⟨fun
-  | PatternVar.localVar x          => toString x
-  | PatternVar.anonymousVar mvarId => s!"?m{mvarId}"⟩
-
 builtin_initialize Parser.registerBuiltinNodeKind `MVarWithIdKind
 
-/--
-  Create an auxiliary Syntax node wrapping a fresh metavariable id.
-  We use this kind of Syntax for representing `_` occurring in patterns.
-  The metavariables are created before we elaborate the patterns into `Expr`s. -/
-private def mkMVarSyntax : TermElabM Syntax := do
-  let mvarId ← mkFreshId
-  return Syntax.node `MVarWithIdKind #[Syntax.node mvarId #[]]
-
-/-- Given a syntax node constructed using `mkMVarSyntax`, return its MVarId -/
-private def getMVarSyntaxMVarId (stx : Syntax) : MVarId :=
-  stx[0].getKind
-
 open Meta.Match (mkInaccessible inaccessible?)
 
 /--
@@ -215,330 +180,6 @@ open Meta.Match (mkInaccessible inaccessible?)
   let e ← elabTerm stx[1] expectedType?
   return mkInaccessible e
 
-/-
-  Patterns define new local variables.
-  This module collect them and preprocess `_` occurring in patterns.
-  Recall that an `_` may represent anonymous variables or inaccessible terms
-  that are implied by typing constraints. Thus, we represent them with fresh named holes `?x`.
-  After we elaborate the pattern, if the metavariable remains unassigned, we transform it into
-  a regular pattern variable. Otherwise, it becomes an inaccessible term.
-
-  Macros occurring in patterns are expanded before the `collectPatternVars` method is executed.
-  The following kinds of Syntax are handled by this module
-  - Constructor applications
-  - Applications of functions tagged with the `[matchPattern]` attribute
-  - Identifiers
-  - Anonymous constructors
-  - Structure instances
-  - Inaccessible terms
-  - Named patterns
-  - Tuple literals
-  - Type ascriptions
-  - Literals: num, string and char
--/
-namespace CollectPatternVars
-
-structure State where
-  found     : NameSet := {}
-  vars      : Array PatternVar := #[]
-
-abbrev M := StateRefT State TermElabM
-
-private def throwCtorExpected {α} : M α :=
-  throwError "invalid pattern, constructor or constant marked with '[matchPattern]' expected"
-
-private def getNumExplicitCtorParams (ctorVal : ConstructorVal) : TermElabM Nat :=
-  forallBoundedTelescope ctorVal.type ctorVal.numParams fun ps _ => do
-    let mut result := 0
-    for p in ps do
-      let localDecl ← getLocalDecl p.fvarId!
-      if localDecl.binderInfo.isExplicit then
-        result := result+1
-    pure result
-
-private def throwInvalidPattern {α} : M α :=
-  throwError "invalid pattern"
-
-/-
-An application in a pattern can be
-
-1- A constructor application
-   The elaborator assumes fields are accessible and inductive parameters are not accessible.
-
-2- A regular application `(f ...)` where `f` is tagged with `[matchPattern]`.
-   The elaborator assumes implicit arguments are not accessible and explicit ones are accessible.
--/
-
-structure Context where
-  funId         : Syntax
-  ctorVal?      : Option ConstructorVal -- It is `some`, if constructor application
-  explicit      : Bool
-  ellipsis      : Bool
-  paramDecls    : Array (Name × BinderInfo) -- parameters names and binder information
-  paramDeclIdx  : Nat := 0
-  namedArgs     : Array NamedArg
-  args          : List Arg
-  newArgs       : Array Syntax := #[]
-  deriving Inhabited
-
-private def isDone (ctx : Context) : Bool :=
-  ctx.paramDeclIdx ≥ ctx.paramDecls.size
-
-private def finalize (ctx : Context) : M Syntax := do
-  if ctx.namedArgs.isEmpty && ctx.args.isEmpty then
-    let fStx ← `(@$(ctx.funId):ident)
-    return Syntax.mkApp fStx ctx.newArgs
-  else
-    throwError "too many arguments"
-
-private def isNextArgAccessible (ctx : Context) : Bool :=
-  let i := ctx.paramDeclIdx
-  match ctx.ctorVal? with
-  | some ctorVal => i ≥ ctorVal.numParams -- For constructor applications only fields are accessible
-  | none =>
-    if h : i < ctx.paramDecls.size then
-      -- For `[matchPattern]` applications, only explicit parameters are accessible.
-      let d := ctx.paramDecls.get ⟨i, h⟩
-      d.2.isExplicit
-    else
-      false
-
-private def getNextParam (ctx : Context) : (Name × BinderInfo) × Context :=
-  let i := ctx.paramDeclIdx
-  let d := ctx.paramDecls[i]
-  (d, { ctx with paramDeclIdx := ctx.paramDeclIdx + 1 })
-
-private def processVar (idStx : Syntax) : M Syntax := do
-  unless idStx.isIdent do
-    throwErrorAt idStx "identifier expected"
-  let id := idStx.getId
-  unless id.eraseMacroScopes.isAtomic do
-    throwError "invalid pattern variable, must be atomic"
-  if (← get).found.contains id then
-    throwError "invalid pattern, variable '{id}' occurred more than once"
-  modify fun s => { s with vars := s.vars.push (PatternVar.localVar id), found := s.found.insert id }
-  return idStx
-
-private def nameToPattern : Name → TermElabM Syntax
-  | Name.anonymous => `(Name.anonymous)
-  | Name.str p s _ => do let p ← nameToPattern p; `(Name.str $p $(quote s) _)
-  | Name.num p n _ => do let p ← nameToPattern p; `(Name.num $p $(quote n) _)
-
-private def quotedNameToPattern (stx : Syntax) : TermElabM Syntax :=
-  match stx[0].isNameLit? with
-  | some val => nameToPattern val
-  | none     => throwIllFormedSyntax
-
-private def doubleQuotedNameToPattern (stx : Syntax) : TermElabM Syntax := do
-  match stx[1].isNameLit? with
-  | some val => nameToPattern (← resolveGlobalConstNoOverloadWithInfo stx[1] val)
-  | none     => throwIllFormedSyntax
-
-partial def collect (stx : Syntax) : M Syntax := withRef stx <| withFreshMacroScope do
-  let k := stx.getKind
-  if k == identKind then
-    processId stx
-  else if k == ``Lean.Parser.Term.app then
-    processCtorApp stx
-  else if k == ``Lean.Parser.Term.anonymousCtor then
-    let elems ← stx[1].getArgs.mapSepElemsM collect
-    return stx.setArg 1 <| mkNullNode elems
-  else if k == ``Lean.Parser.Term.structInst then
-    /-
-    ```
-    leading_parser "{" >> optional (atomic (termParser >> " with "))
-                >> manyIndent (group (structInstField >> optional ", "))
-                >> optional ".."
-                >> optional (" : " >> termParser)
-                >> " }"
-    ```
-    -/
-    let withMod := stx[1]
-    unless withMod.isNone do
-      throwErrorAt withMod "invalid struct instance pattern, 'with' is not allowed in patterns"
-    let fields ← stx[2].getArgs.mapM fun p => do
-        -- p is of the form (group (structInstField >> optional ", "))
-        let field := p[0]
-        -- leading_parser structInstLVal >> " := " >> termParser
-        let newVal ← collect field[2]
-        let field := field.setArg 2 newVal
-        pure <| field.setArg 0 field
-    return stx.setArg 2 <| mkNullNode fields
-  else if k == ``Lean.Parser.Term.hole then
-    let r ← mkMVarSyntax
-    modify fun s => { s with vars := s.vars.push <| PatternVar.anonymousVar <| getMVarSyntaxMVarId r }
-    return r
-  else if k == ``Lean.Parser.Term.paren then
-    let arg := stx[1]
-    if arg.isNone then
-      return stx -- `()`
-    else
-      let t := arg[0]
-      let s := arg[1]
-      if s.isNone || s[0].getKind == ``Lean.Parser.Term.typeAscription then
-        -- Ignore `s`, since it empty or it is a type ascription
-        let t ← collect t
-        let arg := arg.setArg 0 t
-        return stx.setArg 1 arg
-      else
-        return stx
-  else if k == ``Lean.Parser.Term.explicitUniv then
-    processCtor stx[0]
-  else if k == ``Lean.Parser.Term.namedPattern then
-    /- Recall that
-      def namedPattern := check... >> trailing_parser "@" >> termParser -/
-    let id := stx[0]
-    discard <| processVar id
-    let pat := stx[2]
-    let pat ← collect pat
-    `(_root_.namedPattern $id $pat)
-  else if k == ``Lean.Parser.Term.binop then
-    let lhs ← collect stx[2]
-    let rhs ← collect stx[3]
-    return stx.setArg 2 lhs |>.setArg 3 rhs
-  else if k == ``Lean.Parser.Term.inaccessible then
-    return stx
-  else if k == strLitKind then
-    return stx
-  else if k == numLitKind then
-    return stx
-  else if k == scientificLitKind then
-    return stx
-  else if k == charLitKind then
-    return stx
-  else if k == ``Lean.Parser.Term.quotedName then
-    /- Quoted names have an elaboration function associated with them, and they will not be macro expanded.
-      Note that macro expansion is not a good option since it produces a term using the smart constructors `Name.mkStr`, `Name.mkNum`
-      instead of the constructors `Name.str` and `Name.num` -/
-    quotedNameToPattern stx
-  else if k == ``Lean.Parser.Term.doubleQuotedName then
-    /- Similar to previous case -/
-    doubleQuotedNameToPattern stx
-  else if k == choiceKind then
-    throwError "invalid pattern, notation is ambiguous"
-  else
-    throwInvalidPattern
-
-where
-
-  processCtorApp (stx : Syntax) : M Syntax := do
-    let (f, namedArgs, args, ellipsis) ← expandApp stx true
-    processCtorAppCore f namedArgs args ellipsis
-
-  processCtor (stx : Syntax) : M Syntax := do
-    processCtorAppCore stx #[] #[] false
-
-  /- Check whether `stx` is a pattern variable or constructor-like (i.e., constructor or constant tagged with `[matchPattern]` attribute) -/
-  processId (stx : Syntax) : M Syntax := do
-    match (← resolveId? stx "pattern" (withInfo := true)) with
-    | none   => processVar stx
-    | some f => match f with
-      | Expr.const fName _ _ =>
-        match (← getEnv).find? fName with
-        | some (ConstantInfo.ctorInfo _) => processCtor stx
-        | some _ =>
-          if hasMatchPatternAttribute (← getEnv) fName then
-            processCtor stx
-          else
-            processVar stx
-        | none => throwCtorExpected
-      | _ => processVar stx
-
-  pushNewArg (accessible : Bool) (ctx : Context) (arg : Arg) : M Context := do
-    match arg with
-    | Arg.stx stx =>
-      let stx ← if accessible then collect stx else pure stx
-      return { ctx with newArgs := ctx.newArgs.push stx }
-    | _ => unreachable!
-
-  processExplicitArg (accessible : Bool) (ctx : Context) : M Context := do
-    match ctx.args with
-    | [] =>
-      if ctx.ellipsis then
-        pushNewArg accessible ctx (Arg.stx (← `(_)))
-      else
-        throwError "explicit parameter is missing, unused named arguments {ctx.namedArgs.map fun narg => narg.name}"
-    | arg::args =>
-      pushNewArg accessible { ctx with args := args } arg
-
-  processImplicitArg (accessible : Bool) (ctx : Context) : M Context := do
-    if ctx.explicit then
-      processExplicitArg accessible ctx
-    else
-      pushNewArg accessible ctx (Arg.stx (← `(_)))
-
-  processCtorAppContext (ctx : Context) : M Syntax := do
-    if isDone ctx then
-      finalize ctx
-    else
-      let accessible := isNextArgAccessible ctx
-      let (d, ctx)   := getNextParam ctx
-      match ctx.namedArgs.findIdx? fun namedArg => namedArg.name == d.1 with
-      | some idx =>
-        let arg := ctx.namedArgs[idx]
-        let ctx := { ctx with namedArgs := ctx.namedArgs.eraseIdx idx }
-        let ctx ← pushNewArg accessible ctx arg.val
-        processCtorAppContext ctx
-      | none =>
-        let ctx ← match d.2 with
-          | BinderInfo.implicit     => processImplicitArg accessible ctx
-          | BinderInfo.instImplicit => processImplicitArg accessible ctx
-          | _                       => processExplicitArg accessible ctx
-        processCtorAppContext ctx
-
-  processCtorAppCore (f : Syntax) (namedArgs : Array NamedArg) (args : Array Arg) (ellipsis : Bool) : M Syntax := do
-    let args := args.toList
-    let (fId, explicit) ← match f with
-      | `($fId:ident)  => pure (fId, false)
-      | `(@$fId:ident) => pure (fId, true)
-      | _              => throwError "identifier expected"
-    let some (Expr.const fName _ _) ← resolveId? fId "pattern" (withInfo := true) | throwCtorExpected
-    let fInfo ← getConstInfo fName
-    let paramDecls ← forallTelescopeReducing fInfo.type fun xs _ => xs.mapM fun x => do
-      let d ← getFVarLocalDecl x
-      return (d.userName, d.binderInfo)
-    match fInfo with
-    | ConstantInfo.ctorInfo val =>
-      processCtorAppContext
-        { funId := fId, explicit := explicit, ctorVal? := val, paramDecls := paramDecls, namedArgs := namedArgs, args := args, ellipsis := ellipsis }
-    | _ =>
-      if hasMatchPatternAttribute (← getEnv) fName then
-        processCtorAppContext
-          { funId := fId, explicit := explicit, ctorVal? := none, paramDecls := paramDecls, namedArgs := namedArgs, args := args, ellipsis := ellipsis }
-      else
-        throwCtorExpected
-
-def main (alt : MatchAltView) : M MatchAltView := do
-  let patterns ← alt.patterns.mapM fun p => do
-    trace[Elab.match] "collecting variables at pattern: {p}"
-    collect p
-  return { alt with patterns := patterns }
-
-end CollectPatternVars
-
-private def collectPatternVars (alt : MatchAltView) : TermElabM (Array PatternVar × MatchAltView) := do
-  let (alt, s) ← (CollectPatternVars.main alt).run {}
-  return (s.vars, alt)
-
-/- Return the pattern variables in the given pattern.
-   Remark: this method is not used by the main `match` elaborator, but in the precheck hook and other macros (e.g., at `Do.lean`). -/
-def getPatternVars (patternStx : Syntax) : TermElabM (Array PatternVar) := do
-  let patternStx ← liftMacroM <| expandMacros patternStx
-  let (_, s) ← (CollectPatternVars.collect patternStx).run {}
-  return s.vars
-
-def getPatternsVars (patterns : Array Syntax) : TermElabM (Array PatternVar) := do
-  let collect : CollectPatternVars.M Unit := do
-    for pattern in patterns do
-      discard <| CollectPatternVars.collect (← liftMacroM <| expandMacros pattern)
-  let (_, s) ← collect.run {}
-  return s.vars
-
-def getPatternVarNames (pvars : Array PatternVar) : Array Name :=
-  pvars.filterMap fun
-    | PatternVar.localVar x => some x
-    | _ => none
-
 open Lean.Elab.Term.Quotation in
 @[builtinQuotPrecheck Lean.Parser.Term.match] def precheckMatch : Precheck
   | `(match $[$discrs:term],* with $[| $[$patss],* => $rhss]*) => do

stage0/src/Lean/Elab/MatchAltView.lean

@@ -0,0 +1,25 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.Term
+
+namespace Lean.Elab.Term
+
+/- This modules assumes "match"-expressions use the following syntax.
+
+```lean
+def matchDiscr := leading_parser optional (try (ident >> checkNoWsBefore "no space before ':'" >> ":")) >> termParser
+
+def «match» := leading_parser:leadPrec "match " >> sepBy1 matchDiscr ", " >> optType >> " with " >> matchAlts
+```
+-/
+
+structure MatchAltView where
+  ref      : Syntax
+  patterns : Array Syntax
+  rhs      : Syntax
+  deriving Inhabited
+
+end Lean.Elab.Term

stage0/src/Lean/Elab/Mixfix.lean

@@ -0,0 +1,35 @@
+/-
+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 Lean.Elab.Attributes
+
+namespace Lean.Elab.Command
+
+@[builtinMacro Lean.Parser.Command.mixfix] def expandMixfix : Macro := fun stx =>
+  withAttrKindGlobal stx fun stx => do
+    match stx with
+    | `(infixl $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
+      let prec1 := quote <| (← evalOptPrec prec) + 1
+      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? lhs$[:$prec]? $op:strLit rhs:$prec1 => $f lhs rhs)
+    | `(infix $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
+      let prec1 := quote <| (← evalOptPrec prec) + 1
+      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? lhs:$prec1 $op:strLit rhs:$prec1 => $f lhs rhs)
+    | `(infixr $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
+      let prec1 := quote <| (← evalOptPrec prec) + 1
+      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? lhs:$prec1 $op:strLit rhs $[: $prec]? => $f lhs rhs)
+    | `(prefix $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
+      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op:strLit arg $[: $prec]? => $f arg)
+    | `(postfix $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
+      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? arg$[:$prec]? $op:strLit => $f arg)
+    | _ => Macro.throwUnsupported
+where
+  -- set "global" `attrKind`, apply `f`, and restore `attrKind` to result
+  withAttrKindGlobal stx f := do
+    let attrKind := stx[0]
+    let stx  := stx.setArg 0 mkAttrKindGlobal
+    let stx ← f stx
+    return stx.setArg 0 attrKind
+
+end Lean.Elab.Command

stage0/src/Lean/Elab/Notation.lean

@@ -0,0 +1,105 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.Syntax
+
+namespace Lean.Elab.Command
+open Lean.Syntax
+open Lean.Parser.Term hiding macroArg
+open Lean.Parser.Command
+
+/- Wrap all occurrences of the given `ident` nodes in antiquotations -/
+private partial def antiquote (vars : Array Syntax) : Syntax → Syntax
+  | stx => match stx with
+  | `($id:ident) =>
+    if (vars.findIdx? (fun var => var.getId == id.getId)).isSome then
+      mkAntiquotNode id
+    else
+      stx
+  | _ => match stx with
+    | Syntax.node k args => Syntax.node k (args.map (antiquote vars))
+    | stx => stx
+
+/- Convert `notation` command lhs item into a `syntax` command item -/
+def expandNotationItemIntoSyntaxItem (stx : Syntax) : MacroM Syntax :=
+  let k := stx.getKind
+  if k == `Lean.Parser.Command.identPrec then
+    pure $ Syntax.node `Lean.Parser.Syntax.cat #[mkIdentFrom stx `term,  stx[1]]
+  else if k == strLitKind then
+    pure $ Syntax.node `Lean.Parser.Syntax.atom #[stx]
+  else
+    Macro.throwUnsupported
+
+/- Convert `notation` command lhs item into a pattern element -/
+def expandNotationItemIntoPattern (stx : Syntax) : MacroM Syntax :=
+  let k := stx.getKind
+  if k == `Lean.Parser.Command.identPrec then
+    mkAntiquotNode stx[0]
+  else if k == strLitKind then
+    strLitToPattern stx
+  else
+    Macro.throwUnsupported
+
+/-- Try to derive a `SimpleDelab` from a notation.
+    The notation must be of the form `notation ... => c var_1 ... var_n`
+    where `c` is a declaration in the current scope and the `var_i` are a permutation of the LHS vars. -/
+def mkSimpleDelab (attrKind : Syntax) (vars : Array Syntax) (pat qrhs : Syntax) : OptionT MacroM Syntax := do
+  match qrhs with
+  | `($c:ident $args*) =>
+    let [(c, [])] ← Macro.resolveGlobalName c.getId | failure
+    guard <| args.all (Syntax.isIdent ∘ getAntiquotTerm)
+    guard <| args.allDiff
+    -- replace head constant with (unused) antiquotation so we're not dependent on the exact pretty printing of the head
+    let qrhs ← `($(mkAntiquotNode (← `(_))) $args*)
+    `(@[$attrKind:attrKind appUnexpander $(mkIdent c):ident] def unexpand : Lean.PrettyPrinter.Unexpander := fun
+       | `($qrhs) => `($pat)
+       | _        => throw ())
+  | `($c:ident)        =>
+    let [(c, [])] ← Macro.resolveGlobalName c.getId | failure
+    `(@[$attrKind:attrKind appUnexpander $(mkIdent c):ident] def unexpand : Lean.PrettyPrinter.Unexpander := fun _ => `($pat))
+  | _                  => failure
+
+private def isLocalAttrKind (attrKind : Syntax) : Bool :=
+  match attrKind with
+  | `(Parser.Term.attrKind| local) => true
+  | _ => false
+
+private def expandNotationAux (ref : Syntax)
+    (currNamespace : Name) (attrKind : Syntax) (prec? : Option Syntax) (name? : Option Syntax) (prio? : Option Syntax) (items : Array Syntax) (rhs : Syntax) : MacroM Syntax := do
+  let prio ← evalOptPrio prio?
+  -- build parser
+  let syntaxParts ← items.mapM expandNotationItemIntoSyntaxItem
+  let cat := mkIdentFrom ref `term
+  let name ←
+    match name? with
+    | some name => pure name.getId
+    | none => mkNameFromParserSyntax `term (mkNullNode syntaxParts)
+  -- build macro rules
+  let vars := items.filter fun item => item.getKind == `Lean.Parser.Command.identPrec
+  let vars := vars.map fun var => var[0]
+  let qrhs := antiquote vars rhs
+  let patArgs ← items.mapM expandNotationItemIntoPattern
+  /- The command `syntax [<kind>] ...` adds the current namespace to the syntax node kind.
+     So, we must include current namespace when we create a pattern for the following `macro_rules` commands. -/
+  let fullName := currNamespace ++ name
+  let pat := Syntax.node fullName patArgs
+  let stxDecl ← `($attrKind:attrKind syntax $[: $prec?]? (name := $(mkIdent name)) (priority := $(quote prio):numLit) $[$syntaxParts]* : $cat)
+  let mut macroDecl ← `(macro_rules | `($pat) => ``($qrhs))
+  if isLocalAttrKind attrKind then
+    -- Make sure the quotation pre-checker takes section variables into account for local notation.
+    macroDecl ← `(section set_option quotPrecheck.allowSectionVars true $macroDecl end)
+  match (← mkSimpleDelab attrKind vars pat qrhs |>.run) with
+  | some delabDecl => mkNullNode #[stxDecl, macroDecl, delabDecl]
+  | none           => mkNullNode #[stxDecl, macroDecl]
+
+@[builtinMacro Lean.Parser.Command.notation] def expandNotation : Macro
+  | stx@`($attrKind:attrKind notation $[: $prec? ]? $[(name := $name?)]? $[(priority := $prio?)]? $items* => $rhs) => do
+    -- trigger scoped checks early and only once
+    let _ ← toAttributeKind attrKind
+    expandNotationAux stx (← Macro.getCurrNamespace) attrKind prec? name? prio? items rhs
+  | _ => Macro.throwUnsupported
+
+
+end Lean.Elab.Command

stage0/src/Lean/Elab/PatternVar.lean

@@ -0,0 +1,359 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Meta.Match.MatchPatternAttr
+import Lean.Elab.Arg
+import Lean.Elab.MatchAltView
+
+namespace Lean.Elab.Term
+
+open Meta
+
+inductive PatternVar where
+  | localVar     (userName : Name)
+  -- anonymous variables (`_`) are encoded using metavariables
+  | anonymousVar (mvarId   : MVarId)
+
+instance : ToString PatternVar := ⟨fun
+  | PatternVar.localVar x          => toString x
+  | PatternVar.anonymousVar mvarId => s!"?m{mvarId}"⟩
+
+/--
+  Create an auxiliary Syntax node wrapping a fresh metavariable id.
+  We use this kind of Syntax for representing `_` occurring in patterns.
+  The metavariables are created before we elaborate the patterns into `Expr`s. -/
+private def mkMVarSyntax : TermElabM Syntax := do
+  let mvarId ← mkFreshId
+  return Syntax.node `MVarWithIdKind #[Syntax.node mvarId #[]]
+
+/-- Given a syntax node constructed using `mkMVarSyntax`, return its MVarId -/
+def getMVarSyntaxMVarId (stx : Syntax) : MVarId :=
+  stx[0].getKind
+
+/-
+  Patterns define new local variables.
+  This module collect them and preprocess `_` occurring in patterns.
+  Recall that an `_` may represent anonymous variables or inaccessible terms
+  that are implied by typing constraints. Thus, we represent them with fresh named holes `?x`.
+  After we elaborate the pattern, if the metavariable remains unassigned, we transform it into
+  a regular pattern variable. Otherwise, it becomes an inaccessible term.
+
+  Macros occurring in patterns are expanded before the `collectPatternVars` method is executed.
+  The following kinds of Syntax are handled by this module
+  - Constructor applications
+  - Applications of functions tagged with the `[matchPattern]` attribute
+  - Identifiers
+  - Anonymous constructors
+  - Structure instances
+  - Inaccessible terms
+  - Named patterns
+  - Tuple literals
+  - Type ascriptions
+  - Literals: num, string and char
+-/
+namespace CollectPatternVars
+
+structure State where
+  found     : NameSet := {}
+  vars      : Array PatternVar := #[]
+
+abbrev M := StateRefT State TermElabM
+
+private def throwCtorExpected {α} : M α :=
+  throwError "invalid pattern, constructor or constant marked with '[matchPattern]' expected"
+
+private def getNumExplicitCtorParams (ctorVal : ConstructorVal) : TermElabM Nat :=
+  forallBoundedTelescope ctorVal.type ctorVal.numParams fun ps _ => do
+    let mut result := 0
+    for p in ps do
+      let localDecl ← getLocalDecl p.fvarId!
+      if localDecl.binderInfo.isExplicit then
+        result := result+1
+    pure result
+
+private def throwInvalidPattern {α} : M α :=
+  throwError "invalid pattern"
+
+/-
+An application in a pattern can be
+
+1- A constructor application
+   The elaborator assumes fields are accessible and inductive parameters are not accessible.
+
+2- A regular application `(f ...)` where `f` is tagged with `[matchPattern]`.
+   The elaborator assumes implicit arguments are not accessible and explicit ones are accessible.
+-/
+
+structure Context where
+  funId         : Syntax
+  ctorVal?      : Option ConstructorVal -- It is `some`, if constructor application
+  explicit      : Bool
+  ellipsis      : Bool
+  paramDecls    : Array (Name × BinderInfo) -- parameters names and binder information
+  paramDeclIdx  : Nat := 0
+  namedArgs     : Array NamedArg
+  args          : List Arg
+  newArgs       : Array Syntax := #[]
+  deriving Inhabited
+
+private def isDone (ctx : Context) : Bool :=
+  ctx.paramDeclIdx ≥ ctx.paramDecls.size
+
+private def finalize (ctx : Context) : M Syntax := do
+  if ctx.namedArgs.isEmpty && ctx.args.isEmpty then
+    let fStx ← `(@$(ctx.funId):ident)
+    return Syntax.mkApp fStx ctx.newArgs
+  else
+    throwError "too many arguments"
+
+private def isNextArgAccessible (ctx : Context) : Bool :=
+  let i := ctx.paramDeclIdx
+  match ctx.ctorVal? with
+  | some ctorVal => i ≥ ctorVal.numParams -- For constructor applications only fields are accessible
+  | none =>
+    if h : i < ctx.paramDecls.size then
+      -- For `[matchPattern]` applications, only explicit parameters are accessible.
+      let d := ctx.paramDecls.get ⟨i, h⟩
+      d.2.isExplicit
+    else
+      false
+
+private def getNextParam (ctx : Context) : (Name × BinderInfo) × Context :=
+  let i := ctx.paramDeclIdx
+  let d := ctx.paramDecls[i]
+  (d, { ctx with paramDeclIdx := ctx.paramDeclIdx + 1 })
+
+private def processVar (idStx : Syntax) : M Syntax := do
+  unless idStx.isIdent do
+    throwErrorAt idStx "identifier expected"
+  let id := idStx.getId
+  unless id.eraseMacroScopes.isAtomic do
+    throwError "invalid pattern variable, must be atomic"
+  if (← get).found.contains id then
+    throwError "invalid pattern, variable '{id}' occurred more than once"
+  modify fun s => { s with vars := s.vars.push (PatternVar.localVar id), found := s.found.insert id }
+  return idStx
+
+private def nameToPattern : Name → TermElabM Syntax
+  | Name.anonymous => `(Name.anonymous)
+  | Name.str p s _ => do let p ← nameToPattern p; `(Name.str $p $(quote s) _)
+  | Name.num p n _ => do let p ← nameToPattern p; `(Name.num $p $(quote n) _)
+
+private def quotedNameToPattern (stx : Syntax) : TermElabM Syntax :=
+  match stx[0].isNameLit? with
+  | some val => nameToPattern val
+  | none     => throwIllFormedSyntax
+
+private def doubleQuotedNameToPattern (stx : Syntax) : TermElabM Syntax := do
+  match stx[1].isNameLit? with
+  | some val => nameToPattern (← resolveGlobalConstNoOverloadWithInfo stx[1] val)
+  | none     => throwIllFormedSyntax
+
+partial def collect (stx : Syntax) : M Syntax := withRef stx <| withFreshMacroScope do
+  let k := stx.getKind
+  if k == identKind then
+    processId stx
+  else if k == ``Lean.Parser.Term.app then
+    processCtorApp stx
+  else if k == ``Lean.Parser.Term.anonymousCtor then
+    let elems ← stx[1].getArgs.mapSepElemsM collect
+    return stx.setArg 1 <| mkNullNode elems
+  else if k == ``Lean.Parser.Term.structInst then
+    /-
+    ```
+    leading_parser "{" >> optional (atomic (termParser >> " with "))
+                >> manyIndent (group (structInstField >> optional ", "))
+                >> optional ".."
+                >> optional (" : " >> termParser)
+                >> " }"
+    ```
+    -/
+    let withMod := stx[1]
+    unless withMod.isNone do
+      throwErrorAt withMod "invalid struct instance pattern, 'with' is not allowed in patterns"
+    let fields ← stx[2].getArgs.mapM fun p => do
+        -- p is of the form (group (structInstField >> optional ", "))
+        let field := p[0]
+        -- leading_parser structInstLVal >> " := " >> termParser
+        let newVal ← collect field[2]
+        let field := field.setArg 2 newVal
+        pure <| field.setArg 0 field
+    return stx.setArg 2 <| mkNullNode fields
+  else if k == ``Lean.Parser.Term.hole then
+    let r ← mkMVarSyntax
+    modify fun s => { s with vars := s.vars.push <| PatternVar.anonymousVar <| getMVarSyntaxMVarId r }
+    return r
+  else if k == ``Lean.Parser.Term.paren then
+    let arg := stx[1]
+    if arg.isNone then
+      return stx -- `()`
+    else
+      let t := arg[0]
+      let s := arg[1]
+      if s.isNone || s[0].getKind == ``Lean.Parser.Term.typeAscription then
+        -- Ignore `s`, since it empty or it is a type ascription
+        let t ← collect t
+        let arg := arg.setArg 0 t
+        return stx.setArg 1 arg
+      else
+        return stx
+  else if k == ``Lean.Parser.Term.explicitUniv then
+    processCtor stx[0]
+  else if k == ``Lean.Parser.Term.namedPattern then
+    /- Recall that
+      def namedPattern := check... >> trailing_parser "@" >> termParser -/
+    let id := stx[0]
+    discard <| processVar id
+    let pat := stx[2]
+    let pat ← collect pat
+    `(_root_.namedPattern $id $pat)
+  else if k == ``Lean.Parser.Term.binop then
+    let lhs ← collect stx[2]
+    let rhs ← collect stx[3]
+    return stx.setArg 2 lhs |>.setArg 3 rhs
+  else if k == ``Lean.Parser.Term.inaccessible then
+    return stx
+  else if k == strLitKind then
+    return stx
+  else if k == numLitKind then
+    return stx
+  else if k == scientificLitKind then
+    return stx
+  else if k == charLitKind then
+    return stx
+  else if k == ``Lean.Parser.Term.quotedName then
+    /- Quoted names have an elaboration function associated with them, and they will not be macro expanded.
+      Note that macro expansion is not a good option since it produces a term using the smart constructors `Name.mkStr`, `Name.mkNum`
+      instead of the constructors `Name.str` and `Name.num` -/
+    quotedNameToPattern stx
+  else if k == ``Lean.Parser.Term.doubleQuotedName then
+    /- Similar to previous case -/
+    doubleQuotedNameToPattern stx
+  else if k == choiceKind then
+    throwError "invalid pattern, notation is ambiguous"
+  else
+    throwInvalidPattern
+
+where
+
+  processCtorApp (stx : Syntax) : M Syntax := do
+    let (f, namedArgs, args, ellipsis) ← expandApp stx true
+    processCtorAppCore f namedArgs args ellipsis
+
+  processCtor (stx : Syntax) : M Syntax := do
+    processCtorAppCore stx #[] #[] false
+
+  /- Check whether `stx` is a pattern variable or constructor-like (i.e., constructor or constant tagged with `[matchPattern]` attribute) -/
+  processId (stx : Syntax) : M Syntax := do
+    match (← resolveId? stx "pattern" (withInfo := true)) with
+    | none   => processVar stx
+    | some f => match f with
+      | Expr.const fName _ _ =>
+        match (← getEnv).find? fName with
+        | some (ConstantInfo.ctorInfo _) => processCtor stx
+        | some _ =>
+          if hasMatchPatternAttribute (← getEnv) fName then
+            processCtor stx
+          else
+            processVar stx
+        | none => throwCtorExpected
+      | _ => processVar stx
+
+  pushNewArg (accessible : Bool) (ctx : Context) (arg : Arg) : M Context := do
+    match arg with
+    | Arg.stx stx =>
+      let stx ← if accessible then collect stx else pure stx
+      return { ctx with newArgs := ctx.newArgs.push stx }
+    | _ => unreachable!
+
+  processExplicitArg (accessible : Bool) (ctx : Context) : M Context := do
+    match ctx.args with
+    | [] =>
+      if ctx.ellipsis then
+        pushNewArg accessible ctx (Arg.stx (← `(_)))
+      else
+        throwError "explicit parameter is missing, unused named arguments {ctx.namedArgs.map fun narg => narg.name}"
+    | arg::args =>
+      pushNewArg accessible { ctx with args := args } arg
+
+  processImplicitArg (accessible : Bool) (ctx : Context) : M Context := do
+    if ctx.explicit then
+      processExplicitArg accessible ctx
+    else
+      pushNewArg accessible ctx (Arg.stx (← `(_)))
+
+  processCtorAppContext (ctx : Context) : M Syntax := do
+    if isDone ctx then
+      finalize ctx
+    else
+      let accessible := isNextArgAccessible ctx
+      let (d, ctx)   := getNextParam ctx
+      match ctx.namedArgs.findIdx? fun namedArg => namedArg.name == d.1 with
+      | some idx =>
+        let arg := ctx.namedArgs[idx]
+        let ctx := { ctx with namedArgs := ctx.namedArgs.eraseIdx idx }
+        let ctx ← pushNewArg accessible ctx arg.val
+        processCtorAppContext ctx
+      | none =>
+        let ctx ← match d.2 with
+          | BinderInfo.implicit     => processImplicitArg accessible ctx
+          | BinderInfo.instImplicit => processImplicitArg accessible ctx
+          | _                       => processExplicitArg accessible ctx
+        processCtorAppContext ctx
+
+  processCtorAppCore (f : Syntax) (namedArgs : Array NamedArg) (args : Array Arg) (ellipsis : Bool) : M Syntax := do
+    let args := args.toList
+    let (fId, explicit) ← match f with
+      | `($fId:ident)  => pure (fId, false)
+      | `(@$fId:ident) => pure (fId, true)
+      | _              => throwError "identifier expected"
+    let some (Expr.const fName _ _) ← resolveId? fId "pattern" (withInfo := true) | throwCtorExpected
+    let fInfo ← getConstInfo fName
+    let paramDecls ← forallTelescopeReducing fInfo.type fun xs _ => xs.mapM fun x => do
+      let d ← getFVarLocalDecl x
+      return (d.userName, d.binderInfo)
+    match fInfo with
+    | ConstantInfo.ctorInfo val =>
+      processCtorAppContext
+        { funId := fId, explicit := explicit, ctorVal? := val, paramDecls := paramDecls, namedArgs := namedArgs, args := args, ellipsis := ellipsis }
+    | _ =>
+      if hasMatchPatternAttribute (← getEnv) fName then
+        processCtorAppContext
+          { funId := fId, explicit := explicit, ctorVal? := none, paramDecls := paramDecls, namedArgs := namedArgs, args := args, ellipsis := ellipsis }
+      else
+        throwCtorExpected
+
+def main (alt : MatchAltView) : M MatchAltView := do
+  let patterns ← alt.patterns.mapM fun p => do
+    trace[Elab.match] "collecting variables at pattern: {p}"
+    collect p
+  return { alt with patterns := patterns }
+
+end CollectPatternVars
+
+def collectPatternVars (alt : MatchAltView) : TermElabM (Array PatternVar × MatchAltView) := do
+  let (alt, s) ← (CollectPatternVars.main alt).run {}
+  return (s.vars, alt)
+
+/- Return the pattern variables in the given pattern.
+   Remark: this method is not used by the main `match` elaborator, but in the precheck hook and other macros (e.g., at `Do.lean`). -/
+def getPatternVars (patternStx : Syntax) : TermElabM (Array PatternVar) := do
+  let patternStx ← liftMacroM <| expandMacros patternStx
+  let (_, s) ← (CollectPatternVars.collect patternStx).run {}
+  return s.vars
+
+def getPatternsVars (patterns : Array Syntax) : TermElabM (Array PatternVar) := do
+  let collect : CollectPatternVars.M Unit := do
+    for pattern in patterns do
+      discard <| CollectPatternVars.collect (← liftMacroM <| expandMacros pattern)
+  let (_, s) ← collect.run {}
+  return s.vars
+
+def getPatternVarNames (pvars : Array PatternVar) : Array Name :=
+  pvars.filterMap fun
+    | PatternVar.localVar x => some x
+    | _ => none
+
+end Lean.Elab.Term

stage0/src/Lean/Elab/StructInst.lean

@@ -324,7 +324,7 @@ def Struct.modifyFieldsM {m : Type → Type} [Monad m] (s : Struct) (f : Fields
   match s with
   | ⟨ref, structName, fields, source⟩ => return ⟨ref, structName, (← f fields), source⟩
 
-@[inline] def Struct.modifyFields (s : Struct) (f : Fields → Fields) : Struct :=
+def Struct.modifyFields (s : Struct) (f : Fields → Fields) : Struct :=
   Id.run <| s.modifyFieldsM f
 
 def Struct.setFields (s : Struct) (fields : Fields) : Struct :=
@@ -422,7 +422,7 @@ private def mkSubstructSource (structName : Name) (fieldNames : Array Name) (fie
     return Source.explicit stx (mkProj structName idx src)
   | s => return s
 
-@[specialize] private def groupFields (expandStruct : Struct → TermElabM Struct) (s : Struct) : TermElabM Struct := do
+private def groupFields (expandStruct : Struct → TermElabM Struct) (s : Struct) : TermElabM Struct := do
   let env ← getEnv
   let fieldNames := getStructureFields env s.structName
   withRef s.ref do
@@ -455,7 +455,7 @@ def findField? (fields : Fields) (fieldName : Name) : Option (Field Struct) :=
     | [FieldLHS.fieldName _ n] => n == fieldName
     | _                        => false
 
-@[specialize] private def addMissingFields (expandStruct : Struct → TermElabM Struct) (s : Struct) : TermElabM Struct := do
+private def addMissingFields (expandStruct : Struct → TermElabM Struct) (s : Struct) : TermElabM Struct := do
   let env ← getEnv
   let fieldNames := getStructureFields env s.structName
   let ref := s.ref

stage0/src/Lean/Elab/Syntax.lean

@@ -326,36 +326,9 @@ def syntaxAbbrev  := leading_parser "syntax " >> ident >> " := " >> many1 syntax
   let stx' ← `(def $declName : Lean.ParserDescr := ParserDescr.nodeWithAntiquot $(quote (toString declName.getId)) $(quote stxNodeKind) $val)
   withMacroExpansion stx stx' $ elabCommand stx'
 
-private def checkRuleKind (given expected : SyntaxNodeKind) : Bool :=
+def checkRuleKind (given expected : SyntaxNodeKind) : Bool :=
   given == expected || given == expected ++ `antiquot
 
-/-
-  Remark: `k` is the user provided kind with the current namespace included.
-  Recall that syntax node kinds contain the current namespace.
--/
-def elabMacroRulesAux (doc? : Option Syntax) (attrKind : Syntax) (k : SyntaxNodeKind) (alts : Array Syntax) : CommandElabM Syntax := do
-  let alts ← alts.mapM fun alt => match alt with
-    | `(matchAltExpr| | $pats,* => $rhs) => do
-      let pat := pats.elemsAndSeps[0]
-      if !pat.isQuot then
-        throwUnsupportedSyntax
-      let quoted := getQuotContent pat
-      let k' := quoted.getKind
-      if checkRuleKind k' k then
-        pure alt
-      else if k' == choiceKind then
-         match quoted.getArgs.find? fun quotAlt => checkRuleKind quotAlt.getKind k with
-         | none        => throwErrorAt alt "invalid macro_rules alternative, expected syntax node kind '{k}'"
-         | some quoted =>
-           let pat := pat.setArg 1 quoted
-           let pats := pats.elemsAndSeps.set! 0 pat
-           `(matchAltExpr| | $pats,* => $rhs)
-      else
-        throwErrorAt alt "invalid macro_rules alternative, unexpected syntax node kind '{k'}'"
-    | _ => throwUnsupportedSyntax
-  `($[$doc?:docComment]? @[$attrKind:attrKind macro $(Lean.mkIdent k)] def myMacro : Macro :=
-     fun $alts:matchAlt* | _ => throw Lean.Macro.Exception.unsupportedSyntax)
-
 def inferMacroRulesAltKind : Syntax → CommandElabM SyntaxNodeKind
   | `(matchAltExpr| | $pats,* => $rhs) => do
     let pat := pats.elemsAndSeps[0]
@@ -368,7 +341,7 @@ def inferMacroRulesAltKind : Syntax → CommandElabM SyntaxNodeKind
 /--
 Infer syntax kind `k` from first pattern, put alternatives of same kind into new `macro/elab_rules (kind := k)` via `mkCmd (some k)`,
 leave remaining alternatives (via `mkCmd none`) to be recursively expanded. -/
-private def expandNoKindMacroRulesAux (alts : Array Syntax) (cmdName : String) (mkCmd : Option Name → Array Syntax → CommandElabM Syntax) : CommandElabM Syntax := do
+def expandNoKindMacroRulesAux (alts : Array Syntax) (cmdName : String) (mkCmd : Option Name → Array Syntax → CommandElabM Syntax) : CommandElabM Syntax := do
   let mut k ← inferMacroRulesAltKind alts[0]
   if k.isStr && k.getString! == "antiquot" then
     k := k.getPrefix
@@ -383,286 +356,12 @@ private def expandNoKindMacroRulesAux (alts : Array Syntax) (cmdName : String) (
     else
       mkNullNode #[← mkCmd k altsK, ← mkCmd none altsNotK]
 
-@[builtinCommandElab «macro_rules»] def elabMacroRules : CommandElab :=
-  adaptExpander fun stx => match stx with
-  | `($[$doc?:docComment]? $attrKind:attrKind macro_rules $alts:matchAlt*) =>
-    expandNoKindMacroRulesAux alts "macro_rules" fun kind? alts =>
-      `($[$doc?:docComment]? $attrKind:attrKind macro_rules $[(kind := $(mkIdent <$> kind?))]? $alts:matchAlt*)
-  | `($[$doc?:docComment]? $attrKind:attrKind macro_rules (kind := $kind) | $x:ident => $rhs) =>
-    `($[$doc?:docComment]? @[$attrKind:attrKind macro $kind] def myMacro : Macro := fun $x:ident => $rhs)
-  | `($[$doc?:docComment]? $attrKind:attrKind macro_rules (kind := $kind) $alts:matchAlt*) =>
-    do elabMacroRulesAux doc? attrKind (← resolveSyntaxKind kind.getId) alts
-  | _  => throwUnsupportedSyntax
-
-@[builtinMacro Lean.Parser.Command.mixfix] def expandMixfix : Macro := fun stx =>
-  withAttrKindGlobal stx fun stx => do
-    match stx with
-    | `(infixl $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
-      let prec1 := quote <| (← evalOptPrec prec) + 1
-      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? lhs$[:$prec]? $op:strLit rhs:$prec1 => $f lhs rhs)
-    | `(infix $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
-      let prec1 := quote <| (← evalOptPrec prec) + 1
-      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? lhs:$prec1 $op:strLit rhs:$prec1 => $f lhs rhs)
-    | `(infixr $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
-      let prec1 := quote <| (← evalOptPrec prec) + 1
-      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? lhs:$prec1 $op:strLit rhs $[: $prec]? => $f lhs rhs)
-    | `(prefix $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
-      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op:strLit arg $[: $prec]? => $f arg)
-    | `(postfix $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? $op => $f) =>
-      `(notation $[: $prec]? $[(name := $name)]? $[(priority := $prio)]? arg$[:$prec]? $op:strLit => $f arg)
-    | _ => Macro.throwUnsupported
-where
-  -- set "global" `attrKind`, apply `f`, and restore `attrKind` to result
-  withAttrKindGlobal stx f := do
-    let attrKind := stx[0]
-    let stx  := stx.setArg 0 mkAttrKindGlobal
-    let stx ← f stx
-    return stx.setArg 0 attrKind
-
-/- Wrap all occurrences of the given `ident` nodes in antiquotations -/
-private partial def antiquote (vars : Array Syntax) : Syntax → Syntax
-  | stx => match stx with
-  | `($id:ident) =>
-    if (vars.findIdx? (fun var => var.getId == id.getId)).isSome then
-      mkAntiquotNode id
-    else
-      stx
-  | _ => match stx with
-    | Syntax.node k args => Syntax.node k (args.map (antiquote vars))
-    | stx => stx
-
-/- Convert `notation` command lhs item into a `syntax` command item -/
-def expandNotationItemIntoSyntaxItem (stx : Syntax) : MacroM Syntax :=
-  let k := stx.getKind
-  if k == `Lean.Parser.Command.identPrec then
-    pure $ Syntax.node `Lean.Parser.Syntax.cat #[mkIdentFrom stx `term,  stx[1]]
-  else if k == strLitKind then
-    pure $ Syntax.node `Lean.Parser.Syntax.atom #[stx]
-  else
-    Macro.throwUnsupported
-
 def strLitToPattern (stx: Syntax) : MacroM Syntax :=
   match stx.isStrLit? with
   | some str => pure $ mkAtomFrom stx str
   | none     => Macro.throwUnsupported
 
-/- Convert `notation` command lhs item into a pattern element -/
-def expandNotationItemIntoPattern (stx : Syntax) : MacroM Syntax :=
-  let k := stx.getKind
-  if k == `Lean.Parser.Command.identPrec then
-    mkAntiquotNode stx[0]
-  else if k == strLitKind then
-    strLitToPattern stx
-  else
-    Macro.throwUnsupported
-
-/-- Try to derive a `SimpleDelab` from a notation.
-    The notation must be of the form `notation ... => c var_1 ... var_n`
-    where `c` is a declaration in the current scope and the `var_i` are a permutation of the LHS vars. -/
-def mkSimpleDelab (attrKind : Syntax) (vars : Array Syntax) (pat qrhs : Syntax) : OptionT MacroM Syntax := do
-  match qrhs with
-  | `($c:ident $args*) =>
-    let [(c, [])] ← Macro.resolveGlobalName c.getId | failure
-    guard <| args.all (Syntax.isIdent ∘ getAntiquotTerm)
-    guard <| args.allDiff
-    -- replace head constant with (unused) antiquotation so we're not dependent on the exact pretty printing of the head
-    let qrhs ← `($(mkAntiquotNode (← `(_))) $args*)
-    `(@[$attrKind:attrKind appUnexpander $(mkIdent c):ident] def unexpand : Lean.PrettyPrinter.Unexpander := fun
-       | `($qrhs) => `($pat)
-       | _        => throw ())
-  | `($c:ident)        =>
-    let [(c, [])] ← Macro.resolveGlobalName c.getId | failure
-    `(@[$attrKind:attrKind appUnexpander $(mkIdent c):ident] def unexpand : Lean.PrettyPrinter.Unexpander := fun _ => `($pat))
-  | _                  => failure
-
-private def isLocalAttrKind (attrKind : Syntax) : Bool :=
-  match attrKind with
-  | `(Parser.Term.attrKind| local) => true
-  | _ => false
-
-private def expandNotationAux (ref : Syntax)
-    (currNamespace : Name) (attrKind : Syntax) (prec? : Option Syntax) (name? : Option Syntax) (prio? : Option Syntax) (items : Array Syntax) (rhs : Syntax) : MacroM Syntax := do
-  let prio ← evalOptPrio prio?
-  -- build parser
-  let syntaxParts ← items.mapM expandNotationItemIntoSyntaxItem
-  let cat := mkIdentFrom ref `term
-  let name ←
-    match name? with
-    | some name => pure name.getId
-    | none => mkNameFromParserSyntax `term (mkNullNode syntaxParts)
-  -- build macro rules
-  let vars := items.filter fun item => item.getKind == `Lean.Parser.Command.identPrec
-  let vars := vars.map fun var => var[0]
-  let qrhs := antiquote vars rhs
-  let patArgs ← items.mapM expandNotationItemIntoPattern
-  /- The command `syntax [<kind>] ...` adds the current namespace to the syntax node kind.
-     So, we must include current namespace when we create a pattern for the following `macro_rules` commands. -/
-  let fullName := currNamespace ++ name
-  let pat := Syntax.node fullName patArgs
-  let stxDecl ← `($attrKind:attrKind syntax $[: $prec?]? (name := $(mkIdent name)) (priority := $(quote prio):numLit) $[$syntaxParts]* : $cat)
-  let mut macroDecl ← `(macro_rules | `($pat) => ``($qrhs))
-  if isLocalAttrKind attrKind then
-    -- Make sure the quotation pre-checker takes section variables into account for local notation.
-    macroDecl ← `(section set_option quotPrecheck.allowSectionVars true $macroDecl end)
-  match (← mkSimpleDelab attrKind vars pat qrhs |>.run) with
-  | some delabDecl => mkNullNode #[stxDecl, macroDecl, delabDecl]
-  | none           => mkNullNode #[stxDecl, macroDecl]
-
-@[builtinMacro Lean.Parser.Command.notation] def expandNotation : Macro
-  | stx@`($attrKind:attrKind notation $[: $prec? ]? $[(name := $name?)]? $[(priority := $prio?)]? $items* => $rhs) => do
-    -- trigger scoped checks early and only once
-    let _ ← toAttributeKind attrKind
-    expandNotationAux stx (← Macro.getCurrNamespace) attrKind prec? name? prio? items rhs
-  | _ => Macro.throwUnsupported
-
-/- Convert `macro` argument into a `syntax` command item -/
-def expandMacroArgIntoSyntaxItem : Macro
-  | `(macroArg|$id:ident:$stx)    => stx
-  -- can't match against `$s:strLit%$id` because the latter part would be interpreted as an antiquotation on the token
-  -- `strLit`.
-  | `(macroArg|$s:macroArgSymbol) => `(stx|$(s[0]):strLit)
-  | _                             => Macro.throwUnsupported
-
-/- Convert `macro` arg into a pattern element -/
-def expandMacroArgIntoPattern (stx : Syntax) : MacroM Syntax := do
-  match (← expandMacros stx) with
-  | `(macroArg|$id:ident:optional($stx)) =>
-    mkSplicePat `optional id "?"
-  | `(macroArg|$id:ident:many($stx)) =>
-    mkSplicePat `many id "*"
-  | `(macroArg|$id:ident:many1($stx)) =>
-    mkSplicePat `many id "*"
-  | `(macroArg|$id:ident:sepBy($stx, $sep:strLit $[, $stxsep]? $[, allowTrailingSep]?)) =>
-    mkSplicePat `sepBy id ((isStrLit? sep).get! ++ "*")
-  | `(macroArg|$id:ident:sepBy1($stx, $sep:strLit $[, $stxsep]? $[, allowTrailingSep]?)) =>
-    mkSplicePat `sepBy id ((isStrLit? sep).get! ++ "*")
-  | `(macroArg|$id:ident:$stx) => mkAntiquotNode id
-  | `(macroArg|$s:strLit) => strLitToPattern s
-  -- `"tk"%id` ~> `"tk"%$id`
-  | `(macroArg|$s:macroArgSymbol) => mkNode `token_antiquot #[← strLitToPattern s[0], mkAtom "%", mkAtom "$", s[1][1]]
-  | _                          => Macro.throwUnsupported
-  where mkSplicePat kind id suffix :=
-    mkNullNode #[mkAntiquotSuffixSpliceNode kind (mkAntiquotNode id) suffix]
-
-@[builtinMacro Lean.Parser.Command.macro] def expandMacro : Macro
-  | `($[$doc?:docComment]? $attrKind:attrKind
-      macro$[:$prec?]? $[(name := $name?)]? $[(priority := $prio?)]? $head:macroArg $args:macroArg* :
-        $cat => $rhs) => do
-    let prio  ← evalOptPrio prio?
-    -- build parser
-    let stxPart  ← expandMacroArgIntoSyntaxItem head
-    let stxParts ← args.mapM expandMacroArgIntoSyntaxItem
-    let stxParts := #[stxPart] ++ stxParts
-    -- name
-    let name ← match name? with
-      | some name => pure name.getId
-      | none => mkNameFromParserSyntax cat.getId (mkNullNode stxParts)
-    -- build macro rules
-    let patHead ← expandMacroArgIntoPattern head
-    let patArgs ← args.mapM expandMacroArgIntoPattern
-    /- The command `syntax [<kind>] ...` adds the current namespace to the syntax node kind.
-      So, we must include current namespace when we create a pattern for the following `macro_rules` commands. -/
-    let pat := Syntax.node ((← Macro.getCurrNamespace) ++ name) (#[patHead] ++ patArgs)
-    let stxCmd ← `($[$doc?:docComment]? $attrKind:attrKind
-      syntax$[:$prec?]? (name := $(← mkIdentFromRef name)) (priority := $(quote prio)) $[$stxParts]* : $cat)
-    let macroRulesCmd ←
-      if rhs.getArgs.size == 1 then
-        -- `rhs` is a `term`
-        let rhs := rhs[0]
-        `($[$doc?:docComment]? macro_rules | `($pat) => $rhs)
-      else
-        -- `rhs` is of the form `` `( $body ) ``
-        let rhsBody := rhs[1]
-        `($[$doc?:docComment]? macro_rules | `($pat) => `($rhsBody))
-    return mkNullNode #[stxCmd, macroRulesCmd]
-  | _ => Macro.throwUnsupported
-
 builtin_initialize
   registerTraceClass `Elab.syntax
 
-@[inline] def withExpectedType (expectedType? : Option Expr) (x : Expr → TermElabM Expr) : TermElabM Expr := do
-  Term.tryPostponeIfNoneOrMVar expectedType?
-  let some expectedType ← pure expectedType?
-    | throwError "expected type must be known"
-  x expectedType
-
-def elabElabRulesAux (doc? : Option Syntax) (attrKind : Syntax) (k : SyntaxNodeKind) (cat? expty? : Option Syntax) (alts : Array Syntax) : CommandElabM Syntax := do
-  let alts ← alts.mapM fun alt => match alt with
-    | `(matchAltExpr| | $pats,* => $rhs) => do
-      let pat := pats.elemsAndSeps[0]
-      if !pat.isQuot then
-        throwUnsupportedSyntax
-      let quoted := getQuotContent pat
-      let k' := quoted.getKind
-      if checkRuleKind k' k then
-        pure alt
-      else if k' == choiceKind then
-         match quoted.getArgs.find? fun quotAlt => checkRuleKind quotAlt.getKind k with
-         | none        => throwErrorAt alt "invalid elab_rules alternative, expected syntax node kind '{k}'"
-         | some quoted =>
-           let pat := pat.setArg 1 quoted
-           let pats := pats.elemsAndSeps.set! 0 pat
-           `(matchAltExpr| | $pats,* => $rhs)
-      else
-        throwErrorAt alt "invalid elab_rules alternative, unexpected syntax node kind '{k'}'"
-    | _ => throwUnsupportedSyntax
-  let catName ← match cat?, expty? with
-    | some cat, _ => cat.getId
-    | _, some _   => `term
-    -- TODO: infer category from quotation kind, possibly even kind of quoted syntax?
-    | _, _        => throwError "invalid elab_rules command, specify category using `elab_rules : <cat> ...`"
-  if let some expId := expty? then
-    if catName == `term then
-      `($[$doc?:docComment]? @[termElab $(← mkIdentFromRef k):ident] def elabFn : Lean.Elab.Term.TermElab :=
-        fun stx expectedType? => Lean.Elab.Command.withExpectedType expectedType? fun $expId => match stx with
-          $alts:matchAlt* | _ => throwUnsupportedSyntax)
-    else
-      throwErrorAt expId "syntax category '{catName}' does not support expected type specification"
-  else if catName == `term then
-    `($[$doc?:docComment]? @[termElab $(← mkIdentFromRef k):ident] def elabFn : Lean.Elab.Term.TermElab :=
-      fun stx _ => match stx with
-        $alts:matchAlt* | _ => throwUnsupportedSyntax)
-  else if catName == `command then
-    `($[$doc?:docComment]? @[commandElab $(← mkIdentFromRef k):ident] def elabFn : Lean.Elab.Command.CommandElab :=
-      fun $alts:matchAlt* | _ => throwUnsupportedSyntax)
-  else if catName == `tactic then
-    `($[$doc?:docComment]? @[tactic $(← mkIdentFromRef k):ident] def elabFn : Lean.Elab.Tactic.Tactic :=
-      fun $alts:matchAlt* | _ => throwUnsupportedSyntax)
-  else
-    -- We considered making the command extensible and support new user-defined categories. We think it is unnecessary.
-    -- If users want this feature, they add their own `elab_rules` macro that uses this one as a fallback.
-    throwError "unsupported syntax category '{catName}'"
-
-@[builtinCommandElab «elab_rules»] def elabElabRules : CommandElab :=
-  adaptExpander fun stx => match stx with
-  | `($[$doc?:docComment]? $attrKind:attrKind elab_rules $[: $cat?]? $[<= $expty?]? $alts:matchAlt*) =>
-    expandNoKindMacroRulesAux alts "elab_rules" fun kind? alts =>
-      `($[$doc?:docComment]? $attrKind:attrKind elab_rules $[(kind := $(mkIdent <$> kind?))]? $[: $cat?]? $[<= $expty?]? $alts:matchAlt*)
-  | `($[$doc?:docComment]? $attrKind:attrKind elab_rules (kind := $kind) $[: $cat?]? $[<= $expty?]? $alts:matchAlt*) =>
-    do elabElabRulesAux doc? attrKind (← resolveSyntaxKind kind.getId) cat? expty? alts
-  | _  => throwUnsupportedSyntax
-
-@[builtinMacro Lean.Parser.Command.elab]
-def expandElab : Macro
-  | `($[$doc?:docComment]? $attrKind:attrKind
-    elab$[:$prec?]? $[(name := $name?)]? $[(priority := $prio?)]? $head:macroArg $args:macroArg* :
-      $cat $[<= $expectedType?]? => $rhs) => do
-    let prio    ← evalOptPrio prio?
-    let catName := cat.getId
-    -- build parser
-    let stxPart  ← expandMacroArgIntoSyntaxItem head
-    let stxParts ← args.mapM expandMacroArgIntoSyntaxItem
-    let stxParts := #[stxPart] ++ stxParts
-    -- name
-    let name ← match name? with
-      | some name => pure name.getId
-      | none => mkNameFromParserSyntax cat.getId (mkNullNode stxParts)
-    -- build pattern for syntax `match`
-    let patHead ← expandMacroArgIntoPattern head
-    let patArgs ← args.mapM expandMacroArgIntoPattern
-    let pat := Syntax.node ((← Macro.getCurrNamespace) ++ name) (#[patHead] ++ patArgs)
-    `($[$doc?:docComment]? $attrKind:attrKind syntax$[:$prec?]? (name := $(← mkIdentFromRef name)) (priority := $(quote prio)) $[$stxParts]* : $cat
-      $[$doc?:docComment]? elab_rules : $cat $[<= $expectedType?]? | `($pat) => $rhs)
-  | _ => Macro.throwUnsupported
-
 end Lean.Elab.Command

stage0/src/Lean/Elab/Tactic.lean

@@ -13,3 +13,4 @@ import Lean.Elab.Tactic.Match
 import Lean.Elab.Tactic.Rewrite
 import Lean.Elab.Tactic.Location
 import Lean.Elab.Tactic.Simp
+import Lean.Elab.Tactic.BuiltinTactic

stage0/src/Lean/Elab/Tactic/Basic.lean

@@ -341,9 +341,6 @@ def closeMainGoal (val : Expr) (checkUnassigned := true): TacticM Unit := do
     let gs ← tactic mvarId
     pure ((), gs)
 
-@[builtinTactic Lean.Parser.Tactic.«done»] def evalDone : Tactic := fun _ =>
-  done
-
 def tryTactic? (tactic : TacticM α) : TacticM (Option α) := do
   try
     pure (some (← tactic))
@@ -378,156 +375,10 @@ def tagUntaggedGoals (parentTag : Name) (newSuffix : Name) (newGoals : List MVar
         idx := idx + 1
     pure mctx
 
-@[builtinTactic seq1] def evalSeq1 : Tactic := fun stx => do
-  let args := stx[0].getArgs
-  for i in [:args.size] do
-    if i % 2 == 0 then
-      evalTactic args[i]
-    else
-      saveTacticInfoForToken args[i] -- add `TacticInfo` node for `;`
-
-@[builtinTactic paren] def evalParen : Tactic := fun stx =>
-  evalTactic stx[1]
-
-/- Evaluate `many (group (tactic >> optional ";")) -/
-private def evalManyTacticOptSemi (stx : Syntax) : TacticM Unit := do
-  stx.forArgsM fun seqElem => do
-    evalTactic seqElem[0]
-    saveTacticInfoForToken seqElem[1] -- add TacticInfo node for `;`
-
-@[builtinTactic tacticSeq1Indented] def evalTacticSeq1Indented : Tactic := fun stx =>
-  evalManyTacticOptSemi stx[0]
-
-@[builtinTactic tacticSeqBracketed] def evalTacticSeqBracketed : Tactic := fun stx => do
-  let initInfo ← mkInitialTacticInfo stx[0]
-  withRef stx[2] <| closeUsingOrAdmit do
-    -- save state before/after entering focus on `{`
-    withInfoContext (pure ()) initInfo
-    evalManyTacticOptSemi stx[1]
-
-@[builtinTactic Parser.Tactic.focus] def evalFocus : Tactic := fun stx => do
-  let mkInfo ← mkInitialTacticInfo stx[0]
-  focus do
-    -- show focused state on `focus`
-    withInfoContext (pure ()) mkInfo
-    evalTactic stx[1]
-
-private def getOptRotation (stx : Syntax) : Nat :=
-  if stx.isNone then 1 else stx[0].toNat
-
-@[builtinTactic Parser.Tactic.rotateLeft] def evalRotateLeft : Tactic := fun stx => do
-  let n := getOptRotation stx[1]
-  setGoals <| (← getGoals).rotateLeft n
-
-@[builtinTactic Parser.Tactic.rotateRight] def evalRotateRight : Tactic := fun stx => do
-  let n := getOptRotation stx[1]
-  setGoals <| (← getGoals).rotateRight n
-
-@[builtinTactic Parser.Tactic.open] def evalOpen : Tactic := fun stx => do
-  try
-    pushScope
-    let openDecls ← elabOpenDecl stx[1]
-    withTheReader Core.Context (fun ctx => { ctx with openDecls := openDecls }) do
-      evalTactic stx[3]
-  finally
-    popScope
-
-@[builtinTactic Parser.Tactic.set_option] def elabSetOption : Tactic := fun stx => do
-  let options ← Elab.elabSetOption stx[1] stx[2]
-  withTheReader Core.Context (fun ctx => { ctx with maxRecDepth := maxRecDepth.get options, options := options }) do
-    evalTactic stx[4]
-
-@[builtinTactic Parser.Tactic.allGoals] def evalAllGoals : Tactic := fun stx => do
-  let mvarIds ← getGoals
-  let mut mvarIdsNew := #[]
-  for mvarId in mvarIds do
-    unless (← isExprMVarAssigned mvarId) do
-      setGoals [mvarId]
-      try
-        evalTactic stx[1]
-        mvarIdsNew := mvarIdsNew ++ (← getUnsolvedGoals)
-      catch ex =>
-        logException ex
-        mvarIdsNew := mvarIdsNew.push mvarId
-  setGoals mvarIdsNew.toList
-
-@[builtinTactic tacticSeq] def evalTacticSeq : Tactic := fun stx =>
-  evalTactic stx[0]
-
-partial def evalChoiceAux (tactics : Array Syntax) (i : Nat) : TacticM Unit :=
-  if h : i < tactics.size then
-    let tactic := tactics.get ⟨i, h⟩
-    catchInternalId unsupportedSyntaxExceptionId
-      (evalTactic tactic)
-      (fun _ => evalChoiceAux tactics (i+1))
-  else
-    throwUnsupportedSyntax
-
-@[builtinTactic choice] def evalChoice : Tactic := fun stx =>
-  evalChoiceAux stx.getArgs 0
-
-@[builtinTactic skip] def evalSkip : Tactic := fun stx => pure ()
-
-@[builtinTactic unknown] def evalUnknown : Tactic := fun stx => do
-  addCompletionInfo <| CompletionInfo.tactic stx (← getGoals)
-
-@[builtinTactic failIfSuccess] def evalFailIfSuccess : Tactic := fun stx => do
-  let tactic := stx[1]
-  if (← try evalTactic tactic; pure true catch _ => pure false) then
-    throwError "tactic succeeded"
-
-@[builtinTactic traceState] def evalTraceState : Tactic := fun stx => do
-  let gs ← getUnsolvedGoals
-  logInfo (goalsToMessageData gs)
-
-@[builtinTactic Lean.Parser.Tactic.assumption] def evalAssumption : Tactic := fun stx =>
-  liftMetaTactic fun mvarId => do Meta.assumption mvarId; pure []
-
-@[builtinTactic Lean.Parser.Tactic.contradiction] def evalContradiction : Tactic := fun stx =>
-  liftMetaTactic fun mvarId => do Meta.contradiction mvarId; pure []
-
-@[builtinTactic Lean.Parser.Tactic.intro] def evalIntro : Tactic := fun stx => do
-  match stx with
-  | `(tactic| intro)                   => introStep `_
-  | `(tactic| intro $h:ident)          => introStep h.getId
-  | `(tactic| intro _)                 => introStep `_
-  | `(tactic| intro $pat:term)         => evalTactic (← `(tactic| intro h; match h with | $pat:term => ?_; try clear h))
-  | `(tactic| intro $h:term $hs:term*) => evalTactic (← `(tactic| intro $h:term; intro $hs:term*))
-  | _ => throwUnsupportedSyntax
-where
-  introStep (n : Name) : TacticM Unit :=
-    liftMetaTactic fun mvarId => do
-      let (_, mvarId) ← Meta.intro mvarId n
-      pure [mvarId]
-
-@[builtinTactic Lean.Parser.Tactic.introMatch] def evalIntroMatch : Tactic := fun stx => do
-  let matchAlts := stx[1]
-  let stxNew ← liftMacroM <| Term.expandMatchAltsIntoMatchTactic stx matchAlts
-  withMacroExpansion stx stxNew <| evalTactic stxNew
-
-private def getIntrosSize : Expr → Nat
-  | Expr.forallE _ _ b _ => getIntrosSize b + 1
-  | Expr.letE _ _ _ b _  => getIntrosSize b + 1
-  | Expr.mdata _ b _     => getIntrosSize b
-  | _                    => 0
-
 /- Recall that `ident' := ident <|> Term.hole` -/
 def getNameOfIdent' (id : Syntax) : Name :=
   if id.isIdent then id.getId else `_
 
-@[builtinTactic «intros»] def evalIntros : Tactic := fun stx =>
-  match stx with
-  | `(tactic| intros) => liftMetaTactic fun mvarId => do
-    let type ← Meta.getMVarType mvarId
-    let type ← instantiateMVars type
-    let n := getIntrosSize type
-    let (_, mvarId) ← Meta.introN mvarId n
-    pure [mvarId]
-  | `(tactic| intros $ids*) => liftMetaTactic fun mvarId => do
-    let (_, mvarId) ← Meta.introN mvarId ids.size (ids.map getNameOfIdent').toList
-    pure [mvarId]
-  | _ => throwUnsupportedSyntax
-
 def getFVarId (id : Syntax) : TacticM FVarId := withRef id do
   let fvar? ← Term.isLocalIdent? id;
   match fvar? with
@@ -537,56 +388,6 @@ def getFVarId (id : Syntax) : TacticM FVarId := withRef id do
 def getFVarIds (ids : Array Syntax) : TacticM (Array FVarId) := do
   withMainContext do ids.mapM getFVarId
 
-@[builtinTactic Lean.Parser.Tactic.revert] def evalRevert : Tactic := fun stx =>
-  match stx with
-  | `(tactic| revert $hs*) => do
-     let (_, mvarId) ← Meta.revert (← getMainGoal) (← getFVarIds hs)
-     replaceMainGoal [mvarId]
-  | _                     => throwUnsupportedSyntax
-
-/- Sort free variables using an order `x < y` iff `x` was defined after `y` -/
-private def sortFVarIds (fvarIds : Array FVarId) : TacticM (Array FVarId) :=
-  withMainContext do
-    let lctx ← getLCtx
-    return fvarIds.qsort fun fvarId₁ fvarId₂ =>
-      match lctx.find? fvarId₁, lctx.find? fvarId₂ with
-      | some d₁, some d₂ => d₁.index > d₂.index
-      | some _,  none    => false
-      | none,    some _  => true
-      | none,    none    => Name.quickLt fvarId₁ fvarId₂
-
-@[builtinTactic Lean.Parser.Tactic.clear] def evalClear : Tactic := fun stx =>
-  match stx with
-  | `(tactic| clear $hs*) => do
-    let fvarIds ← getFVarIds hs
-    let fvarIds ← sortFVarIds fvarIds
-    for fvarId in fvarIds do
-      withMainContext do
-        let mvarId ← clear (← getMainGoal) fvarId
-        replaceMainGoal [mvarId]
-  | _ => throwUnsupportedSyntax
-
-def forEachVar (hs : Array Syntax) (tac : MVarId → FVarId → MetaM MVarId) : TacticM Unit := do
-  for h in hs do
-    withMainContext do
-      let fvarId ← getFVarId h
-      let mvarId ← tac (← getMainGoal) (← getFVarId h)
-      replaceMainGoal [mvarId]
-
-@[builtinTactic Lean.Parser.Tactic.subst] def evalSubst : Tactic := fun stx =>
-  match stx with
-  | `(tactic| subst $hs*) => forEachVar hs Meta.subst
-  | _                     => throwUnsupportedSyntax
-
-/--
-  First method searches for a metavariable `g` s.t. `tag` is a suffix of its name.
-  If none is found, then it searches for a metavariable `g` s.t. `tag` is a prefix of its name. -/
-private def findTag? (mvarIds : List MVarId) (tag : Name) : TacticM (Option MVarId) := do
-  let mvarId? ← mvarIds.findM? fun mvarId => return tag.isSuffixOf (← getMVarDecl mvarId).userName
-  match mvarId? with
-  | some mvarId => return mvarId
-  | none        => mvarIds.findM? fun mvarId => return tag.isPrefixOf (← getMVarDecl mvarId).userName
-
 /--
   Use position of `=> $body` for error messages.
   If there is a line break before `body`, the message will be displayed on `=>` only,
@@ -594,59 +395,6 @@ private def findTag? (mvarIds : List MVarId) (tag : Name) : TacticM (Option MVar
 def withCaseRef [Monad m] [MonadRef m] (arrow body : Syntax) (x : m α) : m α :=
   withRef (mkNullNode #[arrow, body]) x
 
-@[builtinTactic «case»] def evalCase : Tactic
-  | stx@`(tactic| case $tag $hs* =>%$arr $tac:tacticSeq) => do
-    let tag := tag.getId
-    let gs ← getUnsolvedGoals
-    let some g ← findTag? gs tag | throwError "tag not found"
-    let gs := gs.erase g
-    let mut g := g
-    unless hs.isEmpty do
-      let mvarDecl ← getMVarDecl g
-      let mut lctx := mvarDecl.lctx
-      let mut hs   := hs
-      let n := lctx.numIndices
-      for i in [:n] do
-        let j := n - i - 1
-        match lctx.getAt? j with
-        | none => pure ()
-        | some localDecl =>
-          if localDecl.userName.hasMacroScopes then
-            let h := hs.back
-            if h.isIdent then
-              let newName := h.getId
-              lctx := lctx.setUserName localDecl.fvarId newName
-            hs := hs.pop
-            if hs.isEmpty then
-              break
-      unless hs.isEmpty do
-        logError m!"too many variable names provided at 'case'"
-      let mvarNew ← mkFreshExprMVarAt lctx mvarDecl.localInstances mvarDecl.type MetavarKind.syntheticOpaque mvarDecl.userName
-      assignExprMVar g mvarNew
-      g := mvarNew.mvarId!
-    setGoals [g]
-    let savedTag ← getMVarTag g
-    setMVarTag g Name.anonymous
-    try
-      withCaseRef arr tac do
-        closeUsingOrAdmit (withTacticInfoContext stx (evalTactic tac))
-    finally
-      setMVarTag g savedTag
-    done
-    setGoals gs
-  | _ => throwUnsupportedSyntax
-
-@[builtinTactic «first»] partial def evalFirst : Tactic := fun stx => do
-  let tacs := stx[1].getArgs
-  if tacs.isEmpty then throwUnsupportedSyntax
-  loop tacs 0
-where
-  loop (tacs : Array Syntax) (i : Nat) :=
-    if i == tacs.size - 1 then
-      evalTactic tacs[i][1]
-    else
-      evalTactic tacs[i][1] <|> loop tacs (i+1)
-
 builtin_initialize registerTraceClass `Elab.tactic
 
 end Lean.Elab.Tactic

stage0/src/Lean/Elab/Tactic/BuiltinTactic.lean

@@ -0,0 +1,263 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.Tactic.Basic
+
+namespace Lean.Elab.Tactic
+open Meta
+
+@[builtinTactic Lean.Parser.Tactic.«done»] def evalDone : Tactic := fun _ =>
+  done
+
+@[builtinTactic seq1] def evalSeq1 : Tactic := fun stx => do
+  let args := stx[0].getArgs
+  for i in [:args.size] do
+    if i % 2 == 0 then
+      evalTactic args[i]
+    else
+      saveTacticInfoForToken args[i] -- add `TacticInfo` node for `;`
+
+@[builtinTactic paren] def evalParen : Tactic := fun stx =>
+  evalTactic stx[1]
+
+/- Evaluate `many (group (tactic >> optional ";")) -/
+private def evalManyTacticOptSemi (stx : Syntax) : TacticM Unit := do
+  stx.forArgsM fun seqElem => do
+    evalTactic seqElem[0]
+    saveTacticInfoForToken seqElem[1] -- add TacticInfo node for `;`
+
+@[builtinTactic tacticSeq1Indented] def evalTacticSeq1Indented : Tactic := fun stx =>
+  evalManyTacticOptSemi stx[0]
+
+@[builtinTactic tacticSeqBracketed] def evalTacticSeqBracketed : Tactic := fun stx => do
+  let initInfo ← mkInitialTacticInfo stx[0]
+  withRef stx[2] <| closeUsingOrAdmit do
+    -- save state before/after entering focus on `{`
+    withInfoContext (pure ()) initInfo
+    evalManyTacticOptSemi stx[1]
+
+@[builtinTactic Parser.Tactic.focus] def evalFocus : Tactic := fun stx => do
+  let mkInfo ← mkInitialTacticInfo stx[0]
+  focus do
+    -- show focused state on `focus`
+    withInfoContext (pure ()) mkInfo
+    evalTactic stx[1]
+
+private def getOptRotation (stx : Syntax) : Nat :=
+  if stx.isNone then 1 else stx[0].toNat
+
+@[builtinTactic Parser.Tactic.rotateLeft] def evalRotateLeft : Tactic := fun stx => do
+  let n := getOptRotation stx[1]
+  setGoals <| (← getGoals).rotateLeft n
+
+@[builtinTactic Parser.Tactic.rotateRight] def evalRotateRight : Tactic := fun stx => do
+  let n := getOptRotation stx[1]
+  setGoals <| (← getGoals).rotateRight n
+
+@[builtinTactic Parser.Tactic.open] def evalOpen : Tactic := fun stx => do
+  try
+    pushScope
+    let openDecls ← elabOpenDecl stx[1]
+    withTheReader Core.Context (fun ctx => { ctx with openDecls := openDecls }) do
+      evalTactic stx[3]
+  finally
+    popScope
+
+@[builtinTactic Parser.Tactic.set_option] def elabSetOption : Tactic := fun stx => do
+  let options ← Elab.elabSetOption stx[1] stx[2]
+  withTheReader Core.Context (fun ctx => { ctx with maxRecDepth := maxRecDepth.get options, options := options }) do
+    evalTactic stx[4]
+
+@[builtinTactic Parser.Tactic.allGoals] def evalAllGoals : Tactic := fun stx => do
+  let mvarIds ← getGoals
+  let mut mvarIdsNew := #[]
+  for mvarId in mvarIds do
+    unless (← isExprMVarAssigned mvarId) do
+      setGoals [mvarId]
+      try
+        evalTactic stx[1]
+        mvarIdsNew := mvarIdsNew ++ (← getUnsolvedGoals)
+      catch ex =>
+        logException ex
+        mvarIdsNew := mvarIdsNew.push mvarId
+  setGoals mvarIdsNew.toList
+
+@[builtinTactic tacticSeq] def evalTacticSeq : Tactic := fun stx =>
+  evalTactic stx[0]
+
+partial def evalChoiceAux (tactics : Array Syntax) (i : Nat) : TacticM Unit :=
+  if h : i < tactics.size then
+    let tactic := tactics.get ⟨i, h⟩
+    catchInternalId unsupportedSyntaxExceptionId
+      (evalTactic tactic)
+      (fun _ => evalChoiceAux tactics (i+1))
+  else
+    throwUnsupportedSyntax
+
+@[builtinTactic choice] def evalChoice : Tactic := fun stx =>
+  evalChoiceAux stx.getArgs 0
+
+@[builtinTactic skip] def evalSkip : Tactic := fun stx => pure ()
+
+@[builtinTactic unknown] def evalUnknown : Tactic := fun stx => do
+  addCompletionInfo <| CompletionInfo.tactic stx (← getGoals)
+
+@[builtinTactic failIfSuccess] def evalFailIfSuccess : Tactic := fun stx => do
+  let tactic := stx[1]
+  if (← try evalTactic tactic; pure true catch _ => pure false) then
+    throwError "tactic succeeded"
+
+@[builtinTactic traceState] def evalTraceState : Tactic := fun stx => do
+  let gs ← getUnsolvedGoals
+  logInfo (goalsToMessageData gs)
+
+@[builtinTactic Lean.Parser.Tactic.assumption] def evalAssumption : Tactic := fun stx =>
+  liftMetaTactic fun mvarId => do Meta.assumption mvarId; pure []
+
+@[builtinTactic Lean.Parser.Tactic.contradiction] def evalContradiction : Tactic := fun stx =>
+  liftMetaTactic fun mvarId => do Meta.contradiction mvarId; pure []
+
+@[builtinTactic Lean.Parser.Tactic.intro] def evalIntro : Tactic := fun stx => do
+  match stx with
+  | `(tactic| intro)                   => introStep `_
+  | `(tactic| intro $h:ident)          => introStep h.getId
+  | `(tactic| intro _)                 => introStep `_
+  | `(tactic| intro $pat:term)         => evalTactic (← `(tactic| intro h; match h with | $pat:term => ?_; try clear h))
+  | `(tactic| intro $h:term $hs:term*) => evalTactic (← `(tactic| intro $h:term; intro $hs:term*))
+  | _ => throwUnsupportedSyntax
+where
+  introStep (n : Name) : TacticM Unit :=
+    liftMetaTactic fun mvarId => do
+      let (_, mvarId) ← Meta.intro mvarId n
+      pure [mvarId]
+
+@[builtinTactic Lean.Parser.Tactic.introMatch] def evalIntroMatch : Tactic := fun stx => do
+  let matchAlts := stx[1]
+  let stxNew ← liftMacroM <| Term.expandMatchAltsIntoMatchTactic stx matchAlts
+  withMacroExpansion stx stxNew <| evalTactic stxNew
+
+private def getIntrosSize : Expr → Nat
+  | Expr.forallE _ _ b _ => getIntrosSize b + 1
+  | Expr.letE _ _ _ b _  => getIntrosSize b + 1
+  | Expr.mdata _ b _     => getIntrosSize b
+  | _                    => 0
+
+@[builtinTactic «intros»] def evalIntros : Tactic := fun stx =>
+  match stx with
+  | `(tactic| intros) => liftMetaTactic fun mvarId => do
+    let type ← Meta.getMVarType mvarId
+    let type ← instantiateMVars type
+    let n := getIntrosSize type
+    let (_, mvarId) ← Meta.introN mvarId n
+    pure [mvarId]
+  | `(tactic| intros $ids*) => liftMetaTactic fun mvarId => do
+    let (_, mvarId) ← Meta.introN mvarId ids.size (ids.map getNameOfIdent').toList
+    pure [mvarId]
+  | _ => throwUnsupportedSyntax
+
+@[builtinTactic Lean.Parser.Tactic.revert] def evalRevert : Tactic := fun stx =>
+  match stx with
+  | `(tactic| revert $hs*) => do
+     let (_, mvarId) ← Meta.revert (← getMainGoal) (← getFVarIds hs)
+     replaceMainGoal [mvarId]
+  | _                     => throwUnsupportedSyntax
+
+/- Sort free variables using an order `x < y` iff `x` was defined after `y` -/
+private def sortFVarIds (fvarIds : Array FVarId) : TacticM (Array FVarId) :=
+  withMainContext do
+    let lctx ← getLCtx
+    return fvarIds.qsort fun fvarId₁ fvarId₂ =>
+      match lctx.find? fvarId₁, lctx.find? fvarId₂ with
+      | some d₁, some d₂ => d₁.index > d₂.index
+      | some _,  none    => false
+      | none,    some _  => true
+      | none,    none    => Name.quickLt fvarId₁ fvarId₂
+
+@[builtinTactic Lean.Parser.Tactic.clear] def evalClear : Tactic := fun stx =>
+  match stx with
+  | `(tactic| clear $hs*) => do
+    let fvarIds ← getFVarIds hs
+    let fvarIds ← sortFVarIds fvarIds
+    for fvarId in fvarIds do
+      withMainContext do
+        let mvarId ← clear (← getMainGoal) fvarId
+        replaceMainGoal [mvarId]
+  | _ => throwUnsupportedSyntax
+
+def forEachVar (hs : Array Syntax) (tac : MVarId → FVarId → MetaM MVarId) : TacticM Unit := do
+  for h in hs do
+    withMainContext do
+      let fvarId ← getFVarId h
+      let mvarId ← tac (← getMainGoal) (← getFVarId h)
+      replaceMainGoal [mvarId]
+
+@[builtinTactic Lean.Parser.Tactic.subst] def evalSubst : Tactic := fun stx =>
+  match stx with
+  | `(tactic| subst $hs*) => forEachVar hs Meta.subst
+  | _                     => throwUnsupportedSyntax
+
+/--
+  First method searches for a metavariable `g` s.t. `tag` is a suffix of its name.
+  If none is found, then it searches for a metavariable `g` s.t. `tag` is a prefix of its name. -/
+private def findTag? (mvarIds : List MVarId) (tag : Name) : TacticM (Option MVarId) := do
+  let mvarId? ← mvarIds.findM? fun mvarId => return tag.isSuffixOf (← getMVarDecl mvarId).userName
+  match mvarId? with
+  | some mvarId => return mvarId
+  | none        => mvarIds.findM? fun mvarId => return tag.isPrefixOf (← getMVarDecl mvarId).userName
+
+@[builtinTactic «case»] def evalCase : Tactic
+  | stx@`(tactic| case $tag $hs* =>%$arr $tac:tacticSeq) => do
+    let tag := tag.getId
+    let gs ← getUnsolvedGoals
+    let some g ← findTag? gs tag | throwError "tag not found"
+    let gs := gs.erase g
+    let mut g := g
+    unless hs.isEmpty do
+      let mvarDecl ← getMVarDecl g
+      let mut lctx := mvarDecl.lctx
+      let mut hs   := hs
+      let n := lctx.numIndices
+      for i in [:n] do
+        let j := n - i - 1
+        match lctx.getAt? j with
+        | none => pure ()
+        | some localDecl =>
+          if localDecl.userName.hasMacroScopes then
+            let h := hs.back
+            if h.isIdent then
+              let newName := h.getId
+              lctx := lctx.setUserName localDecl.fvarId newName
+            hs := hs.pop
+            if hs.isEmpty then
+              break
+      unless hs.isEmpty do
+        logError m!"too many variable names provided at 'case'"
+      let mvarNew ← mkFreshExprMVarAt lctx mvarDecl.localInstances mvarDecl.type MetavarKind.syntheticOpaque mvarDecl.userName
+      assignExprMVar g mvarNew
+      g := mvarNew.mvarId!
+    setGoals [g]
+    let savedTag ← getMVarTag g
+    setMVarTag g Name.anonymous
+    try
+      withCaseRef arr tac do
+        closeUsingOrAdmit (withTacticInfoContext stx (evalTactic tac))
+    finally
+      setMVarTag g savedTag
+    done
+    setGoals gs
+  | _ => throwUnsupportedSyntax
+
+@[builtinTactic «first»] partial def evalFirst : Tactic := fun stx => do
+  let tacs := stx[1].getArgs
+  if tacs.isEmpty then throwUnsupportedSyntax
+  loop tacs 0
+where
+  loop (tacs : Array Syntax) (i : Nat) :=
+    if i == tacs.size - 1 then
+      evalTactic tacs[i][1]
+    else
+      evalTactic tacs[i][1] <|> loop tacs (i+1)
+
+end Lean.Elab.Tactic

stage0/src/Lean/Elab/Tactic/Simp.lean

@@ -50,7 +50,7 @@ private def addDeclToUnfoldOrLemma (lemmas : Meta.SimpLemmas) (e : Expr) (post :
     lemmas.add #[] e post
 
 private def addSimpLemma (lemmas : Meta.SimpLemmas) (stx : Syntax) (post : Bool) : TermElabM Meta.SimpLemmas := do
-  let (levelParams, proof) ← Term.withoutModifyingElabMetaState <| withRef stx <| Term.withoutErrToSorry do
+  let (levelParams, proof) ← Term.withoutModifyingElabMetaStateWithInfo <| withRef stx <| Term.withoutErrToSorry do
     let e ← Term.elabTerm stx none
     Term.synthesizeSyntheticMVars (mayPostpone := false) (ignoreStuckTC := true)
     let e ← instantiateMVars e

stage0/src/Lean/Elab/Term.lean

@@ -230,7 +230,7 @@ def getMessageLog : TermElabM MessageLog :=
   We use `observing` to implement overloaded notation and decls.
   We want to save `Info` nodes for the chosen alternative.
 -/
-@[inline] def observing (x : TermElabM α) : TermElabM (TermElabResult α) := do
+def observing (x : TermElabM α) : TermElabM (TermElabResult α) := do
   let s ← saveState
   try
     let e ← x
@@ -250,7 +250,7 @@ def getMessageLog : TermElabM MessageLog :=
 /--
   Apply the result/exception and state captured with `observing`.
   We use this method to implement overloaded notation and symbols. -/
-@[inline] def applyResult (result : TermElabResult α) : TermElabM α :=
+def applyResult (result : TermElabResult α) : TermElabM α :=
   match result with
   | EStateM.Result.ok a r     => do r.restore (restoreInfo := true); pure a
   | EStateM.Result.error ex r => do r.restore (restoreInfo := true); throw ex
@@ -264,20 +264,6 @@ def commitIfDidNotPostpone (x : TermElabM α) : TermElabM α := do
   let r ← observing x
   applyResult r
 
-/--
-  Execute `x` but discard changes performed at `Term.State` and `Meta.State`.
-  Recall that the environment is at `Core.State`. Thus, any updates to it will
-  be preserved. This method is useful for performing computations where all
-  metavariable must be resolved or discarded. -/
-def withoutModifyingElabMetaState (x : TermElabM α) : TermElabM α := do
-  let s ← get
-  let sMeta ← getThe Meta.State
-  try
-    x
-  finally
-    set s
-    set sMeta
-
 def getLevelNames : TermElabM (List Name) :=
   return (← get).levelNames
 
@@ -306,7 +292,7 @@ instance : MonadLog TermElabM where
 protected def getCurrMacroScope : TermElabM MacroScope := do pure (← read).currMacroScope
 protected def getMainModule     : TermElabM Name := do pure (← getEnv).mainModule
 
-@[inline] protected def withFreshMacroScope (x : TermElabM α) : TermElabM α := do
+protected def withFreshMacroScope (x : TermElabM α) : TermElabM α := do
   let fresh ← modifyGetThe Core.State (fun st => (st.nextMacroScope, { st with nextMacroScope := st.nextMacroScope + 1 }))
   withReader (fun ctx => { ctx with currMacroScope := fresh }) x
 
@@ -319,6 +305,22 @@ instance : MonadInfoTree TermElabM where
   getInfoState      := return (← get).infoState
   modifyInfoState f := modify fun s => { s with infoState := f s.infoState }
 
+/--
+  Execute `x` but discard changes performed at `Term.State` and `Meta.State`.
+  Recall that the environment is at `Core.State`. Thus, any updates to it will
+  be preserved. This method is useful for performing computations where all
+  metavariable must be resolved or discarded.
+  The info trees are not discarded, however, and wrapped in `InfoTree.Context`
+  to store their metavariable context. -/
+def withoutModifyingElabMetaStateWithInfo (x : TermElabM α) : TermElabM α := do
+  let s ← get
+  let sMeta ← getThe Meta.State
+  try
+     withSaveInfoContext x
+  finally
+    modify ({ s with infoState := ·.infoState })
+    set sMeta
+
 unsafe def mkTermElabAttributeUnsafe : IO (KeyedDeclsAttribute TermElab) :=
   mkElabAttribute TermElab `Lean.Elab.Term.termElabAttribute `builtinTermElab `termElab `Lean.Parser.Term `Lean.Elab.Term.TermElab "term"
 
@@ -380,8 +382,8 @@ def throwErrorIfErrors : TermElabM Unit := do
   if (← get).messages.hasErrors then
     throwError "Error(s)"
 
-@[inline] def traceAtCmdPos (cls : Name) (msg : Unit → MessageData) : TermElabM Unit :=
-withRef Syntax.missing $ trace cls msg
+def traceAtCmdPos (cls : Name) (msg : Unit → MessageData) : TermElabM Unit :=
+  withRef Syntax.missing $ trace cls msg
 
 def ppGoal (mvarId : MVarId) : TermElabM Format :=
   Meta.ppGoal mvarId
@@ -401,7 +403,7 @@ def elabLevel (stx : Syntax) : TermElabM Level :=
   liftLevelM $ Level.elabLevel stx
 
 /- Elaborate `x` with `stx` on the macro stack -/
-@[inline] def withMacroExpansion (beforeStx afterStx : Syntax) (x : TermElabM α) : TermElabM α :=
+def withMacroExpansion (beforeStx afterStx : Syntax) (x : TermElabM α) : TermElabM α :=
   withMacroExpansionInfo beforeStx afterStx do
     withReader (fun ctx => { ctx with macroStack := { before := beforeStx, after := afterStx } :: ctx.macroStack }) x
 
@@ -497,7 +499,7 @@ def ensureNoUnassignedMVars (decl : Declaration) : TermElabM Unit := do
 /-
   Execute `x` without allowing it to postpone elaboration tasks.
   That is, `tryPostpone` is a noop. -/
-@[inline] def withoutPostponing (x : TermElabM α) : TermElabM α :=
+def withoutPostponing (x : TermElabM α) : TermElabM α :=
   withReader (fun ctx => { ctx with mayPostpone := false }) x
 
 /-- Creates syntax for `(` <ident> `:` <type> `)` -/
@@ -585,7 +587,7 @@ def throwTypeMismatchError (header? : Option String) (expectedType : Expr) (eTyp
   | none   => throwError "{← mkTypeMismatchError header? e eType expectedType}{extraMsg}"
   | some f => Meta.throwAppTypeMismatch f e extraMsg
 
-@[inline] def withoutMacroStackAtErr (x : TermElabM α) : TermElabM α :=
+def withoutMacroStackAtErr (x : TermElabM α) : TermElabM α :=
   withTheReader Core.Context (fun (ctx : Core.Context) => { ctx with options := pp.macroStack.set ctx.options false }) x
 
 /- Try to synthesize metavariable using type class resolution.
@@ -911,7 +913,7 @@ def tryPostponeIfHasMVars (expectedType? : Option Expr) (msg : String) : TermEla
     throwError "{msg}, expected type contains metavariables{indentExpr expectedType}"
   pure expectedType
 
-private def saveContext : TermElabM SavedContext :=
+def saveContext : TermElabM SavedContext :=
   return {
     macroStack := (← read).macroStack
     declName?  := (← read).declName?
@@ -1300,113 +1302,6 @@ def isLetRecAuxMVar (mvarId : MVarId) : TermElabM Bool := do
   trace[Elab.letrec] "mvarId root: {mkMVar mvarId}"
   return (← get).letRecsToLift.any (·.mvarId == mvarId)
 
-/- =======================================
-       Builtin elaboration functions
-   ======================================= -/
-
-@[builtinTermElab «prop»] def elabProp : TermElab := fun _ _ =>
-  return mkSort levelZero
-
-private def elabOptLevel (stx : Syntax) : TermElabM Level :=
-  if stx.isNone then
-    pure levelZero
-  else
-    elabLevel stx[0]
-
-@[builtinTermElab «sort»] def elabSort : TermElab := fun stx _ =>
-  return mkSort (← elabOptLevel stx[1])
-
-@[builtinTermElab «type»] def elabTypeStx : TermElab := fun stx _ =>
-  return mkSort (mkLevelSucc (← elabOptLevel stx[1]))
-
-/-
- the method `resolveName` adds a completion point for it using the given
-    expected type. Thus, we propagate the expected type if `stx[0]` is an identifier.
-    It doesn't "hurt" if the identifier can be resolved because the expected type is not used in this case.
-    Recall that if the name resolution fails a synthetic sorry is returned.-/
-
-@[builtinTermElab «pipeCompletion»] def elabPipeCompletion : TermElab := fun stx expectedType? => do
-  let e ← elabTerm stx[0] none
-  unless e.isSorry do
-    addDotCompletionInfo stx e expectedType?
-  throwErrorAt stx[1] "invalid field notation, identifier or numeral expected"
-
-@[builtinTermElab «completion»] def elabCompletion : TermElab := fun stx expectedType? => do
-  /- `ident.` is ambiguous in Lean, we may try to be completing a declaration name or access a "field". -/
-  if stx[0].isIdent then
-    /- If we can elaborate the identifier successfully, we assume it a dot-completion. Otherwise, we treat it as
-       identifier completion with a dangling `.`.
-       Recall that the server falls back to identifier completion when dot-completion fails. -/
-    let s ← saveState
-    try
-      let e ← elabTerm stx[0] none
-      addDotCompletionInfo stx e expectedType?
-    catch _ =>
-      s.restore
-      addCompletionInfo <| CompletionInfo.id stx stx[0].getId (danglingDot := true) (← getLCtx) expectedType?
-    throwErrorAt stx[1] "invalid field notation, identifier or numeral expected"
-  else
-    elabPipeCompletion stx expectedType?
-
-@[builtinTermElab «hole»] def elabHole : TermElab := fun stx expectedType? => do
-  let mvar ← mkFreshExprMVar expectedType?
-  registerMVarErrorHoleInfo mvar.mvarId! stx
-  pure mvar
-
-@[builtinTermElab «syntheticHole»] def elabSyntheticHole : TermElab := fun stx expectedType? => do
-  let arg  := stx[1]
-  let userName := if arg.isIdent then arg.getId else Name.anonymous
-  let mkNewHole : Unit → TermElabM Expr := fun _ => do
-    let mvar ← mkFreshExprMVar expectedType? MetavarKind.syntheticOpaque userName
-    registerMVarErrorHoleInfo mvar.mvarId! stx
-    pure mvar
-  if userName.isAnonymous then
-    mkNewHole ()
-  else
-    let mctx ← getMCtx
-    match mctx.findUserName? userName with
-    | none => mkNewHole ()
-    | some mvarId =>
-      let mvar := mkMVar mvarId
-      let mvarDecl ← getMVarDecl mvarId
-      let lctx ← getLCtx
-      if mvarDecl.lctx.isSubPrefixOf lctx then
-        pure mvar
-      else match mctx.getExprAssignment? mvarId with
-      | some val =>
-        let val ← instantiateMVars val
-        if mctx.isWellFormed lctx val then
-          pure val
-        else
-          withLCtx mvarDecl.lctx mvarDecl.localInstances do
-            throwError "synthetic hole has already been defined and assigned to value incompatible with the current context{indentExpr val}"
-      | none =>
-        if mctx.isDelayedAssigned mvarId then
-          -- We can try to improve this case if needed.
-          throwError "synthetic hole has already beend defined and delayed assigned with an incompatible local context"
-        else if lctx.isSubPrefixOf mvarDecl.lctx then
-          let mvarNew ← mkNewHole ()
-          modifyMCtx fun mctx => mctx.assignExpr mvarId mvarNew
-          pure mvarNew
-        else
-          throwError "synthetic hole has already been defined with an incompatible local context"
-
-private def mkTacticMVar (type : Expr) (tacticCode : Syntax) : TermElabM Expr := do
-  let mvar ← mkFreshExprMVar type MetavarKind.syntheticOpaque
-  let mvarId := mvar.mvarId!
-  let ref ← getRef
-  let declName? ← getDeclName?
-  registerSyntheticMVar ref mvarId <| SyntheticMVarKind.tactic tacticCode (← saveContext)
-  return mvar
-
-@[builtinTermElab byTactic] def elabByTactic : TermElab := fun stx expectedType? =>
-  match expectedType? with
-  | some expectedType => mkTacticMVar expectedType stx
-  | none => throwError ("invalid 'by' tactic, expected type has not been provided")
-
-@[builtinTermElab noImplicitLambda] def elabNoImplicitLambda : TermElab := fun stx expectedType? =>
-  elabTerm stx[1] (mkNoImplicitLambdaAnnotation <$> expectedType?)
-
 def resolveLocalName (n : Name) : TermElabM (Option (Expr × List String)) := do
   let lctx ← getLCtx
   let view := extractMacroScopes n
@@ -1524,104 +1419,18 @@ def resolveId? (stx : Syntax) (kind := "term") (withInfo := false) : TermElabM (
     | _   => throwError "ambiguous {kind}, use fully qualified name, possible interpretations {fs}"
   | _ => throwError "identifier expected"
 
-@[builtinTermElab cdot] def elabBadCDot : TermElab := fun stx _ =>
-  throwError "invalid occurrence of `·` notation, it must be surrounded by parentheses (e.g. `(· + 1)`)"
-
-@[builtinTermElab strLit] def elabStrLit : TermElab := fun stx _ => do
-  match stx.isStrLit? with
-  | some val => pure $ mkStrLit val
-  | none     => throwIllFormedSyntax
-
-private def mkFreshTypeMVarFor (expectedType? : Option Expr) : TermElabM Expr := do
-  let typeMVar ← mkFreshTypeMVar MetavarKind.synthetic
-  match expectedType? with
-  | some expectedType => discard <| isDefEq expectedType typeMVar
-  | _                 => pure ()
-  return typeMVar
-
-@[builtinTermElab numLit] def elabNumLit : TermElab := fun stx expectedType? => do
-  let val ← match stx.isNatLit? with
-    | some val => pure val
-    | none     => throwIllFormedSyntax
-  let typeMVar ← mkFreshTypeMVarFor expectedType?
-  let u ← getDecLevel typeMVar
-  let mvar ← mkInstMVar (mkApp2 (Lean.mkConst ``OfNat [u]) typeMVar (mkNatLit val))
-  let r := mkApp3 (Lean.mkConst ``OfNat.ofNat [u]) typeMVar (mkNatLit val) mvar
-  registerMVarErrorImplicitArgInfo mvar.mvarId! stx r
-  return r
-
-@[builtinTermElab rawNatLit] def elabRawNatLit : TermElab :=  fun stx expectedType? => do
-  match stx[1].isNatLit? with
-  | some val => return mkNatLit val
-  | none     => throwIllFormedSyntax
-
-@[builtinTermElab scientificLit]
-def elabScientificLit : TermElab := fun stx expectedType? => do
-  match stx.isScientificLit? with
-  | none        => throwIllFormedSyntax
-  | some (m, sign, e) =>
-    let typeMVar ← mkFreshTypeMVarFor expectedType?
-    let u ← getDecLevel typeMVar
-    let mvar ← mkInstMVar (mkApp (Lean.mkConst ``OfScientific [u]) typeMVar)
-    return mkApp5 (Lean.mkConst ``OfScientific.ofScientific [u]) typeMVar mvar (mkNatLit m) (toExpr sign) (mkNatLit e)
-
-@[builtinTermElab charLit] def elabCharLit : TermElab := fun stx _ => do
-  match stx.isCharLit? with
-  | some val => return mkApp (Lean.mkConst ``Char.ofNat) (mkNatLit val.toNat)
-  | none     => throwIllFormedSyntax
-
-@[builtinTermElab quotedName] def elabQuotedName : TermElab := fun stx _ =>
-  match stx[0].isNameLit? with
-  | some val => pure $ toExpr val
-  | none     => throwIllFormedSyntax
-
-@[builtinTermElab doubleQuotedName] def elabDoubleQuotedName : TermElab := fun stx _ => do
-  match stx[1].isNameLit? with
-  | some val => toExpr (← resolveGlobalConstNoOverloadWithInfo stx[1] val)
-  | none     => throwIllFormedSyntax
-
-@[builtinTermElab typeOf] def elabTypeOf : TermElab := fun stx _ => do
-  inferType (← elabTerm stx[1] none)
-
-@[builtinTermElab ensureTypeOf] def elabEnsureTypeOf : TermElab := fun stx expectedType? =>
-  match stx[2].isStrLit? with
-  | none     => throwIllFormedSyntax
-  | some msg => do
-    let refTerm ← elabTerm stx[1] none
-    let refTermType ← inferType refTerm
-    elabTermEnsuringType stx[3] refTermType (errorMsgHeader? := msg)
-
-@[builtinTermElab ensureExpectedType] def elabEnsureExpectedType : TermElab := fun stx expectedType? =>
-  match stx[1].isStrLit? with
-  | none     => throwIllFormedSyntax
-  | some msg => elabTermEnsuringType stx[2] expectedType? (errorMsgHeader? := msg)
-
-@[builtinTermElab «open»] def elabOpen : TermElab := fun stx expectedType? => do
-  try
-    pushScope
-    let openDecls ← elabOpenDecl stx[1]
-    withTheReader Core.Context (fun ctx => { ctx with openDecls := openDecls }) do
-      elabTerm stx[3] expectedType?
-  finally
-    popScope
-
-@[builtinTermElab «set_option»] def elabSetOption : TermElab := fun stx expectedType? => do
-  let options ← Elab.elabSetOption stx[1] stx[2]
-  withTheReader Core.Context (fun ctx => { ctx with maxRecDepth := maxRecDepth.get options, options := options }) do
-    elabTerm stx[4] expectedType?
-
 private def mkSomeContext : Context := {
   fileName      := "<TermElabM>"
   fileMap       := arbitrary
 }
 
-@[inline] def TermElabM.run (x : TermElabM α) (ctx : Context := mkSomeContext) (s : State := {}) : MetaM (α × State) :=
+def TermElabM.run (x : TermElabM α) (ctx : Context := mkSomeContext) (s : State := {}) : MetaM (α × State) :=
   withConfig setElabConfig (x ctx |>.run s)
 
 @[inline] def TermElabM.run' (x : TermElabM α) (ctx : Context := mkSomeContext) (s : State := {}) : MetaM α :=
   (·.1) <$> x.run ctx s
 
-@[inline] def TermElabM.toIO (x : TermElabM α)
+def TermElabM.toIO (x : TermElabM α)
     (ctxCore : Core.Context) (sCore : Core.State)
     (ctxMeta : Meta.Context) (sMeta : Meta.State)
     (ctx : Context) (s : State) : IO (α × Core.State × Meta.State × State) := do
@@ -1669,7 +1478,7 @@ private def throwStuckAtUniverseCnstr : TermElabM Unit := do
     logErrorAt uniqueEntries[i].ref (← mkLevelStuckErrorMessage uniqueEntries[i])
   throwErrorAt uniqueEntries[0].ref (← mkLevelStuckErrorMessage uniqueEntries[0])
 
-@[specialize] def withoutPostponingUniverseConstraints (x : TermElabM α) : TermElabM α := do
+def withoutPostponingUniverseConstraints (x : TermElabM α) : TermElabM α := do
   let postponed ← getResetPostponed
   try
     let a ← x

stage0/src/Lean/Meta/Match/Match.lean

@@ -542,7 +542,7 @@ private def expandNatValuePattern (p : Problem) : Problem := do
     | _                                                     => alt
   { p with alts := alts }
 
-private def traceStep (msg : String) : StateRefT State MetaM Unit :=
+private def traceStep (msg : String) : StateRefT State MetaM Unit := do
   trace[Meta.Match.match] "{msg} step"
 
 private def traceState (p : Problem) : MetaM Unit :=

stage0/src/Lean/Meta/Tactic/Clear.lean

@@ -21,7 +21,7 @@ def clear (mvarId : MVarId) (fvarId : FVarId) : MetaM MVarId :=
           throwTacticEx `clear mvarId m!"variable '{localDecl.toExpr}' depends on '{mkFVar fvarId}'"
     let mvarDecl ← getMVarDecl mvarId
     if mctx.exprDependsOn mvarDecl.type fvarId then
-      throwTacticEx `clear mvarId m!"taget depends on '{mkFVar fvarId}'"
+      throwTacticEx `clear mvarId m!"target depends on '{mkFVar fvarId}'"
     let lctx := lctx.erase fvarId
     let localInsts ← getLocalInstances
     let localInsts := match localInsts.findIdx? $ fun localInst => localInst.fvar.fvarId! == fvarId with

stage0/src/Lean/Server/FileWorker.lean

@@ -355,7 +355,12 @@ def workerMain : IO UInt32 := do
   let o ← IO.getStdout
   let e ← IO.getStderr
   try
-    initAndRunWorker i o e
+    let exitCode ← initAndRunWorker i o e
+    -- HACK: all `Task`s are currently "foreground", i.e. we join on them on main thread exit, but we definitely don't
+    -- want to do that in the case of the worker processes, which can produce non-terminating tasks evaluating user code
+    o.flush
+    e.flush
+    IO.Process.exit exitCode.toUInt8
   catch err =>
     e.putStrLn s!"worker initialization error: {err}"
     return (1 : UInt32)

stage0/src/Lean/Server/InfoUtils.lean

@@ -131,8 +131,10 @@ partial def InfoTree.hoverableInfoAt? (t : InfoTree) (hoverPos : String.Pos) : O
 def Info.fmtHover? (ci : ContextInfo) (i : Info) : IO (Option Format) := do
   ci.runMetaM i.lctx do
     let mut fmts := #[]
-    if let some f ← fmtTerm? then
-      fmts := fmts.push f
+    try
+      if let some f ← fmtTerm? then
+        fmts := fmts.push f
+    catch _ => pure ()
     if let some f ← fmtDoc? then
       fmts := fmts.push f
     if fmts.isEmpty then

stage0/src/Lean/Server/Snapshots.lean

@@ -104,7 +104,7 @@ def compileNextCmd (contents : String) (snap : Snapshot) : IO (Sum Snapshot Mess
     let (output, _) ← IO.FS.withIsolatedStreams do
       EIO.toIO ioErrorFromEmpty do
         Elab.Command.catchExceptions
-          (Elab.Command.elabCommand cmdStx)
+          (Elab.Command.elabCommandTopLevel cmdStx)
           cmdCtx cmdStateRef
     let mut postCmdState ← cmdStateRef.get
     if !output.isEmpty then

stage0/src/Lean/Syntax.lean

@@ -215,7 +215,7 @@ partial def reprint (stx : Syntax) : Option String :=
           -- given that choice nodes are quite rare and small
           let s0 ← reprint args[0]
           for arg in args[1:] do
-            let s' ← reprint stx
+            let s' ← reprint arg
             guard (s0 == s')
       | _ => pure ()
     return s

stage0/src/Lean/Util/Trace.lean

@@ -135,15 +135,12 @@ end
 def registerTraceClass (traceClassName : Name) : IO Unit :=
   registerOption (`trace ++ traceClassName) { group := "trace", defValue := false, descr := "enable/disable tracing for the given module and submodules" }
 
-syntax "trace[" ident "]" (interpolatedStr(term) <|> term) : term
-
-macro_rules
-  | `(trace[$id] $s) =>
-    if s.getKind == interpolatedStrKind then
-      `(Lean.trace $(quote id.getId) fun _ => m! $s)
-    else
-      `(Lean.trace $(quote id.getId) fun _ => ($s : MessageData))
-
+macro "trace[" id:ident "]" s:(interpolatedStr(term) <|> term) : doElem => do
+  let msg ← if s.getKind == interpolatedStrKind then `(m! $s) else `(($s : MessageData))
+  `(doElem| do
+    let cls := $(quote id.getId)
+    if (← Lean.isTracingEnabledFor cls) then
+      Lean.addTrace cls $msg)
 
 private def withNestedTracesFinalizer [Monad m] [MonadTrace m] (ref : Syntax) (currTraces : PersistentArray TraceElem) : m Unit := do
   modifyTraces fun traces =>

stage0/src/include/lean/lean.h

@@ -293,6 +293,9 @@ static inline lean_object * lean_box(size_t n) { return (lean_object*)(((size_t)
 static inline size_t lean_unbox(lean_object * o) { return (size_t)(o) >> 1; }
 
 void lean_set_exit_on_panic(bool flag);
+/* Enable/disable panic messages */
+void lean_set_panic_messages(bool flag);
+
 lean_object * lean_panic_fn(lean_object * default_val, lean_object * msg);
 
 __attribute__((noreturn)) void lean_internal_panic(char const * msg);

stage0/src/runtime/io.cpp

@@ -837,8 +837,8 @@ extern "C" obj_res lean_io_wait_any(b_obj_arg task_list, obj_arg) {
     return io_result_mk_ok(v);
 }
 
-extern "C" obj_res lean_io_exit(obj_arg obj, obj_arg /* w */) {
-    exit((size_t) obj);
+extern "C" obj_res lean_io_exit(uint8_t code, obj_arg /* w */) {
+    exit(code);
 }
 
 void initialize_io() {

stage0/src/runtime/object.cpp

@@ -42,14 +42,21 @@ extern "C" void lean_internal_panic_rc_overflow() {
 }
 
 bool g_exit_on_panic = false;
+bool g_panic_messages = true;
 
 extern "C" void lean_set_exit_on_panic(bool flag) {
     g_exit_on_panic = flag;
 }
 
+extern "C" void lean_set_panic_messages(bool flag) {
+    g_panic_messages = flag;
+}
+
 extern "C" object * lean_panic_fn(object * default_val, object * msg) {
     // TODO(Leo, Kha): add thread local buffer for interpreter.
-    std::cerr << lean_string_cstr(msg) << "\n";
+    if (g_panic_messages) {
+        std::cerr << lean_string_cstr(msg) << "\n";
+    }
     if (g_exit_on_panic) {
         std::exit(1);
     }

stage0/stdlib/Init/Coe.c

@@ -13,20 +13,19 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__12;
 lean_object* l_coeTC(lean_object*, lean_object*);
+lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(lean_object*, lean_object*);
 lean_object* l_coeBase___rarg(lean_object*);
-lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(lean_object*, lean_object*);
 lean_object* l_instCoeDep___rarg(lean_object*, lean_object*);
 lean_object* l_coeOfHead___rarg(lean_object*);
 lean_object* l_coeTail___rarg(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__11;
 lean_object* l_instCoeTail__1___rarg(lean_object*, lean_object*);
 lean_object* l_coeOfDep___rarg___boxed(lean_object*);
 lean_object* l_coeOfDep(lean_object*, lean_object*, lean_object*);
 lean_object* l_instCoeTail___rarg(lean_object*, lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 extern lean_object* l_Lean_nullKind;
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__1;
 lean_object* l_instHDiv__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_coeD___rarg(lean_object*);
 lean_object* l_coeOfTCOfTail(lean_object*, lean_object*, lean_object*);
@@ -38,18 +37,22 @@ lean_object* l_coeOfHTCT___rarg(lean_object*, lean_object*);
 lean_object* l_instHDiv__1(lean_object*, lean_object*);
 lean_object* l_coeTC___rarg(lean_object*, lean_object*);
 lean_object* l_coeTail(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__9;
 lean_object* l_coeOfTC___rarg(lean_object*);
 static lean_object* l_term_u2191_____closed__7;
 lean_object* l_coeFun(lean_object*, lean_object*);
 uint8_t l_decPropToBool___rarg(uint8_t);
 lean_object* l_coeBase(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__17;
 lean_object* l_coeTrans(lean_object*, lean_object*, lean_object*);
 lean_object* l_coeB___rarg(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__8;
 lean_object* l_coeOfTail(lean_object*, lean_object*);
 lean_object* l_instHDiv__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* l_instHSub__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_term_u2191_____closed__3;
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__2;
 lean_object* l_instHMul__2(lean_object*, lean_object*);
 lean_object* l_coeOfHeadOfTC___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_instHAndThen__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -59,21 +62,17 @@ lean_object* l_coeSort___rarg(lean_object*, lean_object*);
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* l_instCoeDep(lean_object*, lean_object*);
 lean_object* l_hasOfNatOfCoe___rarg(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__4;
 lean_object* l_instHAdd__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_term_u2191_____closed__11;
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__4;
 lean_object* l_instHAdd__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instHSub__2(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__2;
 lean_object* l_liftCoeM___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_coeOfHTCT(lean_object*, lean_object*);
 lean_object* l_boolToSort;
 lean_object* l_coeOfHeadOfTC(lean_object*, lean_object*, lean_object*);
 lean_object* l_coeOfTCOfTail___rarg(lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__8;
 lean_object* l_instHOrElse__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__17;
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__9;
 lean_object* l_instHSub__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_coe___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_instHMod__1(lean_object*, lean_object*);
@@ -81,70 +80,71 @@ lean_object* l_subtypeCoe___rarg___boxed(lean_object*);
 lean_object* l_coeOfHead(lean_object*, lean_object*);
 static lean_object* l_term_u2191_____closed__2;
 lean_object* l_instHOrElse__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__1;
 lean_object* l_optionCoe___rarg(lean_object*);
 lean_object* l_instHAppend__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_hasOfNatOfCoe(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__11;
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__12;
 lean_object* l_instHMod__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_coeOfDep___rarg(lean_object*);
 lean_object* l_instHAdd__1(lean_object*, lean_object*);
 lean_object* l_coeOfTC(lean_object*, lean_object*);
 uint8_t l_coeDecidableEq(uint8_t);
 static lean_object* l_term_u2191_____closed__1;
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__5;
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__14;
 lean_object* l_coeD___rarg___boxed(lean_object*);
 static lean_object* l_term_u2191_____closed__9;
 lean_object* l_liftCoeM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_term_u2191_____closed__8;
 lean_object* l_coeOfTail___rarg(lean_object*);
 lean_object* l_coe___rarg(lean_object*);
+lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_2002____spec__1(lean_object*);
 lean_object* l_hasOfNatOfCoe___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__7;
 static lean_object* l_term_u2191_____closed__4;
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__18;
 lean_object* l_coe(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isNodeOf(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__15;
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__3;
 lean_object* l_coeDecidableEq___boxed(lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__16;
 lean_object* l_instCoeTail__1(lean_object*, lean_object*);
 lean_object* l_coeOfDep___boxed(lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__6;
 static lean_object* l_term_u2191_____closed__5;
 lean_object* l_instHMod__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_coeTrans___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_optionCoe(lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__10;
 lean_object* l_instHMod__2(lean_object*, lean_object*);
 lean_object* l_instHAppend__2(lean_object*, lean_object*);
 lean_object* l_coeM(lean_object*, lean_object*, lean_object*);
 lean_object* l_unexpand____x40_Init_Coe___hyg_147_(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__13;
 lean_object* l_coeId(lean_object*);
 lean_object* l_subtypeCoe___rarg(lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__13;
 lean_object* l_coeFun___rarg(lean_object*, lean_object*);
 lean_object* l_instHAndThen__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_coeB(lean_object*, lean_object*);
 lean_object* l_subtypeCoe(lean_object*, lean_object*);
 lean_object* l_term_u2191__;
 lean_object* l_coeSort(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Coe___hyg_162_(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Coe___hyg_163_(lean_object*, lean_object*, lean_object*);
 lean_object* l_instHAppend__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_coeM___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__10;
 lean_object* l_liftCoeM(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instHMul__1(lean_object*, lean_object*);
 lean_object* l_coeOfHeafOfTCOfTail___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__6;
 lean_object* l_coe___rarg___boxed(lean_object*);
 lean_object* l_boolToProp;
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 static lean_object* l_term_u2191_____closed__6;
 lean_object* l_coeHead___rarg(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__16;
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__15;
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__18;
 lean_object* l_coeId___rarg(lean_object*);
 lean_object* l_coeId___rarg___boxed(lean_object*);
 lean_object* l_instHAndThen__1(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__7;
 lean_object* l_instCoeTail(lean_object*, lean_object*);
 lean_object* l_coeD___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_instHAdd__2(lean_object*, lean_object*);
@@ -154,9 +154,9 @@ lean_object* l_instHOrElse__1(lean_object*, lean_object*);
 lean_object* l_instHAppend__1(lean_object*, lean_object*);
 lean_object* l_decPropToBool(lean_object*);
 lean_object* l_coeOfHeafOfTCOfTail(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_1981____spec__1(lean_object*);
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__5;
 lean_object* l_coeHead(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Coe___hyg_162____closed__3;
+static lean_object* l_myMacro____x40_Init_Coe___hyg_163____closed__14;
 lean_object* l_instHMul__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_coeD(lean_object*, lean_object*, lean_object*);
 lean_object* l_coeB___rarg(lean_object* x_1, lean_object* x_2) {
@@ -409,7 +409,7 @@ x_1 = l_term_u2191_____closed__11;
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__1() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -417,17 +417,17 @@ x_1 = lean_mk_string("Lean");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__2() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Coe___hyg_162____closed__1;
+x_2 = l_myMacro____x40_Init_Coe___hyg_163____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__3() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -435,17 +435,17 @@ x_1 = lean_mk_string("Parser");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__4() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Coe___hyg_162____closed__2;
-x_2 = l_myMacro____x40_Init_Coe___hyg_162____closed__3;
+x_1 = l_myMacro____x40_Init_Coe___hyg_163____closed__2;
+x_2 = l_myMacro____x40_Init_Coe___hyg_163____closed__3;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__5() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__5() {
 _start:
 {
 lean_object* x_1; 
@@ -453,17 +453,17 @@ x_1 = lean_mk_string("Term");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__6() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Coe___hyg_162____closed__4;
-x_2 = l_myMacro____x40_Init_Coe___hyg_162____closed__5;
+x_1 = l_myMacro____x40_Init_Coe___hyg_163____closed__4;
+x_2 = l_myMacro____x40_Init_Coe___hyg_163____closed__5;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__7() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__7() {
 _start:
 {
 lean_object* x_1; 
@@ -471,17 +471,17 @@ x_1 = lean_mk_string("app");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__8() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Coe___hyg_162____closed__6;
-x_2 = l_myMacro____x40_Init_Coe___hyg_162____closed__7;
+x_1 = l_myMacro____x40_Init_Coe___hyg_163____closed__6;
+x_2 = l_myMacro____x40_Init_Coe___hyg_163____closed__7;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__9() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__9() {
 _start:
 {
 lean_object* x_1; 
@@ -489,22 +489,22 @@ x_1 = lean_mk_string("coe");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__10() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__10() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_Coe___hyg_162____closed__9;
+x_1 = l_myMacro____x40_Init_Coe___hyg_163____closed__9;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__11() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__11() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_Coe___hyg_162____closed__9;
+x_1 = l_myMacro____x40_Init_Coe___hyg_163____closed__9;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_Coe___hyg_162____closed__10;
+x_3 = l_myMacro____x40_Init_Coe___hyg_163____closed__10;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -512,41 +512,41 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__12() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__12() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Coe___hyg_162____closed__9;
+x_2 = l_myMacro____x40_Init_Coe___hyg_163____closed__9;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__13() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Coe___hyg_162____closed__12;
+x_2 = l_myMacro____x40_Init_Coe___hyg_163____closed__12;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__14() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__14() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Coe___hyg_162____closed__13;
+x_2 = l_myMacro____x40_Init_Coe___hyg_163____closed__13;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__15() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__15() {
 _start:
 {
 lean_object* x_1; 
@@ -554,17 +554,17 @@ x_1 = lean_mk_string("null");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__16() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__16() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Coe___hyg_162____closed__15;
+x_2 = l_myMacro____x40_Init_Coe___hyg_163____closed__15;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__17() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__17() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -573,7 +573,7 @@ x_2 = lean_mk_empty_array_with_capacity(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_162____closed__18() {
+static lean_object* _init_l_myMacro____x40_Init_Coe___hyg_163____closed__18() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -582,7 +582,7 @@ x_2 = lean_mk_empty_array_with_capacity(x_1);
 return x_2;
 }
 }
-lean_object* l_myMacro____x40_Init_Coe___hyg_162_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_myMacro____x40_Init_Coe___hyg_163_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -606,7 +606,7 @@ lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11;
 x_8 = lean_unsigned_to_nat(1u);
 x_9 = l_Lean_Syntax_getArg(x_1, x_8);
 lean_dec(x_1);
-x_10 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(x_2, x_3);
+x_10 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(x_2, x_3);
 x_11 = !lean_is_exclusive(x_10);
 if (x_11 == 0)
 {
@@ -617,25 +617,25 @@ lean_inc(x_13);
 x_14 = lean_ctor_get(x_2, 1);
 lean_inc(x_14);
 lean_dec(x_2);
-x_15 = l_myMacro____x40_Init_Coe___hyg_162____closed__12;
+x_15 = l_myMacro____x40_Init_Coe___hyg_163____closed__12;
 x_16 = l_Lean_addMacroScope(x_14, x_15, x_13);
-x_17 = l_myMacro____x40_Init_Coe___hyg_162____closed__11;
-x_18 = l_myMacro____x40_Init_Coe___hyg_162____closed__14;
+x_17 = l_myMacro____x40_Init_Coe___hyg_163____closed__11;
+x_18 = l_myMacro____x40_Init_Coe___hyg_163____closed__14;
 x_19 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_19, 0, x_12);
 lean_ctor_set(x_19, 1, x_17);
 lean_ctor_set(x_19, 2, x_16);
 lean_ctor_set(x_19, 3, x_18);
-x_20 = l_myMacro____x40_Init_Coe___hyg_162____closed__17;
+x_20 = l_myMacro____x40_Init_Coe___hyg_163____closed__17;
 x_21 = lean_array_push(x_20, x_9);
-x_22 = l_myMacro____x40_Init_Coe___hyg_162____closed__16;
+x_22 = l_myMacro____x40_Init_Coe___hyg_163____closed__16;
 x_23 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_23, 0, x_22);
 lean_ctor_set(x_23, 1, x_21);
-x_24 = l_myMacro____x40_Init_Coe___hyg_162____closed__18;
+x_24 = l_myMacro____x40_Init_Coe___hyg_163____closed__18;
 x_25 = lean_array_push(x_24, x_19);
 x_26 = lean_array_push(x_25, x_23);
-x_27 = l_myMacro____x40_Init_Coe___hyg_162____closed__8;
+x_27 = l_myMacro____x40_Init_Coe___hyg_163____closed__8;
 x_28 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_28, 0, x_27);
 lean_ctor_set(x_28, 1, x_26);
@@ -655,25 +655,25 @@ lean_inc(x_31);
 x_32 = lean_ctor_get(x_2, 1);
 lean_inc(x_32);
 lean_dec(x_2);
-x_33 = l_myMacro____x40_Init_Coe___hyg_162____closed__12;
+x_33 = l_myMacro____x40_Init_Coe___hyg_163____closed__12;
 x_34 = l_Lean_addMacroScope(x_32, x_33, x_31);
-x_35 = l_myMacro____x40_Init_Coe___hyg_162____closed__11;
-x_36 = l_myMacro____x40_Init_Coe___hyg_162____closed__14;
+x_35 = l_myMacro____x40_Init_Coe___hyg_163____closed__11;
+x_36 = l_myMacro____x40_Init_Coe___hyg_163____closed__14;
 x_37 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_37, 0, x_29);
 lean_ctor_set(x_37, 1, x_35);
 lean_ctor_set(x_37, 2, x_34);
 lean_ctor_set(x_37, 3, x_36);
-x_38 = l_myMacro____x40_Init_Coe___hyg_162____closed__17;
+x_38 = l_myMacro____x40_Init_Coe___hyg_163____closed__17;
 x_39 = lean_array_push(x_38, x_9);
-x_40 = l_myMacro____x40_Init_Coe___hyg_162____closed__16;
+x_40 = l_myMacro____x40_Init_Coe___hyg_163____closed__16;
 x_41 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_41, 0, x_40);
 lean_ctor_set(x_41, 1, x_39);
-x_42 = l_myMacro____x40_Init_Coe___hyg_162____closed__18;
+x_42 = l_myMacro____x40_Init_Coe___hyg_163____closed__18;
 x_43 = lean_array_push(x_42, x_37);
 x_44 = lean_array_push(x_43, x_41);
-x_45 = l_myMacro____x40_Init_Coe___hyg_162____closed__8;
+x_45 = l_myMacro____x40_Init_Coe___hyg_163____closed__8;
 x_46 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_46, 0, x_45);
 lean_ctor_set(x_46, 1, x_44);
@@ -689,7 +689,7 @@ lean_object* l_unexpand____x40_Init_Coe___hyg_147_(lean_object* x_1, lean_object
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
-x_3 = l_myMacro____x40_Init_Coe___hyg_162____closed__8;
+x_3 = l_myMacro____x40_Init_Coe___hyg_163____closed__8;
 lean_inc(x_1);
 x_4 = l_Lean_Syntax_isOfKind(x_1, x_3);
 if (x_4 == 0)
@@ -727,7 +727,7 @@ lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16;
 x_13 = lean_unsigned_to_nat(0u);
 x_14 = l_Lean_Syntax_getArg(x_8, x_13);
 lean_dec(x_8);
-x_15 = l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_1981____spec__1(x_2);
+x_15 = l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_2002____spec__1(x_2);
 x_16 = !lean_is_exclusive(x_15);
 if (x_16 == 0)
 {
@@ -737,7 +737,7 @@ x_18 = l_term_u2191_____closed__5;
 x_19 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_19, 0, x_17);
 lean_ctor_set(x_19, 1, x_18);
-x_20 = l_myMacro____x40_Init_Coe___hyg_162____closed__18;
+x_20 = l_myMacro____x40_Init_Coe___hyg_163____closed__18;
 x_21 = lean_array_push(x_20, x_19);
 x_22 = lean_array_push(x_21, x_14);
 x_23 = l_term_u2191_____closed__2;
@@ -759,7 +759,7 @@ x_27 = l_term_u2191_____closed__5;
 x_28 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_28, 0, x_25);
 lean_ctor_set(x_28, 1, x_27);
-x_29 = l_myMacro____x40_Init_Coe___hyg_162____closed__18;
+x_29 = l_myMacro____x40_Init_Coe___hyg_163____closed__18;
 x_30 = lean_array_push(x_29, x_28);
 x_31 = lean_array_push(x_30, x_14);
 x_32 = l_term_u2191_____closed__2;
@@ -1548,42 +1548,42 @@ l_term_u2191_____closed__11 = _init_l_term_u2191_____closed__11();
 lean_mark_persistent(l_term_u2191_____closed__11);
 l_term_u2191__ = _init_l_term_u2191__();
 lean_mark_persistent(l_term_u2191__);
-l_myMacro____x40_Init_Coe___hyg_162____closed__1 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__1();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__1);
-l_myMacro____x40_Init_Coe___hyg_162____closed__2 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__2();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__2);
-l_myMacro____x40_Init_Coe___hyg_162____closed__3 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__3();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__3);
-l_myMacro____x40_Init_Coe___hyg_162____closed__4 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__4();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__4);
-l_myMacro____x40_Init_Coe___hyg_162____closed__5 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__5();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__5);
-l_myMacro____x40_Init_Coe___hyg_162____closed__6 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__6();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__6);
-l_myMacro____x40_Init_Coe___hyg_162____closed__7 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__7();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__7);
-l_myMacro____x40_Init_Coe___hyg_162____closed__8 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__8();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__8);
-l_myMacro____x40_Init_Coe___hyg_162____closed__9 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__9();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__9);
-l_myMacro____x40_Init_Coe___hyg_162____closed__10 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__10();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__10);
-l_myMacro____x40_Init_Coe___hyg_162____closed__11 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__11();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__11);
-l_myMacro____x40_Init_Coe___hyg_162____closed__12 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__12();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__12);
-l_myMacro____x40_Init_Coe___hyg_162____closed__13 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__13();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__13);
-l_myMacro____x40_Init_Coe___hyg_162____closed__14 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__14();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__14);
-l_myMacro____x40_Init_Coe___hyg_162____closed__15 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__15();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__15);
-l_myMacro____x40_Init_Coe___hyg_162____closed__16 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__16();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__16);
-l_myMacro____x40_Init_Coe___hyg_162____closed__17 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__17();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__17);
-l_myMacro____x40_Init_Coe___hyg_162____closed__18 = _init_l_myMacro____x40_Init_Coe___hyg_162____closed__18();
-lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_162____closed__18);
+l_myMacro____x40_Init_Coe___hyg_163____closed__1 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__1();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__1);
+l_myMacro____x40_Init_Coe___hyg_163____closed__2 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__2();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__2);
+l_myMacro____x40_Init_Coe___hyg_163____closed__3 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__3();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__3);
+l_myMacro____x40_Init_Coe___hyg_163____closed__4 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__4();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__4);
+l_myMacro____x40_Init_Coe___hyg_163____closed__5 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__5();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__5);
+l_myMacro____x40_Init_Coe___hyg_163____closed__6 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__6();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__6);
+l_myMacro____x40_Init_Coe___hyg_163____closed__7 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__7();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__7);
+l_myMacro____x40_Init_Coe___hyg_163____closed__8 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__8();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__8);
+l_myMacro____x40_Init_Coe___hyg_163____closed__9 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__9();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__9);
+l_myMacro____x40_Init_Coe___hyg_163____closed__10 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__10();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__10);
+l_myMacro____x40_Init_Coe___hyg_163____closed__11 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__11();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__11);
+l_myMacro____x40_Init_Coe___hyg_163____closed__12 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__12();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__12);
+l_myMacro____x40_Init_Coe___hyg_163____closed__13 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__13();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__13);
+l_myMacro____x40_Init_Coe___hyg_163____closed__14 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__14();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__14);
+l_myMacro____x40_Init_Coe___hyg_163____closed__15 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__15();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__15);
+l_myMacro____x40_Init_Coe___hyg_163____closed__16 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__16();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__16);
+l_myMacro____x40_Init_Coe___hyg_163____closed__17 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__17();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__17);
+l_myMacro____x40_Init_Coe___hyg_163____closed__18 = _init_l_myMacro____x40_Init_Coe___hyg_163____closed__18();
+lean_mark_persistent(l_myMacro____x40_Init_Coe___hyg_163____closed__18);
 l_boolToProp = _init_l_boolToProp();
 l_boolToSort = _init_l_boolToSort();
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Init/Control/Basic.c

@@ -13,136 +13,136 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_536____closed__4;
+lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(lean_object*, lean_object*);
 static lean_object* l_term___x3c_x7c_x7c_x3e_____closed__3;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_534____closed__4;
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 static lean_object* l_term___x3c_x26_x26_x3e_____closed__7;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_840____closed__5;
 extern lean_object* l_Lean_nullKind;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_term___x3c_x26_x3e__;
 lean_object* l_term___x3c_x7c_x7c_x3e__;
 static lean_object* l_unexpand____x40_Init_Control_Basic___hyg_38____closed__1;
 static lean_object* l_term___x3c_x7c_x7c_x3e_____closed__7;
 lean_object* l_instMonadControlT___rarg___lambda__3(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19;
 lean_object* l_control___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_unexpand____x40_Init_Control_Basic___hyg_502_(lean_object*, lean_object*);
-lean_object* l_unexpand____x40_Init_Control_Basic___hyg_808_(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__11;
+lean_object* l_unexpand____x40_Init_Control_Basic___hyg_503_(lean_object*, lean_object*);
+lean_object* l_unexpand____x40_Init_Control_Basic___hyg_810_(lean_object*, lean_object*);
 lean_object* l_unexpand____x40_Init_Control_Basic___hyg_38_(lean_object*, lean_object*);
 static lean_object* l_term___x3c_x7c_x7c_x3e_____closed__5;
 lean_object* l_guard___rarg(lean_object*, lean_object*, uint8_t);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__11;
 lean_object* l_controlAt___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instOrElse(lean_object*, lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_840____closed__4;
 lean_object* l_bool_match__1(lean_object*);
 lean_object* l_term___x3c_x26_x26_x3e__;
 static lean_object* l_term___x3c_x7c_x7c_x3e_____closed__2;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__12;
 lean_object* l_controlAt(lean_object*, lean_object*);
 static lean_object* l_term___x3c_x26_x26_x3e_____closed__3;
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* l_Functor_discard(lean_object*, lean_object*);
 lean_object* l_instMonadControlT(lean_object*, lean_object*, lean_object*);
 lean_object* l_Functor_mapRev(lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__12;
 lean_object* l_instMonadControlT__1___rarg___lambda__1___boxed(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_840____closed__3;
 static lean_object* l_term___x3c_x7c_x7c_x3e_____closed__1;
 lean_object* l_Functor_discard___rarg(lean_object*, lean_object*);
 static lean_object* l_optional___rarg___closed__1;
 static lean_object* l_term___x3c_x26_x3e_____closed__5;
 lean_object* l_instMonadControlT___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instMonadControlT__1(lean_object*);
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_843____closed__4;
 lean_object* l_not___boxed(lean_object*);
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_536____closed__6;
 lean_object* l_andM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_term___x3c_x26_x3e_____closed__1;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_534____closed__6;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20;
 lean_object* l_instOrElse___rarg(lean_object*);
 lean_object* l_instMonadControlT___rarg___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__10;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20;
 lean_object* l_optional___rarg(lean_object*, lean_object*, lean_object*);
 static lean_object* l_term___x3c_x26_x26_x3e_____closed__5;
 static lean_object* l_term___x3c_x7c_x7c_x3e_____closed__6;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__10;
 static lean_object* l_term___x3c_x26_x3e_____closed__8;
 lean_object* l_bool_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_instToBoolBool___boxed(lean_object*);
 lean_object* l_bool_match__1___rarg(uint8_t, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_843____closed__6;
 static lean_object* l_term___x3c_x26_x3e_____closed__4;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_843____closed__5;
 static lean_object* l_term___x3c_x26_x3e_____closed__9;
 static lean_object* l_notM___rarg___closed__1;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__16;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__16;
 lean_object* l_guard___rarg___boxed(lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_840____closed__6;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__7;
 static lean_object* l_term___x3c_x26_x3e_____closed__2;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__7;
 lean_object* l_orM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instMonadControlT__1___rarg___lambda__3(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Control_Basic___hyg_534_(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54_(lean_object*, lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Control_Basic___hyg_840_(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_843____closed__1;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_843____closed__2;
+lean_object* l_myMacro____x40_Init_Control_Basic___hyg_536_(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55_(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Control_Basic___hyg_843_(lean_object*, lean_object*, lean_object*);
 lean_object* l_instMonadControlT__1___rarg___lambda__2(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__3;
+lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_2002____spec__1(lean_object*);
 lean_object* l_bool___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__18;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__15;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__18;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__15;
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
 lean_object* l_instMonadControlT___rarg___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__14;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__3;
 lean_object* l_notM(lean_object*);
 uint8_t l_Lean_Syntax_isNodeOf(lean_object*, lean_object*, lean_object*);
 lean_object* l_instMonadControlT___rarg___lambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_bool(lean_object*, lean_object*);
 static lean_object* l_term___x3c_x26_x26_x3e_____closed__2;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__14;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__9;
 static lean_object* l_instMonadControlT__1___rarg___lambda__2___closed__1;
 lean_object* l_Functor_mapRev___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_instToBoolBool(uint8_t);
 static lean_object* l_term___x3c_x26_x3e_____closed__3;
 static lean_object* l_instMonadControlT__1___rarg___closed__1;
 lean_object* l_instMonadControlT___rarg(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_534____closed__1;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_536____closed__1;
 lean_object* l_orM___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_536____closed__2;
 static lean_object* l_term___x3c_x26_x3e_____closed__6;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__6;
 lean_object* l_instMonadControlT__1___rarg___lambda__1(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__5;
 lean_object* l_optional___rarg___lambda__1(lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_534____closed__2;
 lean_object* l_orM___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__6;
 static lean_object* l_term___x3c_x7c_x7c_x3e_____closed__4;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__5;
 lean_object* l_andM___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_term___x3c_x26_x26_x3e_____closed__6;
 lean_object* l_bool___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__13;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_840____closed__2;
 static lean_object* l_term___x3c_x26_x26_x3e_____closed__4;
 static lean_object* l_term___x3c_x26_x3e_____closed__11;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__13;
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__2;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_534____closed__5;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_840____closed__1;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_534____closed__3;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_843____closed__3;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__2;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_536____closed__3;
 lean_object* l_andM___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_andM(lean_object*, lean_object*);
 lean_object* l_guard(lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__1;
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
 lean_object* l_optional(lean_object*);
 lean_object* l_orM(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__17;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__1;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__4;
 lean_object* l_control(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__4;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55____closed__17;
 static lean_object* l_term___x3c_x26_x3e_____closed__7;
 lean_object* l_instMonadControlT__1___rarg(lean_object*);
-lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_1981____spec__1(lean_object*);
-static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54____closed__9;
 static lean_object* l_term___x3c_x26_x3e_____closed__10;
 lean_object* l_notM___rarg(lean_object*, lean_object*);
 static lean_object* l_term___x3c_x26_x26_x3e_____closed__1;
+static lean_object* l_myMacro____x40_Init_Control_Basic___hyg_536____closed__5;
 lean_object* l_Functor_mapRev___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
@@ -284,7 +284,7 @@ x_1 = l_term___x3c_x26_x3e_____closed__11;
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__1() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -292,17 +292,17 @@ x_1 = lean_mk_string("Lean");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__2() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__1;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__3() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -310,17 +310,17 @@ x_1 = lean_mk_string("Parser");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__4() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__2;
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__3;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__2;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__3;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__5() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__5() {
 _start:
 {
 lean_object* x_1; 
@@ -328,17 +328,17 @@ x_1 = lean_mk_string("Term");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__6() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__4;
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__5;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__4;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__5;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__7() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__7() {
 _start:
 {
 lean_object* x_1; 
@@ -346,17 +346,17 @@ x_1 = lean_mk_string("app");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__6;
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__7;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__6;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__7;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__9() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__9() {
 _start:
 {
 lean_object* x_1; 
@@ -364,22 +364,22 @@ x_1 = lean_mk_string("Functor.mapRev");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__10() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__10() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__9;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__9;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__11() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__11() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__9;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__9;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__10;
+x_3 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__10;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -387,7 +387,7 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__12() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__12() {
 _start:
 {
 lean_object* x_1; 
@@ -395,17 +395,17 @@ x_1 = lean_mk_string("Functor");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__13() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__12;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__12;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__14() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__14() {
 _start:
 {
 lean_object* x_1; 
@@ -413,41 +413,41 @@ x_1 = lean_mk_string("mapRev");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__15() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__15() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__13;
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__14;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__13;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__14;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__16() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__16() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__15;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__15;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__17() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__17() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__16;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__16;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__18() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__18() {
 _start:
 {
 lean_object* x_1; 
@@ -455,17 +455,17 @@ x_1 = lean_mk_string("null");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__18;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__18;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -474,7 +474,7 @@ x_2 = lean_mk_empty_array_with_capacity(x_1);
 return x_2;
 }
 }
-lean_object* l_myMacro____x40_Init_Control_Basic___hyg_54_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_myMacro____x40_Init_Control_Basic___hyg_55_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -500,7 +500,7 @@ x_9 = l_Lean_Syntax_getArg(x_1, x_8);
 x_10 = lean_unsigned_to_nat(2u);
 x_11 = l_Lean_Syntax_getArg(x_1, x_10);
 lean_dec(x_1);
-x_12 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(x_2, x_3);
+x_12 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(x_2, x_3);
 x_13 = !lean_is_exclusive(x_12);
 if (x_13 == 0)
 {
@@ -511,25 +511,25 @@ lean_inc(x_15);
 x_16 = lean_ctor_get(x_2, 1);
 lean_inc(x_16);
 lean_dec(x_2);
-x_17 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__15;
+x_17 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__15;
 x_18 = l_Lean_addMacroScope(x_16, x_17, x_15);
-x_19 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__11;
-x_20 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__17;
+x_19 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__11;
+x_20 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__17;
 x_21 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_21, 0, x_14);
 lean_ctor_set(x_21, 1, x_19);
 lean_ctor_set(x_21, 2, x_18);
 lean_ctor_set(x_21, 3, x_20);
-x_22 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20;
+x_22 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20;
 x_23 = lean_array_push(x_22, x_9);
 x_24 = lean_array_push(x_23, x_11);
-x_25 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19;
+x_25 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19;
 x_26 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_26, 0, x_25);
 lean_ctor_set(x_26, 1, x_24);
 x_27 = lean_array_push(x_22, x_21);
 x_28 = lean_array_push(x_27, x_26);
-x_29 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
+x_29 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
 x_30 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_30, 0, x_29);
 lean_ctor_set(x_30, 1, x_28);
@@ -549,25 +549,25 @@ lean_inc(x_33);
 x_34 = lean_ctor_get(x_2, 1);
 lean_inc(x_34);
 lean_dec(x_2);
-x_35 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__15;
+x_35 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__15;
 x_36 = l_Lean_addMacroScope(x_34, x_35, x_33);
-x_37 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__11;
-x_38 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__17;
+x_37 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__11;
+x_38 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__17;
 x_39 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_39, 0, x_31);
 lean_ctor_set(x_39, 1, x_37);
 lean_ctor_set(x_39, 2, x_36);
 lean_ctor_set(x_39, 3, x_38);
-x_40 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20;
+x_40 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20;
 x_41 = lean_array_push(x_40, x_9);
 x_42 = lean_array_push(x_41, x_11);
-x_43 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19;
+x_43 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19;
 x_44 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_44, 0, x_43);
 lean_ctor_set(x_44, 1, x_42);
 x_45 = lean_array_push(x_40, x_39);
 x_46 = lean_array_push(x_45, x_44);
-x_47 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
+x_47 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
 x_48 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_48, 0, x_47);
 lean_ctor_set(x_48, 1, x_46);
@@ -592,7 +592,7 @@ lean_object* l_unexpand____x40_Init_Control_Basic___hyg_38_(lean_object* x_1, le
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
-x_3 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
+x_3 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
 lean_inc(x_1);
 x_4 = l_Lean_Syntax_isOfKind(x_1, x_3);
 if (x_4 == 0)
@@ -632,7 +632,7 @@ x_14 = lean_unsigned_to_nat(0u);
 x_15 = l_Lean_Syntax_getArg(x_8, x_14);
 x_16 = l_Lean_Syntax_getArg(x_8, x_7);
 lean_dec(x_8);
-x_17 = l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_1981____spec__1(x_2);
+x_17 = l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_2002____spec__1(x_2);
 x_18 = !lean_is_exclusive(x_17);
 if (x_18 == 0)
 {
@@ -1055,7 +1055,7 @@ x_1 = l_term___x3c_x7c_x7c_x3e_____closed__7;
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__1() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1063,22 +1063,22 @@ x_1 = lean_mk_string("orM");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__2() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__1;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__1;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__3() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__1;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__1;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__2;
+x_3 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__2;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -1086,41 +1086,41 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__4() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__1;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__5() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__4;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__4;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__6() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__5;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__5;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_myMacro____x40_Init_Control_Basic___hyg_534_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_myMacro____x40_Init_Control_Basic___hyg_536_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -1146,7 +1146,7 @@ x_9 = l_Lean_Syntax_getArg(x_1, x_8);
 x_10 = lean_unsigned_to_nat(2u);
 x_11 = l_Lean_Syntax_getArg(x_1, x_10);
 lean_dec(x_1);
-x_12 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(x_2, x_3);
+x_12 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(x_2, x_3);
 x_13 = !lean_is_exclusive(x_12);
 if (x_13 == 0)
 {
@@ -1157,25 +1157,25 @@ lean_inc(x_15);
 x_16 = lean_ctor_get(x_2, 1);
 lean_inc(x_16);
 lean_dec(x_2);
-x_17 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__4;
+x_17 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__4;
 x_18 = l_Lean_addMacroScope(x_16, x_17, x_15);
-x_19 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__3;
-x_20 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__6;
+x_19 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__3;
+x_20 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__6;
 x_21 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_21, 0, x_14);
 lean_ctor_set(x_21, 1, x_19);
 lean_ctor_set(x_21, 2, x_18);
 lean_ctor_set(x_21, 3, x_20);
-x_22 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20;
+x_22 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20;
 x_23 = lean_array_push(x_22, x_9);
 x_24 = lean_array_push(x_23, x_11);
-x_25 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19;
+x_25 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19;
 x_26 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_26, 0, x_25);
 lean_ctor_set(x_26, 1, x_24);
 x_27 = lean_array_push(x_22, x_21);
 x_28 = lean_array_push(x_27, x_26);
-x_29 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
+x_29 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
 x_30 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_30, 0, x_29);
 lean_ctor_set(x_30, 1, x_28);
@@ -1195,25 +1195,25 @@ lean_inc(x_33);
 x_34 = lean_ctor_get(x_2, 1);
 lean_inc(x_34);
 lean_dec(x_2);
-x_35 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__4;
+x_35 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__4;
 x_36 = l_Lean_addMacroScope(x_34, x_35, x_33);
-x_37 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__3;
-x_38 = l_myMacro____x40_Init_Control_Basic___hyg_534____closed__6;
+x_37 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__3;
+x_38 = l_myMacro____x40_Init_Control_Basic___hyg_536____closed__6;
 x_39 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_39, 0, x_31);
 lean_ctor_set(x_39, 1, x_37);
 lean_ctor_set(x_39, 2, x_36);
 lean_ctor_set(x_39, 3, x_38);
-x_40 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20;
+x_40 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20;
 x_41 = lean_array_push(x_40, x_9);
 x_42 = lean_array_push(x_41, x_11);
-x_43 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19;
+x_43 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19;
 x_44 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_44, 0, x_43);
 lean_ctor_set(x_44, 1, x_42);
 x_45 = lean_array_push(x_40, x_39);
 x_46 = lean_array_push(x_45, x_44);
-x_47 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
+x_47 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
 x_48 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_48, 0, x_47);
 lean_ctor_set(x_48, 1, x_46);
@@ -1225,11 +1225,11 @@ return x_49;
 }
 }
 }
-lean_object* l_unexpand____x40_Init_Control_Basic___hyg_502_(lean_object* x_1, lean_object* x_2) {
+lean_object* l_unexpand____x40_Init_Control_Basic___hyg_503_(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
-x_3 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
+x_3 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
 lean_inc(x_1);
 x_4 = l_Lean_Syntax_isOfKind(x_1, x_3);
 if (x_4 == 0)
@@ -1269,7 +1269,7 @@ x_14 = lean_unsigned_to_nat(0u);
 x_15 = l_Lean_Syntax_getArg(x_8, x_14);
 x_16 = l_Lean_Syntax_getArg(x_8, x_7);
 lean_dec(x_8);
-x_17 = l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_1981____spec__1(x_2);
+x_17 = l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_2002____spec__1(x_2);
 x_18 = !lean_is_exclusive(x_17);
 if (x_18 == 0)
 {
@@ -1465,7 +1465,7 @@ x_1 = l_term___x3c_x26_x26_x3e_____closed__7;
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__1() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1473,22 +1473,22 @@ x_1 = lean_mk_string("andM");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__2() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__1;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__1;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__3() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__1;
+x_1 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__1;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__2;
+x_3 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__2;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -1496,41 +1496,41 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__4() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__1;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__5() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__4;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__4;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__6() {
+static lean_object* _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__5;
+x_2 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__5;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_myMacro____x40_Init_Control_Basic___hyg_840_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_myMacro____x40_Init_Control_Basic___hyg_843_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -1556,7 +1556,7 @@ x_9 = l_Lean_Syntax_getArg(x_1, x_8);
 x_10 = lean_unsigned_to_nat(2u);
 x_11 = l_Lean_Syntax_getArg(x_1, x_10);
 lean_dec(x_1);
-x_12 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(x_2, x_3);
+x_12 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(x_2, x_3);
 x_13 = !lean_is_exclusive(x_12);
 if (x_13 == 0)
 {
@@ -1567,25 +1567,25 @@ lean_inc(x_15);
 x_16 = lean_ctor_get(x_2, 1);
 lean_inc(x_16);
 lean_dec(x_2);
-x_17 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__4;
+x_17 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__4;
 x_18 = l_Lean_addMacroScope(x_16, x_17, x_15);
-x_19 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__3;
-x_20 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__6;
+x_19 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__3;
+x_20 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__6;
 x_21 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_21, 0, x_14);
 lean_ctor_set(x_21, 1, x_19);
 lean_ctor_set(x_21, 2, x_18);
 lean_ctor_set(x_21, 3, x_20);
-x_22 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20;
+x_22 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20;
 x_23 = lean_array_push(x_22, x_9);
 x_24 = lean_array_push(x_23, x_11);
-x_25 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19;
+x_25 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19;
 x_26 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_26, 0, x_25);
 lean_ctor_set(x_26, 1, x_24);
 x_27 = lean_array_push(x_22, x_21);
 x_28 = lean_array_push(x_27, x_26);
-x_29 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
+x_29 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
 x_30 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_30, 0, x_29);
 lean_ctor_set(x_30, 1, x_28);
@@ -1605,25 +1605,25 @@ lean_inc(x_33);
 x_34 = lean_ctor_get(x_2, 1);
 lean_inc(x_34);
 lean_dec(x_2);
-x_35 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__4;
+x_35 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__4;
 x_36 = l_Lean_addMacroScope(x_34, x_35, x_33);
-x_37 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__3;
-x_38 = l_myMacro____x40_Init_Control_Basic___hyg_840____closed__6;
+x_37 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__3;
+x_38 = l_myMacro____x40_Init_Control_Basic___hyg_843____closed__6;
 x_39 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_39, 0, x_31);
 lean_ctor_set(x_39, 1, x_37);
 lean_ctor_set(x_39, 2, x_36);
 lean_ctor_set(x_39, 3, x_38);
-x_40 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20;
+x_40 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20;
 x_41 = lean_array_push(x_40, x_9);
 x_42 = lean_array_push(x_41, x_11);
-x_43 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19;
+x_43 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19;
 x_44 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_44, 0, x_43);
 lean_ctor_set(x_44, 1, x_42);
 x_45 = lean_array_push(x_40, x_39);
 x_46 = lean_array_push(x_45, x_44);
-x_47 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
+x_47 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
 x_48 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_48, 0, x_47);
 lean_ctor_set(x_48, 1, x_46);
@@ -1635,11 +1635,11 @@ return x_49;
 }
 }
 }
-lean_object* l_unexpand____x40_Init_Control_Basic___hyg_808_(lean_object* x_1, lean_object* x_2) {
+lean_object* l_unexpand____x40_Init_Control_Basic___hyg_810_(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
-x_3 = l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8;
+x_3 = l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8;
 lean_inc(x_1);
 x_4 = l_Lean_Syntax_isOfKind(x_1, x_3);
 if (x_4 == 0)
@@ -1679,7 +1679,7 @@ x_14 = lean_unsigned_to_nat(0u);
 x_15 = l_Lean_Syntax_getArg(x_8, x_14);
 x_16 = l_Lean_Syntax_getArg(x_8, x_7);
 lean_dec(x_8);
-x_17 = l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_1981____spec__1(x_2);
+x_17 = l_Lean_MonadRef_mkInfoFromRefPos___at_unexpand____x40_Init_Notation___hyg_2002____spec__1(x_2);
 x_18 = !lean_is_exclusive(x_17);
 if (x_18 == 0)
 {
@@ -1998,46 +1998,46 @@ l_term___x3c_x26_x3e_____closed__11 = _init_l_term___x3c_x26_x3e_____closed__11(
 lean_mark_persistent(l_term___x3c_x26_x3e_____closed__11);
 l_term___x3c_x26_x3e__ = _init_l_term___x3c_x26_x3e__();
 lean_mark_persistent(l_term___x3c_x26_x3e__);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__1 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__1();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__1);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__2 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__2();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__2);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__3 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__3();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__3);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__4 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__4();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__4);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__5 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__5();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__5);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__6 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__6();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__6);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__7 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__7();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__7);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__8);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__9 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__9();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__9);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__10 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__10();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__10);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__11 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__11();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__11);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__12 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__12();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__12);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__13 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__13();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__13);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__14 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__14();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__14);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__15 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__15();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__15);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__16 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__16();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__16);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__17 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__17();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__17);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__18 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__18();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__18);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__19);
-l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20 = _init_l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_54____closed__20);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__1 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__1();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__1);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__2 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__2();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__2);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__3 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__3();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__3);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__4 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__4();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__4);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__5 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__5();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__5);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__6 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__6();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__6);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__7 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__7();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__7);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__8);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__9 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__9();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__9);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__10 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__10();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__10);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__11 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__11();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__11);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__12 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__12();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__12);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__13 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__13();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__13);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__14 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__14();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__14);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__15 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__15();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__15);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__16 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__16();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__16);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__17 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__17();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__17);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__18 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__18();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__18);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__19);
+l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20 = _init_l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_55____closed__20);
 l_unexpand____x40_Init_Control_Basic___hyg_38____closed__1 = _init_l_unexpand____x40_Init_Control_Basic___hyg_38____closed__1();
 lean_mark_persistent(l_unexpand____x40_Init_Control_Basic___hyg_38____closed__1);
 l_optional___rarg___closed__1 = _init_l_optional___rarg___closed__1();
@@ -2058,18 +2058,18 @@ l_term___x3c_x7c_x7c_x3e_____closed__7 = _init_l_term___x3c_x7c_x7c_x3e_____clos
 lean_mark_persistent(l_term___x3c_x7c_x7c_x3e_____closed__7);
 l_term___x3c_x7c_x7c_x3e__ = _init_l_term___x3c_x7c_x7c_x3e__();
 lean_mark_persistent(l_term___x3c_x7c_x7c_x3e__);
-l_myMacro____x40_Init_Control_Basic___hyg_534____closed__1 = _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__1();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_534____closed__1);
-l_myMacro____x40_Init_Control_Basic___hyg_534____closed__2 = _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__2();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_534____closed__2);
-l_myMacro____x40_Init_Control_Basic___hyg_534____closed__3 = _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__3();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_534____closed__3);
-l_myMacro____x40_Init_Control_Basic___hyg_534____closed__4 = _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__4();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_534____closed__4);
-l_myMacro____x40_Init_Control_Basic___hyg_534____closed__5 = _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__5();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_534____closed__5);
-l_myMacro____x40_Init_Control_Basic___hyg_534____closed__6 = _init_l_myMacro____x40_Init_Control_Basic___hyg_534____closed__6();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_534____closed__6);
+l_myMacro____x40_Init_Control_Basic___hyg_536____closed__1 = _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__1();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_536____closed__1);
+l_myMacro____x40_Init_Control_Basic___hyg_536____closed__2 = _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__2();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_536____closed__2);
+l_myMacro____x40_Init_Control_Basic___hyg_536____closed__3 = _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__3();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_536____closed__3);
+l_myMacro____x40_Init_Control_Basic___hyg_536____closed__4 = _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__4();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_536____closed__4);
+l_myMacro____x40_Init_Control_Basic___hyg_536____closed__5 = _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__5();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_536____closed__5);
+l_myMacro____x40_Init_Control_Basic___hyg_536____closed__6 = _init_l_myMacro____x40_Init_Control_Basic___hyg_536____closed__6();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_536____closed__6);
 l_term___x3c_x26_x26_x3e_____closed__1 = _init_l_term___x3c_x26_x26_x3e_____closed__1();
 lean_mark_persistent(l_term___x3c_x26_x26_x3e_____closed__1);
 l_term___x3c_x26_x26_x3e_____closed__2 = _init_l_term___x3c_x26_x26_x3e_____closed__2();
@@ -2086,18 +2086,18 @@ l_term___x3c_x26_x26_x3e_____closed__7 = _init_l_term___x3c_x26_x26_x3e_____clos
 lean_mark_persistent(l_term___x3c_x26_x26_x3e_____closed__7);
 l_term___x3c_x26_x26_x3e__ = _init_l_term___x3c_x26_x26_x3e__();
 lean_mark_persistent(l_term___x3c_x26_x26_x3e__);
-l_myMacro____x40_Init_Control_Basic___hyg_840____closed__1 = _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__1();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_840____closed__1);
-l_myMacro____x40_Init_Control_Basic___hyg_840____closed__2 = _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__2();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_840____closed__2);
-l_myMacro____x40_Init_Control_Basic___hyg_840____closed__3 = _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__3();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_840____closed__3);
-l_myMacro____x40_Init_Control_Basic___hyg_840____closed__4 = _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__4();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_840____closed__4);
-l_myMacro____x40_Init_Control_Basic___hyg_840____closed__5 = _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__5();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_840____closed__5);
-l_myMacro____x40_Init_Control_Basic___hyg_840____closed__6 = _init_l_myMacro____x40_Init_Control_Basic___hyg_840____closed__6();
-lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_840____closed__6);
+l_myMacro____x40_Init_Control_Basic___hyg_843____closed__1 = _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__1();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_843____closed__1);
+l_myMacro____x40_Init_Control_Basic___hyg_843____closed__2 = _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__2();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_843____closed__2);
+l_myMacro____x40_Init_Control_Basic___hyg_843____closed__3 = _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__3();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_843____closed__3);
+l_myMacro____x40_Init_Control_Basic___hyg_843____closed__4 = _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__4();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_843____closed__4);
+l_myMacro____x40_Init_Control_Basic___hyg_843____closed__5 = _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__5();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_843____closed__5);
+l_myMacro____x40_Init_Control_Basic___hyg_843____closed__6 = _init_l_myMacro____x40_Init_Control_Basic___hyg_843____closed__6();
+lean_mark_persistent(l_myMacro____x40_Init_Control_Basic___hyg_843____closed__6);
 l_notM___rarg___closed__1 = _init_l_notM___rarg___closed__1();
 lean_mark_persistent(l_notM___rarg___closed__1);
 l_instMonadControlT__1___rarg___lambda__2___closed__1 = _init_l_instMonadControlT__1___rarg___lambda__2___closed__1();

stage0/stdlib/Init/Data/Array/Basic.c

@@ -15,13 +15,13 @@ extern "C" {
 #endif
 lean_object* l_Array_foldrMUnsafe_fold___rarg(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_List_foldl___at_Array_appendList___spec__1(lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__25;
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_concatMap___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forM(lean_object*, lean_object*);
 lean_object* l_Array_findM_x3f(lean_object*, lean_object*);
 lean_object* l_Array_findSomeM_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__11;
 lean_object* l_Array_findSomeRevM_x3f_find___at_Array_findRevM_x3f___spec__1___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_getEvenElems___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_getMax_x3f___rarg(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findIdxM_x3f___spec__1___rarg___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -32,6 +32,7 @@ lean_object* l_Array_partition_match__1(lean_object*, lean_object*);
 lean_object* l_Array_instBEqArray(lean_object*);
 lean_object* l_Array_toListLitAux_match__1(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_instReprArray___rarg___closed__5;
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__19;
 lean_object* l_Array_elem___rarg___boxed(lean_object*, lean_object*, lean_object*);
 static lean_object* l_term_x23_x5b___x2c_x5d___closed__8;
 lean_object* l_Array_filterM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -39,8 +40,8 @@ lean_object* l_Array_indexOfAux___rarg(lean_object*, lean_object*, lean_object*,
 static lean_object* l_term_x23_x5b___x2c_x5d___closed__3;
 lean_object* l_Array_filterMapM___at_Array_filterMap___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_filterMapM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__14;
 lean_object* l_Array_back_x3f(lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__22;
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Array_findSomeM_x3f___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -83,7 +84,6 @@ lean_object* l_Array_filterMapM___rarg___lambda__1(lean_object*, lean_object*, l
 lean_object* l_Array_mapMUnsafe_map___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_swapAt(lean_object*);
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__7;
 lean_object* lean_array_fswap(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_zip___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Array_allM___spec__1___rarg___lambda__2(size_t, lean_object*, lean_object*, lean_object*, lean_object*, size_t, uint8_t);
@@ -99,12 +99,14 @@ lean_object* l_Std_Format_joinSep___at_Array_instReprArray___spec__1(lean_object
 size_t l_USize_sub(size_t, size_t);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findSome_x21___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_modifyOp(lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__24;
 static lean_object* l_term_x23_x5b___x2c_x5d___closed__9;
 lean_object* l_Array_modifyM___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_eraseIdxSzAuxInstance___rarg(lean_object*);
 lean_object* l_Array_anyMUnsafe_any(lean_object*, lean_object*);
 lean_object* l_Array_instForInArray___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_uget___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__7;
 static lean_object* l_Array_instReprArray___rarg___closed__6;
 lean_object* l_Array_foldl___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapIdxM_map___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -143,8 +145,8 @@ lean_object* l_Array_eraseIdxSzAux_match__1___rarg(lean_object*, lean_object*, l
 lean_object* l_Array_forInUnsafe_loop___at_Array_findIdxM_x3f___spec__1___rarg___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findRev_x3f___rarg(lean_object*, lean_object*);
 lean_object* l_Array_shrink___rarg(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__15;
 lean_object* l_Array_foldlMUnsafe_fold(lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__22;
 lean_object* l_Array_findIdxM_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapIdxM_map___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findIdx_x3f___rarg(lean_object*, lean_object*);
@@ -155,6 +157,7 @@ lean_object* l_Array_findM_x3f___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findM_x3f___spec__1___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findSomeM_x3f___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__16;
 lean_object* l_Array_foldrMUnsafe_fold___at_Array_foldr___spec__2___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Array_singleton(lean_object*);
 lean_object* l_Array_find_x3f(lean_object*);
@@ -183,9 +186,11 @@ lean_object* l_Array_isEqvAux(lean_object*);
 lean_object* l_Array_forIn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyM_loop___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
 lean_object* l_Array_zip___rarg(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__21;
 lean_object* l_Array_partition(lean_object*);
 lean_object* l_Array_mapMUnsafe(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_zipWithAux___at_Array_zip___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__20;
 lean_object* l_Array_mapIdx___rarg(lean_object*, lean_object*);
 lean_object* l_Array_getMax_x3f___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_swap___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -196,6 +201,7 @@ lean_object* l_Array_forInUnsafe_loop___at_Array_find_x3f___spec__1(lean_object*
 lean_object* l_Array_swap_x21___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forIn_loop(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlM(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__10;
 lean_object* l_Array_foldrM(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_reverse_rev(lean_object*);
 lean_object* l_Array_findSomeRev_x3f(lean_object*, lean_object*);
@@ -221,17 +227,18 @@ lean_object* l_Array_foldlMUnsafe_fold___at_Array_concatMapM___spec__1___rarg___
 lean_object* l_Array_findIdx_x3f_loop(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findSomeM_x3f___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__4;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_unzip___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_forIn___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_0__Array_allDiffAuxAux(lean_object*);
 lean_object* l_Array_eraseIdxAux_match__1(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__23;
 lean_object* l_Array_foldlM_loop_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findSomeM_x3f___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_instAppendArray___closed__1;
 lean_object* l_Array_toArrayLit___rarg___boxed(lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__24;
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Array_shrink_loop_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_all___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -240,6 +247,7 @@ lean_object* l_Array_filter___rarg___boxed(lean_object*, lean_object*, lean_obje
 lean_object* l_Array_eraseIdx_x27___rarg___boxed(lean_object*, lean_object*);
 lean_object* lean_array_swap(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_getIdx_x3f___rarg___boxed(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__13;
 lean_object* l_Array_anyMUnsafe_any___at_Array_all___spec__1(lean_object*);
 lean_object* l_Array_get_x3f___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_findIdx_x3f___rarg___boxed(lean_object*, lean_object*);
@@ -256,12 +264,12 @@ uint8_t l_Array_instBEqArray___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_indexOf_x3f___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyMUnsafe_any___rarg___lambda__1(size_t, lean_object*, lean_object*, lean_object*, size_t, uint8_t);
 static lean_object* l_Array_instReprArray___rarg___closed__9;
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__19;
 lean_object* l_Array_anyMUnsafe_any___at_Array_contains___spec__1(lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Array_any___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_allM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_partition_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Array_allDiff(lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__12;
 lean_object* l_Array_findIdxM_x3f___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findIdxM_x3f___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_pop___boxed(lean_object*, lean_object*);
@@ -306,8 +314,6 @@ lean_object* l_Array_toListLitAux_match__1___rarg(lean_object*, lean_object*, le
 lean_object* l_Array_forInUnsafe_loop___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyMUnsafe_any___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_swapAt_x21___rarg___closed__4;
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__20;
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__16;
 lean_object* l_Array_instBEqArray___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_getLit___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___rarg___lambda__1(lean_object*, size_t, lean_object*, lean_object*, size_t, lean_object*);
@@ -333,19 +339,21 @@ lean_object* l_Array_modify___rarg___boxed(lean_object*, lean_object*, lean_obje
 lean_object* l_List_toString___rarg(lean_object*, lean_object*);
 lean_object* l_Array_findSomeRevM_x3f(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findSomeRevM_x3f_find___at_Array_findRevM_x3f___spec__1___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__5;
 lean_object* l_Array_findSomeRevM_x3f_find___at_Array_findRev_x3f___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_term_x23_x5b___x2c_x5d___closed__15;
 lean_object* l_Array_indexOfAux(lean_object*);
 static lean_object* l_Array_instReprArray___rarg___closed__11;
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_concatMap___spec__1___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__12;
 lean_object* l_Array_append(lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__14;
 lean_object* l_Array_instToStringArray(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findM_x3f___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findSome_x21___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_anyMUnsafe_any___at_Array_any___spec__1___rarg(lean_object*, lean_object*, size_t, size_t);
 static lean_object* l_term_x23_x5b___x2c_x5d___closed__14;
 lean_object* l_Array_findRevM_x3f(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__18;
 lean_object* l_Array_forInUnsafe_loop_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_concatMapM___spec__1___rarg(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Array_unzip___rarg(lean_object*);
@@ -364,7 +372,6 @@ lean_object* l_Array_anyMUnsafe_any___at_Array_allM___spec__1___rarg___boxed(lea
 lean_object* l_Array_foldrMUnsafe_fold___at_Array_toList___spec__2(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findIdxM_x3f___spec__1___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findM_x3f___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__11;
 lean_object* l_Array_forIn_loop___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_forM___spec__1___rarg___lambda__1(size_t, lean_object*, lean_object*, lean_object*, size_t, lean_object*);
 lean_object* l_Array_isPrefixOfAux(lean_object*);
@@ -406,6 +413,7 @@ lean_object* l_Array_findSomeRevM_x3f_find_match__1___rarg(lean_object*, lean_ob
 lean_object* l_Array_anyMUnsafe_any___at_Array_any___spec__1(lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_filterM___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_find_x3f___rarg___boxed(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__3;
 lean_object* l_Array_mapMUnsafe_map___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_concatMapM___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_mapM___spec__1___rarg___lambda__2(size_t, lean_object*, lean_object*, lean_object*, size_t, lean_object*);
@@ -424,7 +432,7 @@ static lean_object* l_Array_insertAt___rarg___closed__1;
 lean_object* l_Array_findSome_x3f(lean_object*, lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Array_allM___spec__1(lean_object*, lean_object*);
 static lean_object* l_Array_swapAt_x21___rarg___closed__3;
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__21;
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__9;
 lean_object* l_Array_instReprArray(lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_0__Array_allDiffAux(lean_object*);
 lean_object* l_Array_zip(lean_object*, lean_object*);
@@ -436,15 +444,14 @@ lean_object* l_Array_findSomeRevM_x3f_find_match__1(lean_object*, lean_object*);
 lean_object* l_List_redLength___rarg(lean_object*);
 lean_object* l_Array_indexOf_x3f___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyM_loop(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__23;
 static lean_object* l_term_x23_x5b___x2c_x5d___closed__7;
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_forM___spec__1___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forRevM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_filterMapM(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_foldl___spec__1___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__13;
 lean_object* l_Array_indexOf_x3f(lean_object*);
 lean_object* l_Array_partition___rarg___boxed(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__17;
 lean_object* l_Array_mapIdxM_map_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_isEqv___rarg(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_partition___rarg___closed__1;
@@ -483,6 +490,7 @@ lean_object* l_Array_reverse_rev___rarg___boxed(lean_object*, lean_object*, lean
 static lean_object* l_term_x23_x5b___x2c_x5d___closed__10;
 lean_object* l_Array_zipWithAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_filter___spec__1(lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__8;
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_mapM___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findSomeM_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldrMUnsafe_fold___at_Array_foldr___spec__2(lean_object*, lean_object*);
@@ -491,7 +499,6 @@ lean_object* l_Array_back___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_instAppendArray(lean_object*);
 lean_object* l_Array_modifyOp___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_unzip___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__4;
 lean_object* l_Array_forInUnsafe___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_getEvenElems___rarg(lean_object*);
@@ -502,7 +509,6 @@ lean_object* l_Array_findSomeRevM_x3f_find___at_Array_findSomeRev_x3f___spec__1_
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_filterM___spec__1___rarg___lambda__2(size_t, lean_object*, lean_object*, lean_object*, size_t, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_append___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_concatMapM___rarg(lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__17;
 lean_object* l_Array_forIn_loop_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapIdx___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_findSomeRev_x3f___rarg___boxed(lean_object*, lean_object*);
@@ -515,7 +521,6 @@ lean_object* l_Array_findSome_x21(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findIdxM_x3f___spec__1___rarg___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
 lean_object* l_Array_get_x3f(lean_object*);
 lean_object* l_Array_get_x3f___rarg(lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__8;
 lean_object* l_Array_findSomeRevM_x3f_find___at_Array_findRevM_x3f___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_find_x3f___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_modify___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -549,7 +554,6 @@ lean_object* lean_string_length(lean_object*);
 lean_object* l_Array_foldlM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_erase_match__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_filterMap___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__6;
 static lean_object* l_Array_instReprArray___rarg___closed__8;
 lean_object* l_Array_forRevM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_instForInArray(lean_object*, lean_object*, lean_object*);
@@ -563,14 +567,11 @@ lean_object* l_Array_foldlMUnsafe_fold___at_Array_filterM___spec__1___rarg(lean_
 lean_object* l_Array_instInhabitedArray(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_partition___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findSomeM_x3f___spec__1___rarg___lambda__3(lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__9;
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_filterM___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Array_allM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t);
 lean_object* l_Array_forIn_loop_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlM_loop___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldrM_fold___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__18;
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__15;
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_filterMap___spec__2(lean_object*, lean_object*);
 lean_object* l_Array_unzip_match__2___rarg(lean_object*, lean_object*);
 lean_object* l_Array_findIdx_x3f_loop___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -579,10 +580,8 @@ lean_object* l_Array_findSomeRevM_x3f_find___rarg___lambda__1___boxed(lean_objec
 lean_object* l___private_Init_Data_Array_Basic_0__Array_allDiffAuxAux_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_isEqvAux_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_contains(lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__10;
 lean_object* l_Array_insertAtAux___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__3;
 lean_object* l_Array_forInUnsafe_loop___at_Array_find_x3f___spec__1___rarg(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findSome_x21___rarg(lean_object*, lean_object*, lean_object*);
@@ -615,16 +614,14 @@ lean_object* l_Array_filter___rarg(lean_object*, lean_object*, lean_object*, lea
 uint8_t l___private_Init_Data_Array_Basic_0__Array_allDiffAuxAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findSomeM_x3f___spec__1___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldrM_fold(lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__1;
 lean_object* l_Array_insertAt___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Array_map___spec__1___rarg(lean_object*, size_t, size_t, lean_object*);
-lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614_(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620_(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_contains___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_to_int(lean_object*);
 lean_object* l_Array_eraseIdxSzAux_match__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldrMUnsafe_fold___at_Array_toList___spec__1___rarg(lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Array_instHAppendArrayListArray(lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__2;
 lean_object* l_Array_eraseIdxAux___rarg(lean_object*, lean_object*);
 static lean_object* l_Array_instReprArray___rarg___closed__3;
 lean_object* l_Array_foldrMUnsafe_fold___at_Array_forRevM___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -633,6 +630,8 @@ lean_object* l_Array_zipWithAux___at_Array_zip___spec__1(lean_object*, lean_obje
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_forM___spec__1___rarg(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Array_foldlMUnsafe_fold___at_Array_split___spec__1(lean_object*);
 lean_object* l_Array_mapIdxM_map___at_Array_mapIdx___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__1;
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__2;
 lean_object* l_Array_findSomeM_x3f(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_findIdxM_x3f___rarg___closed__1;
 lean_object* l_Array_isEqvAux_match__1___rarg(uint8_t, lean_object*, lean_object*);
@@ -641,6 +640,8 @@ lean_object* l_Array_anyMUnsafe___rarg(lean_object*, lean_object*, lean_object*,
 lean_object* l_Array_getEvenElems_match__1___rarg(lean_object*, lean_object*);
 static lean_object* l_term_x23_x5b___x2c_x5d___closed__6;
 lean_object* l_Array_concatMap___rarg(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__25;
+static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__6;
 lean_object* l_Array_foldrMUnsafe_fold___at_Array_forRevM___spec__2___rarg(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Array_any___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Array_findSomeM_x3f___spec__1___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
@@ -652,7 +653,6 @@ lean_object* l_Array_foldlMUnsafe_fold___at_Array_filterMap___spec__2___rarg___b
 lean_object* l_Array_indexOfAux___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findSomeM_x3f_match__1(lean_object*, lean_object*);
 lean_object* l_Array_foldrM_fold___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__5;
 lean_object* l_Array_foldl___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mkArray___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
@@ -7838,7 +7838,7 @@ x_1 = l_term_x23_x5b___x2c_x5d___closed__15;
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__1() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -7846,17 +7846,17 @@ x_1 = lean_mk_string("Lean");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__2() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__1;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__3() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -7864,17 +7864,17 @@ x_1 = lean_mk_string("Parser");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__4() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__2;
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__3;
+x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__2;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__3;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__5() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__5() {
 _start:
 {
 lean_object* x_1; 
@@ -7882,17 +7882,17 @@ x_1 = lean_mk_string("Term");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__6() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__4;
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__5;
+x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__4;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__5;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__7() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__7() {
 _start:
 {
 lean_object* x_1; 
@@ -7900,17 +7900,17 @@ x_1 = lean_mk_string("app");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__8() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__6;
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__7;
+x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__6;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__7;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__9() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__9() {
 _start:
 {
 lean_object* x_1; 
@@ -7918,22 +7918,22 @@ x_1 = lean_mk_string("List.toArray");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__10() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__10() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__9;
+x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__9;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__11() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__11() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__9;
+x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__9;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__10;
+x_3 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__10;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -7941,7 +7941,7 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__12() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__12() {
 _start:
 {
 lean_object* x_1; 
@@ -7949,17 +7949,17 @@ x_1 = lean_mk_string("List");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__13() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__12;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__12;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__14() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__14() {
 _start:
 {
 lean_object* x_1; 
@@ -7967,41 +7967,41 @@ x_1 = lean_mk_string("toArray");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__15() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__15() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__13;
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__14;
+x_1 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__13;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__14;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__16() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__16() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__15;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__15;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__17() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__17() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__16;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__16;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__18() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__18() {
 _start:
 {
 lean_object* x_1; 
@@ -8009,17 +8009,17 @@ x_1 = lean_mk_string("null");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__19() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__19() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__18;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__18;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__20() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__20() {
 _start:
 {
 lean_object* x_1; 
@@ -8027,17 +8027,17 @@ x_1 = lean_mk_string("term[_]");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__21() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__21() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__20;
+x_2 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__20;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__22() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__22() {
 _start:
 {
 lean_object* x_1; 
@@ -8045,7 +8045,7 @@ x_1 = lean_mk_string("[");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__23() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__23() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -8054,7 +8054,7 @@ x_2 = lean_mk_empty_array_with_capacity(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__24() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__24() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -8063,7 +8063,7 @@ x_2 = lean_mk_empty_array_with_capacity(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__25() {
+static lean_object* _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__25() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -8072,7 +8072,7 @@ x_2 = lean_mk_empty_array_with_capacity(x_1);
 return x_2;
 }
 }
-lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3614_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_myMacro____x40_Init_Data_Array_Basic___hyg_3620_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -8098,7 +8098,7 @@ x_9 = l_Lean_Syntax_getArg(x_1, x_8);
 lean_dec(x_1);
 x_10 = l_Lean_Syntax_getArgs(x_9);
 lean_dec(x_9);
-x_11 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(x_2, x_3);
+x_11 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(x_2, x_3);
 x_12 = !lean_is_exclusive(x_11);
 if (x_12 == 0)
 {
@@ -8109,17 +8109,17 @@ lean_inc(x_14);
 x_15 = lean_ctor_get(x_2, 1);
 lean_inc(x_15);
 lean_dec(x_2);
-x_16 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__15;
+x_16 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__15;
 x_17 = l_Lean_addMacroScope(x_15, x_16, x_14);
-x_18 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__11;
-x_19 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__17;
+x_18 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__11;
+x_19 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__17;
 lean_inc(x_13);
 x_20 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_20, 0, x_13);
 lean_ctor_set(x_20, 1, x_18);
 lean_ctor_set(x_20, 2, x_17);
 lean_ctor_set(x_20, 3, x_19);
-x_21 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__22;
+x_21 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__22;
 lean_inc(x_13);
 x_22 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_22, 0, x_13);
@@ -8127,7 +8127,7 @@ lean_ctor_set(x_22, 1, x_21);
 x_23 = l_Array_instEmptyCollectionArray___closed__1;
 x_24 = l_Array_append___rarg(x_23, x_10);
 lean_dec(x_10);
-x_25 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__19;
+x_25 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__19;
 x_26 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_26, 0, x_25);
 lean_ctor_set(x_26, 1, x_24);
@@ -8135,23 +8135,23 @@ x_27 = l_Array_instReprArray___rarg___closed__8;
 x_28 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_28, 0, x_13);
 lean_ctor_set(x_28, 1, x_27);
-x_29 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__23;
+x_29 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__23;
 x_30 = lean_array_push(x_29, x_22);
 x_31 = lean_array_push(x_30, x_26);
 x_32 = lean_array_push(x_31, x_28);
-x_33 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__21;
+x_33 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__21;
 x_34 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_34, 0, x_33);
 lean_ctor_set(x_34, 1, x_32);
-x_35 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__24;
+x_35 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__24;
 x_36 = lean_array_push(x_35, x_34);
 x_37 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_37, 0, x_25);
 lean_ctor_set(x_37, 1, x_36);
-x_38 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__25;
+x_38 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__25;
 x_39 = lean_array_push(x_38, x_20);
 x_40 = lean_array_push(x_39, x_37);
-x_41 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__8;
+x_41 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__8;
 x_42 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_42, 0, x_41);
 lean_ctor_set(x_42, 1, x_40);
@@ -8171,17 +8171,17 @@ lean_inc(x_45);
 x_46 = lean_ctor_get(x_2, 1);
 lean_inc(x_46);
 lean_dec(x_2);
-x_47 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__15;
+x_47 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__15;
 x_48 = l_Lean_addMacroScope(x_46, x_47, x_45);
-x_49 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__11;
-x_50 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__17;
+x_49 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__11;
+x_50 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__17;
 lean_inc(x_43);
 x_51 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_51, 0, x_43);
 lean_ctor_set(x_51, 1, x_49);
 lean_ctor_set(x_51, 2, x_48);
 lean_ctor_set(x_51, 3, x_50);
-x_52 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__22;
+x_52 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__22;
 lean_inc(x_43);
 x_53 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_53, 0, x_43);
@@ -8189,7 +8189,7 @@ lean_ctor_set(x_53, 1, x_52);
 x_54 = l_Array_instEmptyCollectionArray___closed__1;
 x_55 = l_Array_append___rarg(x_54, x_10);
 lean_dec(x_10);
-x_56 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__19;
+x_56 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__19;
 x_57 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_57, 0, x_56);
 lean_ctor_set(x_57, 1, x_55);
@@ -8197,23 +8197,23 @@ x_58 = l_Array_instReprArray___rarg___closed__8;
 x_59 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_59, 0, x_43);
 lean_ctor_set(x_59, 1, x_58);
-x_60 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__23;
+x_60 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__23;
 x_61 = lean_array_push(x_60, x_53);
 x_62 = lean_array_push(x_61, x_57);
 x_63 = lean_array_push(x_62, x_59);
-x_64 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__21;
+x_64 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__21;
 x_65 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_65, 0, x_64);
 lean_ctor_set(x_65, 1, x_63);
-x_66 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__24;
+x_66 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__24;
 x_67 = lean_array_push(x_66, x_65);
 x_68 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_68, 0, x_56);
 lean_ctor_set(x_68, 1, x_67);
-x_69 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__25;
+x_69 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__25;
 x_70 = lean_array_push(x_69, x_51);
 x_71 = lean_array_push(x_70, x_68);
-x_72 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__8;
+x_72 = l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__8;
 x_73 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_73, 0, x_72);
 lean_ctor_set(x_73, 1, x_71);
@@ -10886,56 +10886,56 @@ l_term_x23_x5b___x2c_x5d___closed__15 = _init_l_term_x23_x5b___x2c_x5d___closed_
 lean_mark_persistent(l_term_x23_x5b___x2c_x5d___closed__15);
 l_term_x23_x5b___x2c_x5d = _init_l_term_x23_x5b___x2c_x5d();
 lean_mark_persistent(l_term_x23_x5b___x2c_x5d);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__1 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__1();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__1);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__2 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__2();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__2);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__3 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__3();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__3);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__4 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__4();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__4);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__5 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__5();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__5);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__6 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__6();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__6);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__7 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__7();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__7);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__8 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__8();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__8);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__9 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__9();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__9);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__10 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__10();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__10);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__11 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__11();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__11);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__12 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__12();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__12);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__13 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__13();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__13);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__14 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__14();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__14);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__15 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__15();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__15);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__16 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__16();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__16);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__17 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__17();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__17);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__18 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__18();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__18);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__19 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__19();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__19);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__20 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__20();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__20);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__21 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__21();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__21);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__22 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__22();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__22);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__23 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__23();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__23);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__24 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__24();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__24);
-l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__25 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__25();
-lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3614____closed__25);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__1 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__1();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__1);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__2 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__2();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__2);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__3 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__3();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__3);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__4 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__4();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__4);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__5 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__5();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__5);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__6 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__6();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__6);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__7 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__7();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__7);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__8 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__8();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__8);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__9 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__9();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__9);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__10 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__10();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__10);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__11 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__11();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__11);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__12 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__12();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__12);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__13 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__13();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__13);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__14 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__14();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__14);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__15 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__15();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__15);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__16 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__16();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__16);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__17 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__17();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__17);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__18 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__18();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__18);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__19 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__19();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__19);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__20 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__20();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__20);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__21 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__21();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__21);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__22 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__22();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__22);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__23 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__23();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__23);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__24 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__24();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__24);
+l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__25 = _init_l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__25();
+lean_mark_persistent(l_myMacro____x40_Init_Data_Array_Basic___hyg_3620____closed__25);
 l_Array_partition___rarg___closed__1 = _init_l_Array_partition___rarg___closed__1();
 lean_mark_persistent(l_Array_partition___rarg___closed__1);
 l_Array_insertAt___rarg___closed__1 = _init_l_Array_insertAt___rarg___closed__1();

stage0/stdlib/Init/Data/Format/Macro.c

@@ -13,36 +13,36 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__14;
 static lean_object* l_Std_termF_x21_____closed__11;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__14;
-lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(lean_object*, lean_object*);
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__10;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__5;
+lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(lean_object*, lean_object*);
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__10;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__5;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__3;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__3;
 static lean_object* l_Std_termF_x21_____closed__7;
 static lean_object* l_Std_termF_x21_____closed__16;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__7;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__7;
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* l_Std_termF_x21__;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__13;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__13;
 lean_object* l_Lean_Syntax_expandInterpolatedStr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Std_termF_x21_____closed__10;
-lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18_(lean_object*, lean_object*, lean_object*);
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__6;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__2;
+lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19_(lean_object*, lean_object*, lean_object*);
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__6;
 static lean_object* l_Std_termF_x21_____closed__14;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__11;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__2;
 static lean_object* l_Std_termF_x21_____closed__5;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__11;
 static lean_object* l_Std_termF_x21_____closed__3;
 static lean_object* l_Std_termF_x21_____closed__15;
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__9;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__8;
 static lean_object* l_Std_termF_x21_____closed__4;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__9;
 static lean_object* l_Std_termF_x21_____closed__9;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__4;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__8;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__1;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__4;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__1;
 static lean_object* l_Std_termF_x21_____closed__13;
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
 static lean_object* l_Std_termF_x21_____closed__8;
@@ -50,7 +50,7 @@ static lean_object* l_Std_termF_x21_____closed__2;
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 static lean_object* l_Std_termF_x21_____closed__1;
 static lean_object* l_Std_termF_x21_____closed__6;
-static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__12;
+static lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__12;
 static lean_object* l_Std_termF_x21_____closed__12;
 static lean_object* _init_l_Std_termF_x21_____closed__1() {
 _start:
@@ -220,7 +220,7 @@ x_1 = l_Std_termF_x21_____closed__16;
 return x_1;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__1() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -228,22 +228,22 @@ x_1 = lean_mk_string("Format");
 return x_1;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__2() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__1;
+x_1 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__1;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__3() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__1;
+x_1 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__1;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__2;
+x_3 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__2;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -251,51 +251,51 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__4() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__1;
+x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__5() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Std_termF_x21_____closed__2;
-x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__1;
+x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__6() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__5;
+x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__5;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__7() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__7() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__6;
+x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__6;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__8() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__8() {
 _start:
 {
 lean_object* x_1; 
@@ -303,22 +303,22 @@ x_1 = lean_mk_string("fmt");
 return x_1;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__9() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__9() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__8;
+x_1 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__8;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__10() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__10() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__8;
+x_1 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__8;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__9;
+x_3 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__9;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -326,51 +326,51 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__11() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__11() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__8;
+x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__8;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__12() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__12() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Std_termF_x21_____closed__2;
-x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__8;
+x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__8;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__13() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__12;
+x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__12;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__14() {
+static lean_object* _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__14() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__13;
+x_2 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__13;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -394,7 +394,7 @@ lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_o
 x_8 = lean_unsigned_to_nat(1u);
 x_9 = l_Lean_Syntax_getArg(x_1, x_8);
 lean_dec(x_1);
-x_10 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(x_2, x_3);
+x_10 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(x_2, x_3);
 x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
 x_12 = lean_ctor_get(x_10, 1);
@@ -404,27 +404,27 @@ x_13 = lean_ctor_get(x_2, 2);
 lean_inc(x_13);
 x_14 = lean_ctor_get(x_2, 1);
 lean_inc(x_14);
-x_15 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__4;
+x_15 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__4;
 lean_inc(x_13);
 lean_inc(x_14);
 x_16 = l_Lean_addMacroScope(x_14, x_15, x_13);
-x_17 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__3;
-x_18 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__7;
+x_17 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__3;
+x_18 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__7;
 x_19 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_19, 0, x_11);
 lean_ctor_set(x_19, 1, x_17);
 lean_ctor_set(x_19, 2, x_16);
 lean_ctor_set(x_19, 3, x_18);
-x_20 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(x_2, x_12);
+x_20 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(x_2, x_12);
 x_21 = lean_ctor_get(x_20, 0);
 lean_inc(x_21);
 x_22 = lean_ctor_get(x_20, 1);
 lean_inc(x_22);
 lean_dec(x_20);
-x_23 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__11;
+x_23 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__11;
 x_24 = l_Lean_addMacroScope(x_14, x_23, x_13);
-x_25 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__10;
-x_26 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__14;
+x_25 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__10;
+x_26 = l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__14;
 x_27 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_27, 0, x_21);
 lean_ctor_set(x_27, 1, x_25);
@@ -483,34 +483,34 @@ l_Std_termF_x21_____closed__16 = _init_l_Std_termF_x21_____closed__16();
 lean_mark_persistent(l_Std_termF_x21_____closed__16);
 l_Std_termF_x21__ = _init_l_Std_termF_x21__();
 lean_mark_persistent(l_Std_termF_x21__);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__1 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__1();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__1);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__2 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__2();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__2);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__3 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__3();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__3);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__4 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__4();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__4);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__5 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__5();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__5);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__6 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__6();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__6);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__7 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__7();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__7);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__8 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__8();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__8);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__9 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__9();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__9);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__10 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__10();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__10);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__11 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__11();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__11);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__12 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__12();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__12);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__13 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__13();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__13);
-l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__14 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__14();
-lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_18____closed__14);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__1 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__1();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__1);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__2 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__2();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__2);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__3 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__3();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__3);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__4 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__4();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__4);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__5 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__5();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__5);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__6 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__6();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__6);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__7 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__7();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__7);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__8 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__8();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__8);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__9 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__9();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__9);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__10 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__10();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__10);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__11 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__11();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__11);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__12 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__12();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__12);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__13 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__13();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__13);
+l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__14 = _init_l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__14();
+lean_mark_persistent(l_Std_myMacro____x40_Init_Data_Format_Macro___hyg_19____closed__14);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus

stage0/stdlib/Init/Data/Random.c

@@ -83,10 +83,10 @@ lean_object* lean_string_length(lean_object*);
 lean_object* l_stdSplit(lean_object*);
 static lean_object* l_stdNext___closed__7;
 lean_object* lean_int_add(lean_object*, lean_object*);
+static lean_object* l_initFn____x40_Init_Data_Random___hyg_631____closed__1;
 lean_object* lean_nat_mod(lean_object*, lean_object*);
-static lean_object* l_initFn____x40_Init_Data_Random___hyg_630____closed__1;
 lean_object* l_IO_mkRef___rarg(lean_object*, lean_object*);
-lean_object* l_initFn____x40_Init_Data_Random___hyg_630_(lean_object*);
+lean_object* l_initFn____x40_Init_Data_Random___hyg_631_(lean_object*);
 lean_object* l_instReprStdGen(lean_object*, lean_object*);
 lean_object* l_instInhabitedStdGen;
 lean_object* l_IO_rand_match__1(lean_object*);
@@ -1449,7 +1449,7 @@ x_2 = lean_alloc_closure((void*)(l_randBool___rarg), 2, 0);
 return x_2;
 }
 }
-static lean_object* _init_l_initFn____x40_Init_Data_Random___hyg_630____closed__1() {
+static lean_object* _init_l_initFn____x40_Init_Data_Random___hyg_631____closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -1458,11 +1458,11 @@ x_2 = l_mkStdGen(x_1);
 return x_2;
 }
 }
-lean_object* l_initFn____x40_Init_Data_Random___hyg_630_(lean_object* x_1) {
+lean_object* l_initFn____x40_Init_Data_Random___hyg_631_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_initFn____x40_Init_Data_Random___hyg_630____closed__1;
+x_2 = l_initFn____x40_Init_Data_Random___hyg_631____closed__1;
 x_3 = l_IO_mkRef___rarg(x_2, x_1);
 return x_3;
 }
@@ -1979,9 +1979,9 @@ l_instRandomGenStdGen___closed__4 = _init_l_instRandomGenStdGen___closed__4();
 lean_mark_persistent(l_instRandomGenStdGen___closed__4);
 l_instRandomGenStdGen = _init_l_instRandomGenStdGen();
 lean_mark_persistent(l_instRandomGenStdGen);
-l_initFn____x40_Init_Data_Random___hyg_630____closed__1 = _init_l_initFn____x40_Init_Data_Random___hyg_630____closed__1();
-lean_mark_persistent(l_initFn____x40_Init_Data_Random___hyg_630____closed__1);
-res = l_initFn____x40_Init_Data_Random___hyg_630_(lean_io_mk_world());
+l_initFn____x40_Init_Data_Random___hyg_631____closed__1 = _init_l_initFn____x40_Init_Data_Random___hyg_631____closed__1();
+lean_mark_persistent(l_initFn____x40_Init_Data_Random___hyg_631____closed__1);
+res = l_initFn____x40_Init_Data_Random___hyg_631_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_IO_stdGenRef = lean_io_result_get_value(res);
 lean_mark_persistent(l_IO_stdGenRef);

stage0/stdlib/Init/Data/ToString/Macro.c

@@ -13,43 +13,43 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__10;
-lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__10;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
-lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17_(lean_object*, lean_object*, lean_object*);
+lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18_(lean_object*, lean_object*, lean_object*);
 static lean_object* l_termS_x21_____closed__7;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__15;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__7;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__5;
 static lean_object* l_termS_x21_____closed__3;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__5;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__7;
 lean_object* lean_string_utf8_byte_size(lean_object*);
 static lean_object* l_termS_x21_____closed__2;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__14;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__14;
 static lean_object* l_termS_x21_____closed__13;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__3;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__15;
 lean_object* l_Lean_Syntax_expandInterpolatedStr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__3;
 static lean_object* l_termS_x21_____closed__6;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__6;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__6;
 static lean_object* l_termS_x21_____closed__14;
 static lean_object* l_termS_x21_____closed__5;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__2;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__1;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__9;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__13;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__9;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__1;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__2;
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
 static lean_object* l_termS_x21_____closed__9;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__13;
 static lean_object* l_termS_x21_____closed__1;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__8;
 static lean_object* l_termS_x21_____closed__4;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__4;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__8;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__4;
 static lean_object* l_termS_x21_____closed__8;
 static lean_object* l_termS_x21_____closed__10;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__11;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__11;
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
 static lean_object* l_termS_x21_____closed__12;
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 lean_object* l_termS_x21__;
-static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__12;
+static lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__12;
 static lean_object* l_termS_x21_____closed__11;
 static lean_object* _init_l_termS_x21_____closed__1() {
 _start:
@@ -201,7 +201,7 @@ x_1 = l_termS_x21_____closed__14;
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__1() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -209,22 +209,22 @@ x_1 = lean_mk_string("String");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__2() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__1;
+x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__1;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__3() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__1;
+x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__1;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__2;
+x_3 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__2;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -232,41 +232,41 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__4() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__1;
+x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__5() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__4;
+x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__4;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__6() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__5;
+x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__5;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__7() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__7() {
 _start:
 {
 lean_object* x_1; 
@@ -274,22 +274,22 @@ x_1 = lean_mk_string("toString");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__8() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__8() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__7;
+x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__7;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__9() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__9() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__7;
+x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__7;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__8;
+x_3 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__8;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -297,17 +297,17 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__10() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__10() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__7;
+x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__7;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__11() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__11() {
 _start:
 {
 lean_object* x_1; 
@@ -315,51 +315,51 @@ x_1 = lean_mk_string("ToString");
 return x_1;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__12() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__12() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__11;
+x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__11;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__13() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__13() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__12;
-x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__7;
+x_1 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__12;
+x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__7;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__14() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__14() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__13;
+x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__13;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__15() {
+static lean_object* _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__15() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__14;
+x_2 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__14;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_17_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_18_(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -383,7 +383,7 @@ lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_o
 x_8 = lean_unsigned_to_nat(1u);
 x_9 = l_Lean_Syntax_getArg(x_1, x_8);
 lean_dec(x_1);
-x_10 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(x_2, x_3);
+x_10 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(x_2, x_3);
 x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
 x_12 = lean_ctor_get(x_10, 1);
@@ -393,27 +393,27 @@ x_13 = lean_ctor_get(x_2, 2);
 lean_inc(x_13);
 x_14 = lean_ctor_get(x_2, 1);
 lean_inc(x_14);
-x_15 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__4;
+x_15 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__4;
 lean_inc(x_13);
 lean_inc(x_14);
 x_16 = l_Lean_addMacroScope(x_14, x_15, x_13);
-x_17 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__3;
-x_18 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__6;
+x_17 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__3;
+x_18 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__6;
 x_19 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_19, 0, x_11);
 lean_ctor_set(x_19, 1, x_17);
 lean_ctor_set(x_19, 2, x_16);
 lean_ctor_set(x_19, 3, x_18);
-x_20 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_71____spec__1(x_2, x_12);
+x_20 = l_Lean_MonadRef_mkInfoFromRefPos___at_myMacro____x40_Init_Notation___hyg_72____spec__1(x_2, x_12);
 x_21 = lean_ctor_get(x_20, 0);
 lean_inc(x_21);
 x_22 = lean_ctor_get(x_20, 1);
 lean_inc(x_22);
 lean_dec(x_20);
-x_23 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__10;
+x_23 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__10;
 x_24 = l_Lean_addMacroScope(x_14, x_23, x_13);
-x_25 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__9;
-x_26 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__15;
+x_25 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__9;
+x_26 = l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__15;
 x_27 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_27, 0, x_21);
 lean_ctor_set(x_27, 1, x_25);
@@ -468,36 +468,36 @@ l_termS_x21_____closed__14 = _init_l_termS_x21_____closed__14();
 lean_mark_persistent(l_termS_x21_____closed__14);
 l_termS_x21__ = _init_l_termS_x21__();
 lean_mark_persistent(l_termS_x21__);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__1 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__1();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__1);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__2 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__2();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__2);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__3 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__3();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__3);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__4 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__4();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__4);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__5 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__5();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__5);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__6 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__6();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__6);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__7 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__7();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__7);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__8 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__8();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__8);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__9 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__9();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__9);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__10 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__10();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__10);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__11 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__11();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__11);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__12 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__12();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__12);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__13 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__13();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__13);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__14 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__14();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__14);
-l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__15 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__15();
-lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_17____closed__15);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__1 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__1();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__1);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__2 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__2();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__2);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__3 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__3();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__3);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__4 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__4();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__4);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__5 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__5();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__5);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__6 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__6();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__6);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__7 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__7();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__7);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__8 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__8();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__8);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__9 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__9();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__9);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__10 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__10();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__10);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__11 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__11();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__11);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__12 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__12();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__12);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__13 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__13();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__13);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__14 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__14();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__14);
+l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__15 = _init_l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__15();
+lean_mark_persistent(l_myMacro____x40_Init_Data_ToString_Macro___hyg_18____closed__15);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus

stage0/stdlib/Lean/Compiler/InitAttr.c

@@ -86,9 +86,9 @@ uint8_t l_USize_decLt(size_t, size_t);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_registerInitAttrUnsafe___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_resolveGlobalConstNoOverload___at_Lean_registerInitAttrUnsafe___spec__3___closed__2;
 static lean_object* l_Lean_registerParametricAttribute___at_Lean_registerInitAttrUnsafe___spec__10___lambda__6___closed__1;
+static lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__1;
 static lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_registerInitAttrUnsafe___spec__14___lambda__2___closed__1;
 lean_object* l___private_Lean_Compiler_InitAttr_0__Lean_getIOTypeArg___boxed(lean_object*);
-static lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__1;
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttrUnsafe___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_InitAttr_0__Lean_isUnitType_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -98,10 +98,10 @@ static lean_object* l_Lean_regularInitAttr___closed__4;
 lean_object* l_Lean_registerInitAttrUnsafe___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_InitAttr_0__Lean_isIOUnit_match__1___rarg(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_regularInitAttr___closed__9;
+static lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__2;
 lean_object* l_Lean_throwError___at_Lean_registerInitAttrUnsafe___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__2;
-lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613_(lean_object*);
-lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597_(lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616_(lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600_(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_registerInitAttrUnsafe___spec__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_registerParametricAttribute___at_Lean_registerInitAttrUnsafe___spec__10___closed__2;
 lean_object* lean_get_init_fn_name_for(lean_object*, lean_object*);
@@ -138,21 +138,21 @@ lean_object* l_Lean_regularInitAttr___lambda__5(lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 static lean_object* l_Lean_registerParametricAttribute___at_Lean_registerInitAttrUnsafe___spec__10___lambda__4___closed__3;
+static lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__1;
 static lean_object* l_Lean_registerInitAttrUnsafe___lambda__1___closed__7;
 lean_object* l_Lean_getInitFnNameForCore_x3f___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerParametricAttribute___at_Lean_registerInitAttrUnsafe___spec__10(lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttrUnsafe___lambda__3(uint8_t, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__2;
 static lean_object* l_Array_qpartition_loop___at_Lean_registerInitAttrUnsafe___spec__13___closed__1;
 lean_object* l_Array_qpartition_loop___at_Lean_registerInitAttrUnsafe___spec__13___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_isIOUnitBuiltinInitFn___boxed(lean_object*, lean_object*);
 static lean_object* l_Lean_registerParametricAttribute___at_Lean_registerInitAttrUnsafe___spec__10___lambda__4___closed__5;
-static lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__2;
 static lean_object* l_Lean_registerInitAttrUnsafe___closed__1;
 lean_object* lean_eval_const(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_hasInitAttr___boxed(lean_object*, lean_object*);
 lean_object* l_List_filterAux___at_Lean_resolveGlobalConst___spec__1(lean_object*, lean_object*);
 lean_object* lean_get_regular_init_fn_name_for(lean_object*, lean_object*);
-static lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__1;
 lean_object* l_Lean_registerInitAttr___rarg(lean_object*);
 extern lean_object* l_Lean_persistentEnvExtensionsRef;
 lean_object* lean_expr_dbg_to_string(lean_object*);
@@ -3643,7 +3643,7 @@ lean_dec(x_1);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__1() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -3651,21 +3651,21 @@ x_1 = lean_mk_string("init");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__2() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__1;
+x_2 = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597_(lean_object* x_1) {
+lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; uint8_t x_3; lean_object* x_4; 
-x_2 = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__2;
+x_2 = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__2;
 x_3 = 1;
 x_4 = l_Lean_registerInitAttrUnsafe(x_2, x_3, x_1);
 return x_4;
@@ -3940,7 +3940,7 @@ lean_dec(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__1() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -3948,21 +3948,21 @@ x_1 = lean_mk_string("builtinInit");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__2() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__1;
+x_2 = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613_(lean_object* x_1) {
+lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; uint8_t x_3; lean_object* x_4; 
-x_2 = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__2;
+x_2 = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__2;
 x_3 = 0;
 x_4 = l_Lean_registerInitAttrUnsafe(x_2, x_3, x_1);
 return x_4;
@@ -4628,10 +4628,10 @@ lean_mark_persistent(l_Lean_registerInitAttrUnsafe___closed__3);
 l_Lean_registerInitAttr___rarg___closed__1 = _init_l_Lean_registerInitAttr___rarg___closed__1();
 l_Lean_registerInitAttr___rarg___closed__2 = _init_l_Lean_registerInitAttr___rarg___closed__2();
 lean_mark_persistent(l_Lean_registerInitAttr___rarg___closed__2);
-l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__1 = _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__1();
-lean_mark_persistent(l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__1);
-l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__2 = _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__2();
-lean_mark_persistent(l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597____closed__2);
+l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__1 = _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__1();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__1);
+l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__2 = _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__2();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600____closed__2);
 l_Lean_regularInitAttr___lambda__1___closed__1 = _init_l_Lean_regularInitAttr___lambda__1___closed__1();
 lean_mark_persistent(l_Lean_regularInitAttr___lambda__1___closed__1);
 l_Lean_regularInitAttr___lambda__1___closed__2 = _init_l_Lean_regularInitAttr___lambda__1___closed__2();
@@ -4660,16 +4660,16 @@ l_Lean_regularInitAttr___closed__11 = _init_l_Lean_regularInitAttr___closed__11(
 lean_mark_persistent(l_Lean_regularInitAttr___closed__11);
 l_Lean_regularInitAttr___closed__12 = _init_l_Lean_regularInitAttr___closed__12();
 lean_mark_persistent(l_Lean_regularInitAttr___closed__12);
-res = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_597_(lean_io_mk_world());
+res = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_600_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_regularInitAttr = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_regularInitAttr);
 lean_dec_ref(res);
-l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__1 = _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__1();
-lean_mark_persistent(l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__1);
-l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__2 = _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__2();
-lean_mark_persistent(l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613____closed__2);
-res = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_613_(lean_io_mk_world());
+l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__1 = _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__1();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__1);
+l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__2 = _init_l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__2();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616____closed__2);
+res = l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_616_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_builtinInitAttr = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_builtinInitAttr);

stage0/stdlib/Lean/Compiler/NameMangling.c

@@ -15,39 +15,44 @@ extern "C" {
 #endif
 lean_object* lean_string_push(lean_object*, uint32_t);
 lean_object* lean_nat_div(lean_object*, lean_object*);
-lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux(lean_object*, lean_object*, lean_object*);
+static lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__3;
 uint8_t l_Char_isDigit(uint32_t);
 lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_Name_mangleAux_match__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux(lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_Name_mangleAux___closed__1;
-lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux_match__1(lean_object*);
+lean_object* l_String_mangle(lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
+lean_object* l_Nat_repeat_loop___at___private_Lean_Compiler_NameMangling_0__String_mangleAux___spec__1(lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 static lean_object* l_Lean_mkModuleInitializationFunctionName___closed__1;
 uint32_t l_Nat_digitChar(lean_object*);
+lean_object* l_List_foldl___at___private_Lean_Compiler_NameMangling_0__String_mangleAux___spec__2(lean_object*, lean_object*);
+lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_String_Iterator_next(lean_object*);
 uint8_t l_Char_isAlpha(uint32_t);
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
-lean_object* l_Lean_String_mangle(lean_object*);
 lean_object* lean_mk_module_initialization_function_name(lean_object*);
+lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux_match__1(lean_object*);
 uint32_t l_String_Iterator_curr(lean_object*);
-static lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__2;
+lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Nat_toDigits(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_Name_mangleAux_match__2(lean_object*);
 lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_Name_mangleAux(lean_object*);
-static lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__1;
 lean_object* lean_name_mangle(lean_object*, lean_object*);
 lean_object* lean_string_length(lean_object*);
-static lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__3;
+static lean_object* l_String_mangle___closed__1;
 lean_object* lean_nat_mod(lean_object*, lean_object*);
+static lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__2;
 lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_Name_mangleAux_match__1(lean_object*);
+lean_object* l_List_lengthAux___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_Name_mangleAux_match__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_String_mangle___closed__1;
+static lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__1;
 lean_object* lean_uint32_to_nat(uint32_t);
+static lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__4;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 lean_object* x_6; uint8_t x_7; 
@@ -71,24 +76,81 @@ return x_11;
 }
 }
 }
-lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux_match__1(lean_object* x_1) {
+lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux_match__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux_match__1___rarg___boxed), 5, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Compiler_NameMangling_0__String_mangleAux_match__1___rarg___boxed), 5, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux_match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux_match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 lean_object* x_6; 
-x_6 = l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux_match__1___rarg(x_1, x_2, x_3, x_4, x_5);
+x_6 = l___private_Lean_Compiler_NameMangling_0__String_mangleAux_match__1___rarg(x_1, x_2, x_3, x_4, x_5);
 lean_dec(x_1);
 return x_6;
 }
 }
-static lean_object* _init_l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__1() {
+lean_object* l_Nat_repeat_loop___at___private_Lean_Compiler_NameMangling_0__String_mangleAux___spec__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; uint8_t x_4; 
+x_3 = lean_unsigned_to_nat(0u);
+x_4 = lean_nat_dec_eq(x_1, x_3);
+if (x_4 == 0)
+{
+lean_object* x_5; lean_object* x_6; uint32_t x_7; lean_object* x_8; 
+x_5 = lean_unsigned_to_nat(1u);
+x_6 = lean_nat_sub(x_1, x_5);
+lean_dec(x_1);
+x_7 = 48;
+x_8 = lean_string_push(x_2, x_7);
+x_1 = x_6;
+x_2 = x_8;
+goto _start;
+}
+else
+{
+lean_dec(x_1);
+return x_2;
+}
+}
+}
+lean_object* l_List_foldl___at___private_Lean_Compiler_NameMangling_0__String_mangleAux___spec__2(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+if (lean_obj_tag(x_2) == 0)
+{
+return x_1;
+}
+else
+{
+lean_object* x_3; lean_object* x_4; uint32_t 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_unbox_uint32(x_3);
+lean_dec(x_3);
+x_6 = lean_string_push(x_1, x_5);
+x_1 = x_6;
+x_2 = x_4;
+goto _start;
+}
+}
+}
+static lean_object* _init_l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("_U");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -96,7 +158,7 @@ x_1 = lean_mk_string("_u");
 return x_1;
 }
 }
-static lean_object* _init_l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__2() {
+static lean_object* _init_l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -104,7 +166,7 @@ x_1 = lean_mk_string("_x");
 return x_1;
 }
 }
-static lean_object* _init_l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__3() {
+static lean_object* _init_l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -112,7 +174,7 @@ x_1 = lean_mk_string("__");
 return x_1;
 }
 }
-lean_object* l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l___private_Lean_Compiler_NameMangling_0__String_mangleAux(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -139,96 +201,120 @@ if (x_12 == 0)
 {
 lean_object* x_13; lean_object* x_14; uint8_t x_15; 
 x_13 = lean_uint32_to_nat(x_8);
-x_14 = lean_unsigned_to_nat(255u);
+x_14 = lean_unsigned_to_nat(256u);
 x_15 = lean_nat_dec_lt(x_13, x_14);
 if (x_15 == 0)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint32_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint32_t x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint32_t x_30; lean_object* x_31; lean_object* x_32; uint32_t x_33; lean_object* x_34; lean_object* x_35; 
-x_16 = l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__1;
-x_17 = lean_string_append(x_3, x_16);
-x_18 = lean_unsigned_to_nat(4096u);
-x_19 = lean_nat_div(x_13, x_18);
-x_20 = l_Nat_digitChar(x_19);
-lean_dec(x_19);
-x_21 = lean_string_push(x_17, x_20);
-x_22 = lean_nat_mod(x_13, x_18);
-lean_dec(x_13);
-x_23 = lean_unsigned_to_nat(256u);
-x_24 = lean_nat_div(x_22, x_23);
-x_25 = l_Nat_digitChar(x_24);
-lean_dec(x_24);
-x_26 = lean_string_push(x_21, x_25);
-x_27 = lean_nat_mod(x_22, x_23);
+lean_object* x_16; uint8_t x_17; 
+x_16 = lean_unsigned_to_nat(65536u);
+x_17 = lean_nat_dec_lt(x_13, x_16);
+if (x_17 == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_18 = l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__1;
+x_19 = lean_string_append(x_3, x_18);
+x_20 = lean_unsigned_to_nat(16u);
+x_21 = l_Nat_toDigits(x_20, x_13);
+x_22 = l_List_lengthAux___rarg(x_21, x_4);
+x_23 = lean_unsigned_to_nat(8u);
+x_24 = lean_nat_sub(x_23, x_22);
 lean_dec(x_22);
-x_28 = lean_unsigned_to_nat(16u);
-x_29 = lean_nat_div(x_27, x_28);
-x_30 = l_Nat_digitChar(x_29);
-lean_dec(x_29);
-x_31 = lean_string_push(x_26, x_30);
-x_32 = lean_nat_mod(x_27, x_28);
-lean_dec(x_27);
+x_25 = l_Nat_repeat_loop___at___private_Lean_Compiler_NameMangling_0__String_mangleAux___spec__1(x_24, x_19);
+x_26 = l_List_foldl___at___private_Lean_Compiler_NameMangling_0__String_mangleAux___spec__2(x_25, x_21);
+x_27 = l_String_Iterator_next(x_2);
+x_1 = x_7;
+x_2 = x_27;
+x_3 = x_26;
+goto _start;
+}
+else
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint32_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint32_t x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint32_t x_42; lean_object* x_43; lean_object* x_44; uint32_t x_45; lean_object* x_46; lean_object* x_47; 
+x_29 = l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__2;
+x_30 = lean_string_append(x_3, x_29);
+x_31 = lean_unsigned_to_nat(4096u);
+x_32 = lean_nat_div(x_13, x_31);
 x_33 = l_Nat_digitChar(x_32);
 lean_dec(x_32);
-x_34 = lean_string_push(x_31, x_33);
-x_35 = l_String_Iterator_next(x_2);
-x_1 = x_7;
-x_2 = x_35;
-x_3 = x_34;
-goto _start;
-}
-else
-{
-lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint32_t x_41; lean_object* x_42; lean_object* x_43; uint32_t x_44; lean_object* x_45; lean_object* x_46; 
-x_37 = l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__2;
-x_38 = lean_string_append(x_3, x_37);
-x_39 = lean_unsigned_to_nat(16u);
-x_40 = lean_nat_div(x_13, x_39);
-x_41 = l_Nat_digitChar(x_40);
-lean_dec(x_40);
-x_42 = lean_string_push(x_38, x_41);
-x_43 = lean_nat_mod(x_13, x_39);
+x_34 = lean_string_push(x_30, x_33);
+x_35 = lean_nat_mod(x_13, x_31);
 lean_dec(x_13);
-x_44 = l_Nat_digitChar(x_43);
-lean_dec(x_43);
-x_45 = lean_string_push(x_42, x_44);
-x_46 = l_String_Iterator_next(x_2);
+x_36 = lean_nat_div(x_35, x_14);
+x_37 = l_Nat_digitChar(x_36);
+lean_dec(x_36);
+x_38 = lean_string_push(x_34, x_37);
+x_39 = lean_nat_mod(x_35, x_14);
+lean_dec(x_35);
+x_40 = lean_unsigned_to_nat(16u);
+x_41 = lean_nat_div(x_39, x_40);
+x_42 = l_Nat_digitChar(x_41);
+lean_dec(x_41);
+x_43 = lean_string_push(x_38, x_42);
+x_44 = lean_nat_mod(x_39, x_40);
+lean_dec(x_39);
+x_45 = l_Nat_digitChar(x_44);
+lean_dec(x_44);
+x_46 = lean_string_push(x_43, x_45);
+x_47 = l_String_Iterator_next(x_2);
 x_1 = x_7;
-x_2 = x_46;
-x_3 = x_45;
+x_2 = x_47;
+x_3 = x_46;
 goto _start;
 }
 }
 else
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-x_48 = l_String_Iterator_next(x_2);
-x_49 = l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__3;
+lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint32_t x_53; lean_object* x_54; lean_object* x_55; uint32_t x_56; lean_object* x_57; lean_object* x_58; 
+x_49 = l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__3;
 x_50 = lean_string_append(x_3, x_49);
+x_51 = lean_unsigned_to_nat(16u);
+x_52 = lean_nat_div(x_13, x_51);
+x_53 = l_Nat_digitChar(x_52);
+lean_dec(x_52);
+x_54 = lean_string_push(x_50, x_53);
+x_55 = lean_nat_mod(x_13, x_51);
+lean_dec(x_13);
+x_56 = l_Nat_digitChar(x_55);
+lean_dec(x_55);
+x_57 = lean_string_push(x_54, x_56);
+x_58 = l_String_Iterator_next(x_2);
 x_1 = x_7;
-x_2 = x_48;
-x_3 = x_50;
+x_2 = x_58;
+x_3 = x_57;
 goto _start;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; 
-x_52 = l_String_Iterator_next(x_2);
-x_53 = lean_string_push(x_3, x_8);
+lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+x_60 = l_String_Iterator_next(x_2);
+x_61 = l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__4;
+x_62 = lean_string_append(x_3, x_61);
 x_1 = x_7;
-x_2 = x_52;
-x_3 = x_53;
+x_2 = x_60;
+x_3 = x_62;
 goto _start;
 }
 }
 else
 {
-lean_object* x_55; lean_object* x_56; 
-x_55 = l_String_Iterator_next(x_2);
-x_56 = lean_string_push(x_3, x_8);
+lean_object* x_64; lean_object* x_65; 
+x_64 = l_String_Iterator_next(x_2);
+x_65 = lean_string_push(x_3, x_8);
 x_1 = x_7;
-x_2 = x_55;
-x_3 = x_56;
+x_2 = x_64;
+x_3 = x_65;
+goto _start;
+}
+}
+else
+{
+lean_object* x_67; lean_object* x_68; 
+x_67 = l_String_Iterator_next(x_2);
+x_68 = lean_string_push(x_3, x_8);
+x_1 = x_7;
+x_2 = x_67;
+x_3 = x_68;
 goto _start;
 }
 }
@@ -240,7 +326,7 @@ return x_3;
 }
 }
 }
-static lean_object* _init_l_Lean_String_mangle___closed__1() {
+static lean_object* _init_l_String_mangle___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -248,7 +334,7 @@ x_1 = lean_mk_string("");
 return x_1;
 }
 }
-lean_object* l_Lean_String_mangle(lean_object* x_1) {
+lean_object* l_String_mangle(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; 
@@ -257,8 +343,8 @@ x_3 = lean_unsigned_to_nat(0u);
 x_4 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_3);
-x_5 = l_Lean_String_mangle___closed__1;
-x_6 = l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux(x_2, x_4, x_5);
+x_5 = l_String_mangle___closed__1;
+x_6 = l___private_Lean_Compiler_NameMangling_0__String_mangleAux(x_2, x_4, x_5);
 return x_6;
 }
 }
@@ -359,7 +445,7 @@ switch (lean_obj_tag(x_1)) {
 case 0:
 {
 lean_object* x_2; 
-x_2 = l_Lean_String_mangle___closed__1;
+x_2 = l_String_mangle___closed__1;
 return x_2;
 }
 case 1:
@@ -370,7 +456,7 @@ lean_inc(x_3);
 x_4 = lean_ctor_get(x_1, 1);
 lean_inc(x_4);
 lean_dec(x_1);
-x_5 = l_Lean_String_mangle(x_4);
+x_5 = l_String_mangle(x_4);
 if (lean_obj_tag(x_3) == 0)
 {
 return x_5;
@@ -428,7 +514,7 @@ lean_object* lean_mk_module_initialization_function_name(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_2 = l_Lean_String_mangle___closed__1;
+x_2 = l_String_mangle___closed__1;
 x_3 = lean_name_mangle(x_1, x_2);
 x_4 = l_Lean_mkModuleInitializationFunctionName___closed__1;
 x_5 = lean_string_append(x_4, x_3);
@@ -449,14 +535,16 @@ lean_dec_ref(res);
 res = initialize_Lean_Data_Name(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__1 = _init_l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__1();
-lean_mark_persistent(l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__1);
-l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__2 = _init_l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__2();
-lean_mark_persistent(l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__2);
-l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__3 = _init_l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__3();
-lean_mark_persistent(l___private_Lean_Compiler_NameMangling_0__Lean_String_mangleAux___closed__3);
-l_Lean_String_mangle___closed__1 = _init_l_Lean_String_mangle___closed__1();
-lean_mark_persistent(l_Lean_String_mangle___closed__1);
+l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__1 = _init_l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__1();
+lean_mark_persistent(l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__1);
+l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__2 = _init_l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__2();
+lean_mark_persistent(l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__2);
+l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__3 = _init_l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__3();
+lean_mark_persistent(l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__3);
+l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__4 = _init_l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__4();
+lean_mark_persistent(l___private_Lean_Compiler_NameMangling_0__String_mangleAux___closed__4);
+l_String_mangle___closed__1 = _init_l_String_mangle___closed__1();
+lean_mark_persistent(l_String_mangle___closed__1);
 l___private_Lean_Compiler_NameMangling_0__Lean_Name_mangleAux___closed__1 = _init_l___private_Lean_Compiler_NameMangling_0__Lean_Name_mangleAux___closed__1();
 lean_mark_persistent(l___private_Lean_Compiler_NameMangling_0__Lean_Name_mangleAux___closed__1);
 l_Lean_mkModuleInitializationFunctionName___closed__1 = _init_l_Lean_mkModuleInitializationFunctionName___closed__1();

stage0/stdlib/Lean/Compiler/Specialize.c

@@ -34,7 +34,6 @@ lean_object* l_Lean_Compiler_specExtension___elambda__4(lean_object*, lean_objec
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
-static lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___closed__1;
 lean_object* l_Std_PersistentHashMap_findAux___at_Lean_Compiler_getCachedSpecialization___spec__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_Specialize_0__Lean_Compiler_beqSpecializeAttributeKind____x40_Lean_Compiler_Specialize___hyg_11__match__1___rarg(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__6(lean_object*, lean_object*, lean_object*);
@@ -62,7 +61,7 @@ lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean
 uint8_t l___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux(lean_object*, uint8_t, lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAux_traverse___at_Lean_Compiler_SpecState_addEntry___spec__4(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__2(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_SMap_find_x3f___at_Lean_Compiler_getSpecializationInfo___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_specializeAttrs;
 lean_object* l_Lean_EnumAttributes_getValue___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__1___boxed(lean_object*, lean_object*, lean_object*);
@@ -71,31 +70,31 @@ lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* l_Std_AssocList_contains___at_Lean_Compiler_SpecState_addEntry___spec__7___boxed(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Std_PersistentHashMap_getCollisionNodeSize___rarg(lean_object*);
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__3(lean_object*, size_t, size_t, lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__3(lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Std_AssocList_foldlM___at_Lean_Compiler_SpecState_addEntry___spec__10(lean_object*, lean_object*);
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__4___boxed(lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__1;
 static lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__5___lambda__1___closed__1;
 lean_object* l___private_Lean_Compiler_Specialize_0__Lean_Compiler_beqSpecializeAttributeKind____x40_Lean_Compiler_Specialize___hyg_11__match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__5(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_specExtension___closed__1;
+lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__5(lean_object*, lean_object*);
 lean_object* l_Std_AssocList_replace___at_Lean_Compiler_SpecState_addEntry___spec__11(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_find_x3f___at_Lean_Compiler_getCachedSpecialization___spec__1(lean_object*, lean_object*);
 static lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___lambda__4___closed__6;
-lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__5(lean_object*, lean_object*);
 lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_specializeAttrs___closed__5;
 static lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___closed__5;
 size_t l_USize_shiftRight(size_t, size_t);
 lean_object* l_Lean_SMap_switch___at_Lean_Compiler_SpecState_switch___spec__1(lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_specializeAttrs___lambda__2___boxed(lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_expand___at_Lean_Compiler_SpecState_addEntry___spec__8(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_specializeAttrs___closed__3;
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__13(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__2;
 lean_object* l_Lean_Compiler_specializeAttrs___lambda__4___boxed(lean_object*);
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_specExtension___closed__4;
 lean_object* l_Lean_SMap_switch___at_Lean_Compiler_SpecState_switch___spec__2(lean_object*);
@@ -110,6 +109,8 @@ static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg
 size_t l_UInt64_toUSize(uint64_t);
 lean_object* l_Std_AssocList_find_x3f___at_Lean_Compiler_getCachedSpecialization___spec__6(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_SpecState_switch_match__1___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__3(lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__3;
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__5___lambda__2(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_specExtension___closed__2;
 lean_object* l_Lean_Compiler_specializeAttrs___lambda__3(lean_object*);
@@ -117,7 +118,6 @@ lean_object* l_Lean_Compiler_specializeAttrs___lambda__1___boxed(lean_object*, l
 static uint32_t l_Lean_Compiler_specializeAttrs___lambda__1___closed__1;
 static lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___lambda__4___closed__3;
 lean_object* l_Lean_SMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__4___boxed(lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_moveEntries___at_Lean_Compiler_SpecState_addEntry___spec__20(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_specExtension;
@@ -125,15 +125,14 @@ lean_object* l_Std_HashMapImp_expand___at_Lean_Compiler_SpecState_addEntry___spe
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 uint8_t l___private_Lean_Attributes_0__Lean_beqAttributeKind____x40_Lean_Attributes___hyg_139_(uint8_t, uint8_t);
 lean_object* l_Std_PersistentHashMap_find_x3f___at_Lean_Compiler_getCachedSpecialization___spec__2(lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__3;
 lean_object* l_Lean_Compiler_specializeAttrs___lambda__3___boxed(lean_object*);
 lean_object* l___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__3(lean_object*, lean_object*);
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__4(lean_object*);
 lean_object* l_EStateM_bind___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__2(lean_object*, size_t, size_t, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__2(lean_object*, size_t, size_t, lean_object*);
 static lean_object* l_List_map___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__7___lambda__2___closed__2;
 lean_object* lean_array_swap(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Compiler_instInhabitedSpecializeAttributeKind;
@@ -156,6 +155,7 @@ lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_
 uint64_t l_Lean_Name_hash(lean_object*);
 static lean_object* l_Array_qpartition_loop___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__4___closed__1;
 lean_object* l_Nat_repr(lean_object*);
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_List_map___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__7___lambda__4___closed__1;
 uint64_t l_Lean_Expr_hash(lean_object*);
 lean_object* l_List_map___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__7___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -170,14 +170,14 @@ size_t l_USize_shiftLeft(size_t, size_t);
 lean_object* l_Array_qpartition_loop___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_has_specialize_attribute(lean_object*, lean_object*);
 extern lean_object* l_Lean_persistentEnvExtensionsRef;
-lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__1(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_specializeAttrs___closed__7;
+lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__1(lean_object*, lean_object*);
 uint8_t l_Std_AssocList_contains___at_Lean_Compiler_SpecState_addEntry___spec__7(lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__1;
 lean_object* l_Lean_Compiler_specializeAttrs___lambda__4(lean_object*);
 lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___lambda__4(lean_object*);
 lean_object* l_List_map___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__7___lambda__1(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_modn(size_t, lean_object*);
-static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__2;
 lean_object* l_Lean_SMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__12(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_AttributeImpl_erase___default___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_instInhabitedSpecState___closed__4;
@@ -201,13 +201,12 @@ static lean_object* l_List_map___at_Lean_Compiler_initFn____x40_Lean_Compiler_Sp
 lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
 size_t l_USize_land(size_t, size_t);
 static lean_object* l_Lean_Compiler_instInhabitedSpecInfo___closed__1;
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SimplePersistentEnvExtension_getState___rarg(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__6;
 static lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___lambda__4___closed__5;
-lean_object* l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__2;
 lean_object* l_Array_binSearchAux___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__4(lean_object*);
-static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__1;
 lean_object* lean_cache_specialization(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_instInhabitedExt___lambda__1(lean_object*);
 uint8_t l_Lean_Compiler_instInhabitedSpecArgKind;
@@ -217,17 +216,16 @@ lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____
 lean_object* l_Lean_Compiler_specializeAttrs___lambda__2(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAux___at_Lean_Compiler_SpecState_addEntry___spec__14___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_find_x3f___at_Lean_Compiler_getSpecializationInfo___spec__6(lean_object*, lean_object*);
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4(lean_object*, lean_object*);
 uint8_t l___private_Lean_Compiler_Specialize_0__Lean_Compiler_beqSpecializeAttributeKind____x40_Lean_Compiler_Specialize___hyg_11_(uint8_t, uint8_t);
 static lean_object* l_List_map___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__7___lambda__2___closed__4;
 static lean_object* l_Lean_Compiler_specializeAttrs___closed__4;
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__13;
 lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___lambda__3___boxed(lean_object*);
 uint8_t lean_expr_eqv(lean_object*, lean_object*);
-lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____lambda__1(lean_object*);
-lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323_(lean_object*);
+lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324_(lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49_(lean_object*);
 lean_object* lean_list_to_array(lean_object*, lean_object*);
+lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____lambda__1___boxed(lean_object*);
 static lean_object* l_Lean_Compiler_instInhabitedSpecState___closed__3;
 lean_object* l_List_map___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__7(lean_object*, uint8_t, lean_object*, lean_object*);
 uint8_t lean_has_nospecialize_attribute(lean_object*, lean_object*);
@@ -235,17 +233,17 @@ static lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compil
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 uint8_t l_USize_decLe(size_t, size_t);
 lean_object* l_Lean_SMap_find_x3f___at_Lean_Compiler_getSpecializationInfo___spec__1(lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__4;
 lean_object* l_Std_PersistentHashMap_findAtAux___at_Lean_Compiler_getCachedSpecialization___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_findAtAux___at_Lean_Compiler_getSpecializationInfo___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_AssocList_contains___at_Lean_Compiler_SpecState_addEntry___spec__18(lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__4;
 lean_object* l_Lean_Compiler_instInhabitedSpecInfo;
 static lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__5___closed__2;
 lean_object* l_Std_PersistentHashMap_find_x3f___at_Lean_Compiler_getSpecializationInfo___spec__2___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____lambda__1___boxed(lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__5___lambda__2___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____lambda__1(lean_object*);
 lean_object* l_Lean_Compiler_specExtension___elambda__2(lean_object*);
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4(lean_object*, lean_object*);
 static lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___closed__3;
 lean_object* l_Lean_Compiler_specExtension___elambda__1___boxed(lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__10;
@@ -290,8 +288,8 @@ lean_object* l_Std_PersistentHashMap_insertAux_traverse___at_Lean_Compiler_SpecS
 lean_object* l_Std_PersistentHashMap_insertAtCollisionNodeAux___at_Lean_Compiler_SpecState_addEntry___spec__16(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__7;
 lean_object* l_Lean_Compiler_SpecState_switch(lean_object*);
-uint8_t l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__6(lean_object*, lean_object*, size_t, size_t);
 lean_object* l_Lean_Attribute_Builtin_ensureNoArgs(lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__6(lean_object*, lean_object*, size_t, size_t);
 lean_object* l_Lean_Compiler_SpecState_addEntry(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_specExtension___elambda__4___boxed(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__15;
@@ -300,7 +298,6 @@ static lean_object* l_Lean_Compiler_specExtension___closed__3;
 static lean_object* l_Lean_Compiler_specExtension___closed__5;
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__14;
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_lengthAux___rarg(lean_object*, lean_object*);
 lean_object* l_Std_mkHashMap___at_Lean_Compiler_SpecState_cache___default___spec__1(lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__5;
@@ -313,19 +310,22 @@ lean_object* l_EStateM_pure___rarg(lean_object*, lean_object*);
 uint32_t lean_uint32_of_nat(lean_object*);
 lean_object* l_Lean_Compiler_SpecState_addEntry_match__1(lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__3;
+lean_object* l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__17(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_List_map___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__7___lambda__2(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_findAux___at_Lean_Compiler_getSpecializationInfo___spec__3(lean_object*, size_t, lean_object*);
+static lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___closed__1;
 lean_object* l_Lean_Compiler_specExtension___elambda__3(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_mkEmptyEntries(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_specializeAttrs___lambda__1___closed__3;
 static lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___lambda__4___closed__1;
 static lean_object* l_Lean_Compiler_instBEqSpecializeAttributeKind___closed__1;
 static lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__1___closed__1;
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_specExtension___elambda__4___rarg(lean_object*);
 lean_object* l_Std_AssocList_contains___at_Lean_Compiler_SpecState_addEntry___spec__18___boxed(lean_object*, lean_object*);
 lean_object* l_List_map___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____spec__7___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_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_find_x3f___at_Lean_Compiler_getCachedSpecialization___spec__5___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_instInhabitedSpecState;
@@ -5020,7 +5020,7 @@ return x_11;
 }
 }
 }
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__2(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) {
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__2(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -5042,7 +5042,7 @@ return x_4;
 }
 }
 }
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__3(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) {
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__3(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -5080,7 +5080,7 @@ size_t x_15; size_t x_16; lean_object* x_17;
 x_15 = 0;
 x_16 = lean_usize_of_nat(x_7);
 lean_dec(x_7);
-x_17 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__2(x_6, x_15, x_16, x_4);
+x_17 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__2(x_6, x_15, x_16, x_4);
 lean_dec(x_6);
 x_2 = x_11;
 x_4 = x_17;
@@ -5094,7 +5094,7 @@ return x_4;
 }
 }
 }
-lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; uint8_t x_5; 
@@ -5121,13 +5121,13 @@ size_t x_7; size_t x_8; lean_object* x_9;
 x_7 = 0;
 x_8 = lean_usize_of_nat(x_3);
 lean_dec(x_3);
-x_9 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__3(x_2, x_7, x_8, x_1);
+x_9 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__3(x_2, x_7, x_8, x_1);
 return x_9;
 }
 }
 }
 }
-uint8_t l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__6(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4) {
+uint8_t l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__6(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -5165,7 +5165,7 @@ return x_14;
 }
 }
 }
-lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__5(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__5(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; uint8_t x_5; 
@@ -5210,7 +5210,7 @@ size_t x_16; size_t x_17; uint8_t x_18;
 x_16 = 0;
 x_17 = lean_usize_of_nat(x_8);
 lean_dec(x_8);
-x_18 = l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__6(x_1, x_6, x_16, x_17);
+x_18 = l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__6(x_1, x_6, x_16, x_17);
 lean_dec(x_6);
 if (x_18 == 0)
 {
@@ -5281,7 +5281,7 @@ size_t x_39; size_t x_40; uint8_t x_41;
 x_39 = 0;
 x_40 = lean_usize_of_nat(x_31);
 lean_dec(x_31);
-x_41 = l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__6(x_1, x_29, x_39, x_40);
+x_41 = l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__6(x_1, x_29, x_39, x_40);
 lean_dec(x_29);
 if (x_41 == 0)
 {
@@ -5315,7 +5315,7 @@ return x_52;
 }
 }
 }
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 lean_object* x_6; lean_object* x_7; lean_object* x_8; 
@@ -5329,7 +5329,7 @@ lean_ctor_set(x_8, 1, x_5);
 return x_8;
 }
 }
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint8_t x_4; 
@@ -5374,7 +5374,7 @@ return x_15;
 }
 }
 }
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__3(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__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; 
@@ -5389,7 +5389,7 @@ x_6 = lean_apply_1(x_3, x_5);
 return x_6;
 }
 }
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__4(lean_object* x_1) {
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__4(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
@@ -5406,15 +5406,15 @@ lean_ctor_set(x_8, 1, x_6);
 return x_8;
 }
 }
-static lean_object* _init_l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___closed__1() {
+static lean_object* _init_l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__4___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__4___boxed), 1, 0);
 return x_1;
 }
 }
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
@@ -5431,15 +5431,15 @@ lean_ctor_set(x_8, 0, x_5);
 lean_ctor_set(x_8, 1, x_7);
 x_9 = lean_alloc_closure((void*)(l_EStateM_pure___rarg), 2, 1);
 lean_closure_set(x_9, 0, x_8);
-x_10 = lean_alloc_closure((void*)(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__1___boxed), 5, 2);
+x_10 = lean_alloc_closure((void*)(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__1___boxed), 5, 2);
 lean_closure_set(x_10, 0, x_4);
 lean_closure_set(x_10, 1, x_5);
 lean_inc(x_1);
-x_11 = lean_alloc_closure((void*)(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__2), 3, 1);
+x_11 = lean_alloc_closure((void*)(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__2), 3, 1);
 lean_closure_set(x_11, 0, x_1);
-x_12 = lean_alloc_closure((void*)(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__3), 2, 1);
+x_12 = lean_alloc_closure((void*)(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__3), 2, 1);
 lean_closure_set(x_12, 0, x_1);
-x_13 = l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___closed__1;
+x_13 = l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___closed__1;
 x_14 = lean_alloc_ctor(0, 6, 0);
 lean_ctor_set(x_14, 0, x_3);
 lean_ctor_set(x_14, 1, x_9);
@@ -5447,21 +5447,21 @@ lean_ctor_set(x_14, 2, x_10);
 lean_ctor_set(x_14, 3, x_11);
 lean_ctor_set(x_14, 4, x_12);
 lean_ctor_set(x_14, 5, x_13);
-x_15 = l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__5(x_14, x_2);
+x_15 = l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__5(x_14, x_2);
 return x_15;
 }
 }
-lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____lambda__1(lean_object* x_1) {
+lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____lambda__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = l_Lean_Compiler_instInhabitedSpecState___closed__4;
-x_3 = l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__1(x_2, x_1);
+x_3 = l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__1(x_2, x_1);
 x_4 = l_Lean_Compiler_SpecState_switch(x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__1() {
+static lean_object* _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -5470,7 +5470,7 @@ lean_closure_set(x_1, 0, lean_box(0));
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__2() {
+static lean_object* _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -5478,22 +5478,22 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Compiler_SpecState_addEntry), 2, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__3() {
+static lean_object* _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____lambda__1___boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____lambda__1___boxed), 1, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__4() {
+static lean_object* _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__4() {
 _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_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_49____closed__4;
-x_2 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__2;
-x_3 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__3;
-x_4 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__1;
+x_2 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__2;
+x_3 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__3;
+x_4 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__1;
 x_5 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
@@ -5502,16 +5502,16 @@ lean_ctor_set(x_5, 3, x_4);
 return x_5;
 }
 }
-lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323_(lean_object* x_1) {
+lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__4;
-x_3 = l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4(x_2, x_1);
+x_2 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__4;
+x_3 = l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4(x_2, x_1);
 return x_3;
 }
 }
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 size_t x_5; size_t x_6; lean_object* x_7; 
@@ -5519,12 +5519,12 @@ x_5 = lean_unbox_usize(x_2);
 lean_dec(x_2);
 x_6 = lean_unbox_usize(x_3);
 lean_dec(x_3);
-x_7 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__2(x_1, x_5, x_6, x_4);
+x_7 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__2(x_1, x_5, x_6, x_4);
 lean_dec(x_1);
 return x_7;
 }
 }
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 size_t x_5; size_t x_6; lean_object* x_7; 
@@ -5532,21 +5532,21 @@ x_5 = lean_unbox_usize(x_2);
 lean_dec(x_2);
 x_6 = lean_unbox_usize(x_3);
 lean_dec(x_3);
-x_7 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__3(x_1, x_5, x_6, x_4);
+x_7 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__3(x_1, x_5, x_6, x_4);
 lean_dec(x_1);
 return x_7;
 }
 }
-lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__1(x_1, x_2);
+x_3 = l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__1(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
 }
-lean_object* l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 size_t x_5; size_t x_6; uint8_t x_7; lean_object* x_8; 
@@ -5554,36 +5554,36 @@ x_5 = lean_unbox_usize(x_3);
 lean_dec(x_3);
 x_6 = lean_unbox_usize(x_4);
 lean_dec(x_4);
-x_7 = l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__6(x_1, x_2, x_5, x_6);
+x_7 = l_Array_anyMUnsafe_any___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__6(x_1, x_2, x_5, x_6);
 lean_dec(x_2);
 lean_dec(x_1);
 x_8 = lean_box(x_7);
 return x_8;
 }
 }
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 lean_object* x_6; 
-x_6 = l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__1(x_1, x_2, x_3, x_4, x_5);
+x_6 = l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__1(x_1, x_2, x_3, x_4, x_5);
 lean_dec(x_4);
 return x_6;
 }
 }
-lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__4___boxed(lean_object* x_1) {
+lean_object* l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__4___boxed(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___lambda__4(x_1);
+x_2 = l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___lambda__4(x_1);
 lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____lambda__1___boxed(lean_object* x_1) {
+lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____lambda__1___boxed(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____lambda__1(x_1);
+x_2 = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____lambda__1(x_1);
 lean_dec(x_1);
 return x_2;
 }
@@ -6537,16 +6537,16 @@ l_Std_PersistentHashMap_insertAux___at_Lean_Compiler_SpecState_addEntry___spec__
 l_Std_PersistentHashMap_insertAux___at_Lean_Compiler_SpecState_addEntry___spec__3___closed__2 = _init_l_Std_PersistentHashMap_insertAux___at_Lean_Compiler_SpecState_addEntry___spec__3___closed__2();
 l_Std_PersistentHashMap_insertAux___at_Lean_Compiler_SpecState_addEntry___spec__3___closed__3 = _init_l_Std_PersistentHashMap_insertAux___at_Lean_Compiler_SpecState_addEntry___spec__3___closed__3();
 lean_mark_persistent(l_Std_PersistentHashMap_insertAux___at_Lean_Compiler_SpecState_addEntry___spec__3___closed__3);
-l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___closed__1 = _init_l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___closed__1();
-lean_mark_persistent(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____spec__4___closed__1);
-l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__1 = _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__1();
-lean_mark_persistent(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__1);
-l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__2 = _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__2();
-lean_mark_persistent(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__2);
-l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__3 = _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__3();
-lean_mark_persistent(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__3);
-l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__4 = _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__4();
-lean_mark_persistent(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323____closed__4);
+l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___closed__1 = _init_l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___closed__1();
+lean_mark_persistent(l_Lean_registerSimplePersistentEnvExtension___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____spec__4___closed__1);
+l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__1 = _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__1();
+lean_mark_persistent(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__1);
+l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__2 = _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__2();
+lean_mark_persistent(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__2);
+l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__3 = _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__3();
+lean_mark_persistent(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__3);
+l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__4 = _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__4();
+lean_mark_persistent(l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324____closed__4);
 l_Lean_Compiler_specExtension___closed__1 = _init_l_Lean_Compiler_specExtension___closed__1();
 lean_mark_persistent(l_Lean_Compiler_specExtension___closed__1);
 l_Lean_Compiler_specExtension___closed__2 = _init_l_Lean_Compiler_specExtension___closed__2();
@@ -6557,7 +6557,7 @@ l_Lean_Compiler_specExtension___closed__4 = _init_l_Lean_Compiler_specExtension_
 lean_mark_persistent(l_Lean_Compiler_specExtension___closed__4);
 l_Lean_Compiler_specExtension___closed__5 = _init_l_Lean_Compiler_specExtension___closed__5();
 lean_mark_persistent(l_Lean_Compiler_specExtension___closed__5);
-res = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_323_(lean_io_mk_world());
+res = l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_324_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Compiler_specExtension = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Compiler_specExtension);

stage0/stdlib/Lean/Data/Lsp/InitShutdown.c

@@ -15,8 +15,7 @@ extern "C" {
 #endif
 static lean_object* l_Lean_Lsp_instFromJsonTrace___closed__1;
 static lean_object* l_Lean_Lsp_instFromJsonTrace___closed__3;
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593_(lean_object*);
-lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____spec__1___boxed(lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595_(lean_object*);
 static lean_object* l_Lean_Lsp_instFromJsonTrace___closed__5;
 static lean_object* l_Lean_Lsp_instToJsonInitializeResult___closed__1;
 size_t l_USize_add(size_t, size_t);
@@ -27,23 +26,24 @@ static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonIni
 lean_object* l_Lean_Lsp_instFromJsonInitializeParams(lean_object*);
 static lean_object* l_Lean_Lsp_instToJsonInitializationOptions___closed__1;
 lean_object* lean_array_uget(lean_object*, size_t);
+lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Lsp_InitializeResult_serverInfo_x3f___default;
-static lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2___closed__1;
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
-lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2___boxed(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_498_(lean_object*);
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_500_(lean_object*);
 static lean_object* l_Lean_Lsp_Trace_hasToJson___closed__2;
 lean_object* l_Lean_Lsp_InitializeParams_processId_x3f___default;
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Lsp_instFromJsonInitializeParams___spec__7(size_t, size_t, lean_object*);
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_471____boxed(lean_object*);
 lean_object* l_Lean_Lsp_instToJsonServerInfo;
 lean_object* l_Lean_Json_getStr_x3f(lean_object*);
 static lean_object* l_Lean_Lsp_instFromJsonTrace_match__1___rarg___closed__2;
 lean_object* l_Lean_Lsp_instToJsonInitializedParams___boxed(lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Lean_Lsp_Trace_hasToJson___boxed(lean_object*);
-lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Lsp_Trace_hasToJson(uint8_t);
 lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____spec__1___boxed(lean_object*, lean_object*);
+static lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2___closed__1;
 lean_object* l_List_join___rarg(lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
 static lean_object* l_Lean_Lsp_instFromJsonTrace___closed__4;
@@ -72,8 +72,7 @@ lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializePar
 static lean_object* l_Lean_Lsp_Trace_hasToJson___closed__1;
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____closed__4;
 static lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializeParams___spec__4___closed__1;
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_469____boxed(lean_object*);
-lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____spec__1(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____closed__9;
 static lean_object* l_Lean_Lsp_instFromJsonTrace_match__1___rarg___closed__1;
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____closed__7;
@@ -95,18 +94,17 @@ lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializePar
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializeParams___spec__5___boxed(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____closed__15;
 lean_object* l_Lean_Lsp_instToJsonInitializedParams(lean_object*);
-lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Lsp_instToJsonInitializationOptions;
 lean_object* l_Lean_Lsp_instFromJsonInitializeResult;
 lean_object* l___private_Lean_Data_Lsp_Capabilities_0__Lean_Lsp_fromJsonServerCapabilities____x40_Lean_Data_Lsp_Capabilities___hyg_197_(lean_object*);
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_469_(lean_object*);
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_471_(lean_object*);
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____closed__11;
 lean_object* l_Lean_Lsp_Trace_hasToJson_match__1(lean_object*);
 lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializationOptions____x40_Lean_Data_Lsp_InitShutdown___hyg_200_(lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializeParams___spec__5(lean_object*, lean_object*);
 static lean_object* l_Lean_Lsp_instFromJsonClientInfo___closed__1;
-lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2(lean_object*, lean_object*);
+lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____spec__2(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____closed__12;
 lean_object* l_Lean_Lsp_instFromJsonTrace_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -125,7 +123,7 @@ lean_object* l_Lean_Json_mkObj(lean_object*);
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonClientInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_26____closed__1;
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____closed__10;
 lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____spec__3(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____boxed(lean_object*);
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____boxed(lean_object*);
 static lean_object* l_Lean_Lsp_instFromJsonInitializeResult___closed__1;
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____closed__16;
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializeParams___spec__4(lean_object*, lean_object*);
@@ -137,15 +135,16 @@ lean_object* l_Lean_Lsp_InitializeParams_rootUri_x3f___default;
 lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Lsp_InitializeParams_initializationOptions_x3f___default;
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Lsp_instFromJsonInitializeParams___spec__7___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__1___boxed(lean_object*, lean_object*);
 static lean_object* l_Lean_Lsp_instFromJsonTrace_match__1___rarg___closed__3;
 lean_object* l___private_Lean_Data_Lsp_Workspace_0__Lean_Lsp_fromJsonWorkspaceFolder____x40_Lean_Data_Lsp_Workspace___hyg_58_(lean_object*);
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_498____boxed(lean_object*);
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_500____boxed(lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____spec__4(lean_object*, lean_object*);
 lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializationOptions____x40_Lean_Data_Lsp_InitShutdown___hyg_180_(lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_Basic_0__Lean_Lsp_fromJsonVersionedTextDocumentIdentifier____x40_Lean_Data_Lsp_Basic___hyg_1177____spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303_(lean_object*);
-static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____closed__1;
+static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____closed__1;
 static lean_object* l_Lean_Lsp_instFromJsonInitializationOptions___closed__1;
 lean_object* l_Lean_Lsp_InitializeParams_workspaceFolders_x3f___default;
 lean_object* l_Lean_Lsp_ClientInfo_version_x3f___default;
@@ -153,7 +152,8 @@ lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_instFromJsonInitializePar
 static lean_object* l_Lean_Lsp_instToJsonClientInfo___closed__1;
 static lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializationOptions____x40_Lean_Data_Lsp_InitShutdown___hyg_180____closed__1;
 static lean_object* l_Lean_Lsp_Trace_hasToJson___closed__3;
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564_(lean_object*);
+lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__1(lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566_(lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_JsonRpc_instFromJsonMessage___spec__2(lean_object*, lean_object*);
 static lean_object* _init_l_Lean_Lsp_ClientInfo_version_x3f___default() {
@@ -2532,7 +2532,7 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_469_(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_471_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
@@ -2562,11 +2562,11 @@ x_14 = l_Lean_Json_mkObj(x_13);
 return x_14;
 }
 }
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_469____boxed(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_471____boxed(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_469_(x_1);
+x_2 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_471_(x_1);
 lean_dec(x_1);
 return x_2;
 }
@@ -2575,7 +2575,7 @@ static lean_object* _init_l_Lean_Lsp_instToJsonServerInfo___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_469____boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_471____boxed), 1, 0);
 return x_1;
 }
 }
@@ -2587,7 +2587,7 @@ x_1 = l_Lean_Lsp_instToJsonServerInfo___closed__1;
 return x_1;
 }
 }
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_498_(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_500_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -2671,11 +2671,11 @@ return x_18;
 }
 }
 }
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_498____boxed(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_500____boxed(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_498_(x_1);
+x_2 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_500_(x_1);
 lean_dec(x_1);
 return x_2;
 }
@@ -2684,7 +2684,7 @@ static lean_object* _init_l_Lean_Lsp_instFromJsonServerInfo___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_498____boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_500____boxed), 1, 0);
 return x_1;
 }
 }
@@ -2704,7 +2704,7 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -2718,7 +2718,7 @@ else
 {
 lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_4 = lean_ctor_get(x_2, 0);
-x_5 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_469_(x_4);
+x_5 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_471_(x_4);
 x_6 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_6, 0, x_1);
 lean_ctor_set(x_6, 1, x_5);
@@ -2730,7 +2730,7 @@ return x_8;
 }
 }
 }
-static lean_object* _init_l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____closed__1() {
+static lean_object* _init_l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -2738,7 +2738,7 @@ x_1 = lean_mk_string("serverInfo");
 return x_1;
 }
 }
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564_(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
@@ -2756,8 +2756,8 @@ lean_ctor_set(x_7, 1, x_6);
 x_8 = lean_ctor_get(x_1, 1);
 lean_inc(x_8);
 lean_dec(x_1);
-x_9 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____closed__1;
-x_10 = l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____spec__1(x_9, x_8);
+x_9 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____closed__1;
+x_10 = l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____spec__1(x_9, x_8);
 lean_dec(x_8);
 x_11 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_11, 0, x_10);
@@ -2770,11 +2770,11 @@ x_14 = l_Lean_Json_mkObj(x_13);
 return x_14;
 }
 }
-lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____spec__1(x_1, x_2);
+x_3 = l_Lean_Json_opt___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____spec__1(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -2783,7 +2783,7 @@ static lean_object* _init_l_Lean_Lsp_instToJsonInitializeResult___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564_), 1, 0);
+x_1 = lean_alloc_closure((void*)(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566_), 1, 0);
 return x_1;
 }
 }
@@ -2795,7 +2795,7 @@ x_1 = l_Lean_Lsp_instToJsonInitializeResult___closed__1;
 return x_1;
 }
 }
-lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; 
@@ -2805,7 +2805,7 @@ lean_dec(x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2___closed__1() {
+static lean_object* _init_l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -2815,7 +2815,7 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
@@ -2823,13 +2823,13 @@ x_3 = l_Lean_Json_getObjValD(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 lean_object* x_4; 
-x_4 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2___closed__1;
+x_4 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2___closed__1;
 return x_4;
 }
 else
 {
 lean_object* x_5; 
-x_5 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_498_(x_3);
+x_5 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonServerInfo____x40_Lean_Data_Lsp_InitShutdown___hyg_500_(x_3);
 lean_dec(x_3);
 if (lean_obj_tag(x_5) == 0)
 {
@@ -2879,12 +2879,12 @@ return x_14;
 }
 }
 }
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593_(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
 x_2 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeParams____x40_Lean_Data_Lsp_InitShutdown___hyg_303____closed__6;
-x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__1(x_1, x_2);
+x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 uint8_t x_4; 
@@ -2910,8 +2910,8 @@ lean_object* x_7; lean_object* x_8; lean_object* x_9;
 x_7 = lean_ctor_get(x_3, 0);
 lean_inc(x_7);
 lean_dec(x_3);
-x_8 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____closed__1;
-x_9 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2(x_1, x_8);
+x_8 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____closed__1;
+x_9 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2(x_1, x_8);
 if (lean_obj_tag(x_9) == 0)
 {
 uint8_t x_10; 
@@ -2963,31 +2963,31 @@ return x_18;
 }
 }
 }
-lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__1(x_1, x_2);
+x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2(x_1, x_2);
+x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____boxed(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____boxed(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593_(x_1);
+x_2 = l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595_(x_1);
 lean_dec(x_1);
 return x_2;
 }
@@ -2996,7 +2996,7 @@ static lean_object* _init_l_Lean_Lsp_instFromJsonInitializeResult___closed__1()
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____boxed), 1, 0);
+x_1 = lean_alloc_closure((void*)(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____boxed), 1, 0);
 return x_1;
 }
 }
@@ -3142,14 +3142,14 @@ l_Lean_Lsp_instFromJsonServerInfo = _init_l_Lean_Lsp_instFromJsonServerInfo();
 lean_mark_persistent(l_Lean_Lsp_instFromJsonServerInfo);
 l_Lean_Lsp_InitializeResult_serverInfo_x3f___default = _init_l_Lean_Lsp_InitializeResult_serverInfo_x3f___default();
 lean_mark_persistent(l_Lean_Lsp_InitializeResult_serverInfo_x3f___default);
-l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____closed__1 = _init_l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____closed__1();
-lean_mark_persistent(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_564____closed__1);
+l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____closed__1 = _init_l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____closed__1();
+lean_mark_persistent(l___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_toJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_566____closed__1);
 l_Lean_Lsp_instToJsonInitializeResult___closed__1 = _init_l_Lean_Lsp_instToJsonInitializeResult___closed__1();
 lean_mark_persistent(l_Lean_Lsp_instToJsonInitializeResult___closed__1);
 l_Lean_Lsp_instToJsonInitializeResult = _init_l_Lean_Lsp_instToJsonInitializeResult();
 lean_mark_persistent(l_Lean_Lsp_instToJsonInitializeResult);
-l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2___closed__1 = _init_l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2___closed__1();
-lean_mark_persistent(l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_593____spec__2___closed__1);
+l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2___closed__1 = _init_l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2___closed__1();
+lean_mark_persistent(l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_InitShutdown_0__Lean_Lsp_fromJsonInitializeResult____x40_Lean_Data_Lsp_InitShutdown___hyg_595____spec__2___closed__1);
 l_Lean_Lsp_instFromJsonInitializeResult___closed__1 = _init_l_Lean_Lsp_instFromJsonInitializeResult___closed__1();
 lean_mark_persistent(l_Lean_Lsp_instFromJsonInitializeResult___closed__1);
 l_Lean_Lsp_instFromJsonInitializeResult = _init_l_Lean_Lsp_instFromJsonInitializeResult();

stage0/stdlib/Lean/Elab.c

@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Lean.Elab
-// Imports: Init Lean.Elab.Import Lean.Elab.Exception Lean.Elab.Command Lean.Elab.Term Lean.Elab.App Lean.Elab.Binders Lean.Elab.LetRec Lean.Elab.Frontend Lean.Elab.BuiltinNotation Lean.Elab.Declaration Lean.Elab.Tactic Lean.Elab.Match Lean.Elab.Quotation Lean.Elab.Syntax Lean.Elab.Do Lean.Elab.StructInst Lean.Elab.Inductive Lean.Elab.Structure Lean.Elab.Print Lean.Elab.MutualDef Lean.Elab.PreDefinition Lean.Elab.Deriving Lean.Elab.DeclarationRange Lean.Elab.Extra Lean.Elab.GenInjective
+// Imports: Init Lean.Elab.Import Lean.Elab.Exception Lean.Elab.Command Lean.Elab.Term Lean.Elab.App Lean.Elab.Binders Lean.Elab.LetRec Lean.Elab.Frontend Lean.Elab.BuiltinNotation Lean.Elab.Declaration Lean.Elab.Tactic Lean.Elab.Match Lean.Elab.Quotation Lean.Elab.Syntax Lean.Elab.Do Lean.Elab.StructInst Lean.Elab.Inductive Lean.Elab.Structure Lean.Elab.Print Lean.Elab.MutualDef Lean.Elab.PreDefinition Lean.Elab.Deriving Lean.Elab.DeclarationRange Lean.Elab.Extra Lean.Elab.GenInjective Lean.Elab.BuiltinTerm Lean.Elab.Arg Lean.Elab.PatternVar Lean.Elab.ElabRules Lean.Elab.Macro Lean.Elab.Notation Lean.Elab.Mixfix Lean.Elab.MacroRules
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -39,6 +39,14 @@ lean_object* initialize_Lean_Elab_Deriving(lean_object*);
 lean_object* initialize_Lean_Elab_DeclarationRange(lean_object*);
 lean_object* initialize_Lean_Elab_Extra(lean_object*);
 lean_object* initialize_Lean_Elab_GenInjective(lean_object*);
+lean_object* initialize_Lean_Elab_BuiltinTerm(lean_object*);
+lean_object* initialize_Lean_Elab_Arg(lean_object*);
+lean_object* initialize_Lean_Elab_PatternVar(lean_object*);
+lean_object* initialize_Lean_Elab_ElabRules(lean_object*);
+lean_object* initialize_Lean_Elab_Macro(lean_object*);
+lean_object* initialize_Lean_Elab_Notation(lean_object*);
+lean_object* initialize_Lean_Elab_Mixfix(lean_object*);
+lean_object* initialize_Lean_Elab_MacroRules(lean_object*);
 static bool _G_initialized = false;
 lean_object* initialize_Lean_Elab(lean_object* w) {
 lean_object * res;
@@ -122,6 +130,30 @@ lean_dec_ref(res);
 res = initialize_Lean_Elab_GenInjective(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Lean_Elab_BuiltinTerm(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Elab_Arg(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Elab_PatternVar(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Elab_ElabRules(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Elab_Macro(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Elab_Notation(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Elab_Mixfix(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Elab_MacroRules(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus

stage0/stdlib/Lean/Elab/BindersUtil.c

@@ -0,0 +1,67 @@
+// Lean compiler output
+// Module: Lean.Elab.BindersUtil
+// Imports: Init
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* l_Lean_Elab_Term_expandOptType(lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Term_expandOptType___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_mkHole(lean_object*);
+uint8_t l_Lean_Syntax_isNone(lean_object*);
+lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Term_expandOptType(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = l_Lean_Syntax_isNone(x_2);
+if (x_3 == 0)
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_4 = lean_unsigned_to_nat(0u);
+x_5 = l_Lean_Syntax_getArg(x_2, x_4);
+x_6 = lean_unsigned_to_nat(1u);
+x_7 = l_Lean_Syntax_getArg(x_5, x_6);
+lean_dec(x_5);
+return x_7;
+}
+else
+{
+lean_object* x_8; 
+x_8 = l_Lean_mkHole(x_1);
+return x_8;
+}
+}
+}
+lean_object* l_Lean_Elab_Term_expandOptType___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_Lean_Elab_Term_expandOptType(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+lean_object* initialize_Init(lean_object*);
+static bool _G_initialized = false;
+lean_object* initialize_Lean_Elab_BindersUtil(lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

stage0/stdlib/Lean/Elab/DefView.c

@@ -162,6 +162,7 @@ lean_object* l_Lean_Elab_liftMacroM___at_Lean_Elab_Command_MkInstanceName_main__
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Command_MkInstanceName_main___spec__4(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__24;
 static lean_object* l_Lean_Elab_Command_MkInstanceName_main___closed__1;
+static lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__4;
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__16;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Command_MkInstanceName_main___spec__4___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_instInhabitedDefView;
@@ -179,9 +180,9 @@ static lean_object* l_Lean_Elab_Command_mkDefViewOfInstance___closed__6;
 lean_object* l_Lean_Elab_DefKind_isDefOrAbbrevOrOpaque_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Command_mkDefViewOfInstance___spec__4(lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__2;
 uint8_t l_Lean_Elab_DefKind_isTheorem(uint8_t);
 lean_object* l_Lean_throwErrorAt___at_Lean_Elab_Command_MkInstanceName_main___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__1;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Command_mkDefViewOfInstance___spec__4___rarg(lean_object*);
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__36;
@@ -206,9 +207,8 @@ static lean_object* l_Lean_Elab_Command_mkDefViewOfConstant___closed__12;
 lean_object* l_Lean_throwErrorAt___at_Lean_Elab_Command_mkDefViewOfInstance___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_mkDefViewOfConstant_match__1(lean_object*);
 lean_object* l_Lean_Syntax_getKind(lean_object*);
-static lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__4;
 lean_object* l_Lean_Elab_Command_MkInstanceName_collect_match__2(lean_object*);
-lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253_(lean_object*);
+lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255_(lean_object*);
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__20;
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__10;
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__32;
@@ -232,8 +232,6 @@ lean_object* l_Lean_Elab_liftMacroM___at_Lean_Elab_Command_MkInstanceName_main__
 lean_object* l_Lean_Elab_Modifiers_addAttribute(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__25;
 static lean_object* l_Lean_Elab_Command_mkDefViewOfInstance___closed__9;
-lean_object* l_List_forM___at_Lean_Elab_Command_elabCommand___spec__7(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__3;
 lean_object* l_Lean_throwErrorAt___at_Lean_Elab_Command_mkDefViewOfInstance___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__29;
 lean_object* l_Lean_Elab_liftMacroM___at_Lean_Elab_Command_MkInstanceName_main___spec__1___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -243,6 +241,7 @@ lean_object* l_Lean_Elab_Command_mkDefViewOfTheorem_match__1___rarg(lean_object*
 lean_object* l_Lean_Elab_Command_MkInstanceName_collect_match__1(lean_object*);
 lean_object* l_Lean_Elab_Command_MkInstanceName_mkFreshInstanceName(lean_object*);
 static lean_object* l_Lean_Elab_Command_isDefLike___closed__3;
+lean_object* l_List_forM___at_Lean_Elab_Command_elabCommand___spec__5(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_unsupportedSyntaxExceptionId;
 static lean_object* l_Lean_Elab_Command_isDefLike___closed__5;
 lean_object* l_Lean_Elab_DefKind_isExample___boxed(lean_object*);
@@ -250,7 +249,6 @@ lean_object* l_Lean_Elab_toAttributeKind___boxed(lean_object*, lean_object*, lea
 static lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Command_MkInstanceName_main___spec__4___rarg___closed__1;
 lean_object* l_Lean_Elab_liftMacroM___at_Lean_Elab_Command_mkDefViewOfInstance___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__2;
 lean_object* l_Lean_Elab_DefKind_isTheorem_match__1___rarg(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_mkDefView(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Command_MkInstanceName_main___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -262,6 +260,7 @@ uint8_t l_List_isEmpty___rarg(lean_object*);
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__18;
 lean_object* l_Lean_Elab_Command_getScope___rarg(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__5;
+static lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__1;
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__3;
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__15;
 lean_object* l_Lean_Elab_Command_MkInstanceName_mkFreshInstanceName___boxed(lean_object*);
@@ -281,6 +280,7 @@ lean_object* l_Lean_Elab_Command_MkInstanceName_main(lean_object*, lean_object*,
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__22;
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__33;
 static lean_object* l___private_Lean_Elab_DefView_0__Lean_Elab_Command_MkInstanceName_kindReplacements___closed__14;
+static lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__3;
 lean_object* l_Lean_Elab_mkUnusedBaseName(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_getBetterRef(lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
@@ -4948,7 +4948,7 @@ x_54 = lean_ctor_get(x_45, 1);
 lean_inc(x_54);
 lean_dec(x_45);
 x_55 = l_List_reverse___rarg(x_54);
-x_56 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__7(x_55, x_2, x_3, x_53);
+x_56 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__5(x_55, x_2, x_3, x_53);
 lean_dec(x_2);
 x_57 = !lean_is_exclusive(x_56);
 if (x_57 == 0)
@@ -5009,7 +5009,7 @@ x_72 = lean_ctor_get(x_45, 1);
 lean_inc(x_72);
 lean_dec(x_45);
 x_73 = l_List_reverse___rarg(x_72);
-x_74 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__7(x_73, x_2, x_3, x_71);
+x_74 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__5(x_73, x_2, x_3, x_71);
 lean_dec(x_2);
 x_75 = lean_ctor_get(x_74, 1);
 lean_inc(x_75);
@@ -5268,7 +5268,7 @@ x_54 = lean_ctor_get(x_45, 1);
 lean_inc(x_54);
 lean_dec(x_45);
 x_55 = l_List_reverse___rarg(x_54);
-x_56 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__7(x_55, x_2, x_3, x_53);
+x_56 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__5(x_55, x_2, x_3, x_53);
 lean_dec(x_2);
 x_57 = !lean_is_exclusive(x_56);
 if (x_57 == 0)
@@ -5329,7 +5329,7 @@ x_72 = lean_ctor_get(x_45, 1);
 lean_inc(x_72);
 lean_dec(x_45);
 x_73 = l_List_reverse___rarg(x_72);
-x_74 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__7(x_73, x_2, x_3, x_71);
+x_74 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__5(x_73, x_2, x_3, x_71);
 lean_dec(x_2);
 x_75 = lean_ctor_get(x_74, 1);
 lean_inc(x_75);
@@ -6112,7 +6112,7 @@ x_54 = lean_ctor_get(x_45, 1);
 lean_inc(x_54);
 lean_dec(x_45);
 x_55 = l_List_reverse___rarg(x_54);
-x_56 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__7(x_55, x_2, x_3, x_53);
+x_56 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__5(x_55, x_2, x_3, x_53);
 lean_dec(x_2);
 x_57 = !lean_is_exclusive(x_56);
 if (x_57 == 0)
@@ -6173,7 +6173,7 @@ x_72 = lean_ctor_get(x_45, 1);
 lean_inc(x_72);
 lean_dec(x_45);
 x_73 = l_List_reverse___rarg(x_72);
-x_74 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__7(x_73, x_2, x_3, x_71);
+x_74 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__5(x_73, x_2, x_3, x_71);
 lean_dec(x_2);
 x_75 = lean_ctor_get(x_74, 1);
 lean_inc(x_75);
@@ -6486,7 +6486,7 @@ x_54 = lean_ctor_get(x_45, 1);
 lean_inc(x_54);
 lean_dec(x_45);
 x_55 = l_List_reverse___rarg(x_54);
-x_56 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__7(x_55, x_2, x_3, x_53);
+x_56 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__5(x_55, x_2, x_3, x_53);
 lean_dec(x_2);
 x_57 = !lean_is_exclusive(x_56);
 if (x_57 == 0)
@@ -6547,7 +6547,7 @@ x_72 = lean_ctor_get(x_45, 1);
 lean_inc(x_72);
 lean_dec(x_45);
 x_73 = l_List_reverse___rarg(x_72);
-x_74 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__7(x_73, x_2, x_3, x_71);
+x_74 = l_List_forM___at_Lean_Elab_Command_elabCommand___spec__5(x_73, x_2, x_3, x_71);
 lean_dec(x_2);
 x_75 = lean_ctor_get(x_74, 1);
 lean_inc(x_75);
@@ -7468,7 +7468,7 @@ lean_dec(x_4);
 return x_6;
 }
 }
-static lean_object* _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__1() {
+static lean_object* _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -7476,17 +7476,17 @@ x_1 = lean_mk_string("Elab");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__2() {
+static lean_object* _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__1;
+x_2 = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__3() {
+static lean_object* _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -7494,21 +7494,21 @@ x_1 = lean_mk_string("definition");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__4() {
+static lean_object* _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__2;
-x_2 = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__3;
+x_1 = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__2;
+x_2 = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__3;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__4;
+x_2 = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__4;
 x_3 = l_Lean_registerTraceClass(x_2, x_1);
 return x_3;
 }
@@ -7737,15 +7737,15 @@ l_Lean_Elab_Command_mkDefView___closed__1 = _init_l_Lean_Elab_Command_mkDefView_
 lean_mark_persistent(l_Lean_Elab_Command_mkDefView___closed__1);
 l_Lean_Elab_Command_mkDefView___closed__2 = _init_l_Lean_Elab_Command_mkDefView___closed__2();
 lean_mark_persistent(l_Lean_Elab_Command_mkDefView___closed__2);
-l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__1 = _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__1();
-lean_mark_persistent(l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__1);
-l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__2 = _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__2();
-lean_mark_persistent(l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__2);
-l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__3 = _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__3();
-lean_mark_persistent(l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__3);
-l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__4 = _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__4();
-lean_mark_persistent(l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253____closed__4);
-res = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1253_(lean_io_mk_world());
+l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__1 = _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__1();
+lean_mark_persistent(l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__1);
+l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__2 = _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__2();
+lean_mark_persistent(l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__2);
+l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__3 = _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__3();
+lean_mark_persistent(l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__3);
+l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__4 = _init_l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__4();
+lean_mark_persistent(l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255____closed__4);
+res = l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_1255_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Elab/Deriving/BEq.c

@@ -14,7 +14,6 @@
 extern "C" {
 #endif
 lean_object* l_Lean_getConstInfo___at_Lean_Elab_Term_mkConst___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2129____closed__1;
 static lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__4;
 uint8_t l_Lean_Expr_hasAnyFVar_visit___at_Lean_Expr_containsFVar___spec__1(lean_object*, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__4___closed__10;
@@ -27,6 +26,7 @@ lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_liftTermElabM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__9;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 uint8_t l_USize_decEq(size_t, size_t);
@@ -38,6 +38,7 @@ static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts
 lean_object* l_Lean_Elab_Deriving_BEq_mkBEqHeader___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__9;
 static lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__2;
+lean_object* l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___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_Elab_Deriving_BEq_mkMatch_mkElseAlt(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__1;
@@ -104,6 +105,7 @@ lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkAlts_match__1___rarg(lean_object
 static lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__5;
 static lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__3;
 static lean_object* l_Lean_Elab_Deriving_BEq_mkAuxFunction___lambda__1___closed__7;
+lean_object* l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_BEq_mkAuxFunction___lambda__1___closed__16;
 static lean_object* l_Lean_Elab_Deriving_BEq_mkMutualBlock___closed__12;
 lean_object* l_Lean_Elab_addMacroStack___at_Lean_Elab_Term_instAddErrorMessageContextTermElabM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -146,8 +148,7 @@ static lean_object* l_Lean_Elab_Deriving_BEq_mkMutualBlock___closed__8;
 lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkAlts(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__5___lambda__1___closed__5;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__4___closed__8;
-lean_object* l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2129_(lean_object*);
-lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(size_t, size_t, lean_object*);
+lean_object* l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2179_(lean_object*);
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__5___lambda__1___closed__3;
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMutualBlock___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*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___spec__1___closed__5;
@@ -161,6 +162,7 @@ static lean_object* l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq
 static lean_object* l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__16;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__4___closed__4;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(size_t, size_t, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__4___closed__3;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__5___lambda__1___closed__7;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__4___closed__5;
@@ -188,7 +190,6 @@ lean_object* l_Lean_getConstInfoCtor___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts_
 lean_object* l_Lean_Elab_Deriving_BEq_mkMutualBlock(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_BEq_mkMutualBlock___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_getConstInfoCtor___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__1___closed__1;
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallTelescopeReducing___at_Lean_Elab_Deriving_mkInductArgNames___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__5___lambda__1___closed__2;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__4___closed__12;
@@ -200,6 +201,7 @@ extern lean_object* l_Lean_instInhabitedInductiveVal;
 static lean_object* l_Lean_Elab_Deriving_BEq_mkAuxFunction___lambda__1___closed__28;
 static lean_object* l_Lean_Elab_Deriving_BEq_mkAuxFunction___lambda__1___closed__14;
 static lean_object* l_Lean_Elab_Deriving_BEq_mkAuxFunction___lambda__1___closed__5;
+static lean_object* l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2179____closed__1;
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Deriving_BEq_mkMatch_mkAlts___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
@@ -796,7 +798,7 @@ x_67 = lean_usize_of_nat(x_66);
 lean_dec(x_66);
 x_68 = 0;
 x_69 = x_41;
-x_70 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_67, x_68, x_69);
+x_70 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_67, x_68, x_69);
 x_71 = x_70;
 x_72 = l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__17;
 x_73 = l_Lean_mkSepArray(x_71, x_72);
@@ -839,7 +841,7 @@ x_90 = lean_usize_of_nat(x_89);
 lean_dec(x_89);
 x_91 = 0;
 x_92 = x_41;
-x_93 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_90, x_91, x_92);
+x_93 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_90, x_91, x_92);
 x_94 = x_93;
 x_95 = l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__17;
 x_96 = l_Lean_mkSepArray(x_94, x_95);
@@ -2247,7 +2249,7 @@ x_111 = lean_usize_of_nat(x_110);
 lean_dec(x_110);
 x_112 = 0;
 x_113 = x_99;
-x_114 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_111, x_112, x_113);
+x_114 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_111, x_112, x_113);
 x_115 = x_114;
 x_116 = l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__17;
 x_117 = l_Lean_mkSepArray(x_115, x_116);
@@ -2289,7 +2291,7 @@ x_133 = lean_usize_of_nat(x_132);
 lean_dec(x_132);
 x_134 = 0;
 x_135 = x_99;
-x_136 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_133, x_134, x_135);
+x_136 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_133, x_134, x_135);
 x_137 = x_136;
 x_138 = l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__17;
 x_139 = l_Lean_mkSepArray(x_137, x_138);
@@ -2507,7 +2509,7 @@ x_220 = lean_usize_of_nat(x_219);
 lean_dec(x_219);
 x_221 = 0;
 x_222 = x_208;
-x_223 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_220, x_221, x_222);
+x_223 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_220, x_221, x_222);
 x_224 = x_223;
 x_225 = l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__17;
 x_226 = l_Lean_mkSepArray(x_224, x_225);
@@ -3035,7 +3037,7 @@ x_28 = lean_usize_of_nat(x_27);
 lean_dec(x_27);
 x_29 = 0;
 x_30 = x_12;
-x_31 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_28, x_29, x_30);
+x_31 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_28, x_29, x_30);
 x_32 = x_31;
 x_33 = l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__17;
 x_34 = l_Lean_mkSepArray(x_32, x_33);
@@ -3093,7 +3095,7 @@ x_61 = lean_usize_of_nat(x_60);
 lean_dec(x_60);
 x_62 = 0;
 x_63 = x_12;
-x_64 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_61, x_62, x_63);
+x_64 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_61, x_62, x_63);
 x_65 = x_64;
 x_66 = l_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___closed__17;
 x_67 = l_Lean_mkSepArray(x_65, x_66);
@@ -4742,6 +4744,16 @@ return x_12;
 }
 }
 }
+lean_object* l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+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;
+}
+}
 static lean_object* _init_l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__1() {
 _start:
 {
@@ -4875,7 +4887,7 @@ x_21 = l_Lean_Elab_Deriving_mkInstanceCmds(x_14, x_19, x_1, x_20, x_2, x_3, x_4,
 lean_dec(x_14);
 if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; 
+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; uint8_t x_29; lean_object* x_30; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; 
 x_22 = lean_ctor_get(x_21, 0);
 lean_inc(x_22);
 x_23 = lean_ctor_get(x_21, 1);
@@ -4892,6 +4904,7 @@ x_25 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_BEq_mkMatch_mkElseAlt___sp
 x_26 = lean_array_push(x_25, x_17);
 x_27 = l_Array_append___rarg(x_26, x_22);
 lean_dec(x_22);
+x_28 = l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__6;
 x_45 = lean_st_ref_get(x_7, x_23);
 x_46 = lean_ctor_get(x_45, 0);
 lean_inc(x_46);
@@ -4907,34 +4920,33 @@ x_49 = lean_ctor_get(x_45, 1);
 lean_inc(x_49);
 lean_dec(x_45);
 x_50 = 0;
-x_28 = x_50;
-x_29 = x_49;
+x_29 = x_50;
+x_30 = x_49;
 goto block_44;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; 
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
 x_51 = lean_ctor_get(x_45, 1);
 lean_inc(x_51);
 lean_dec(x_45);
-x_52 = l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__6;
-x_53 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_52, x_2, x_3, x_4, x_5, x_6, x_7, x_51);
-x_54 = lean_ctor_get(x_53, 0);
+x_52 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_28, x_2, x_3, x_4, x_5, x_6, x_7, x_51);
+x_53 = lean_ctor_get(x_52, 0);
+lean_inc(x_53);
+x_54 = lean_ctor_get(x_52, 1);
 lean_inc(x_54);
-x_55 = lean_ctor_get(x_53, 1);
-lean_inc(x_55);
+lean_dec(x_52);
+x_55 = lean_unbox(x_53);
 lean_dec(x_53);
-x_56 = lean_unbox(x_54);
-lean_dec(x_54);
-x_28 = x_56;
 x_29 = x_55;
+x_30 = x_54;
 goto block_44;
 }
 block_44:
 {
-if (x_28 == 0)
+if (x_29 == 0)
 {
-lean_object* x_30; 
+lean_object* x_31; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -4942,33 +4954,32 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 if (lean_is_scalar(x_24)) {
- x_30 = lean_alloc_ctor(0, 2, 0);
+ x_31 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_30 = x_24;
+ x_31 = x_24;
 }
-lean_ctor_set(x_30, 0, x_27);
-lean_ctor_set(x_30, 1, x_29);
-return x_30;
+lean_ctor_set(x_31, 0, x_27);
+lean_ctor_set(x_31, 1, x_30);
+return x_31;
 }
 else
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; 
+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; uint8_t x_40; 
 lean_dec(x_24);
 lean_inc(x_27);
-x_31 = lean_array_to_list(lean_box(0), x_27);
-x_32 = l_List_map___at___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___spec__1(x_31);
-x_33 = l_Lean_MessageData_ofList(x_32);
-lean_dec(x_32);
-x_34 = l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__8;
-x_35 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_35, 0, x_34);
-lean_ctor_set(x_35, 1, x_33);
-x_36 = l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__10;
-x_37 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_36);
-x_38 = l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__6;
-x_39 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_38, x_37, x_2, x_3, x_4, x_5, x_6, x_7, x_29);
+x_32 = lean_array_to_list(lean_box(0), x_27);
+x_33 = l_List_map___at___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___spec__1(x_32);
+x_34 = l_Lean_MessageData_ofList(x_33);
+lean_dec(x_33);
+x_35 = l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__8;
+x_36 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_36, 0, x_35);
+lean_ctor_set(x_36, 1, x_34);
+x_37 = l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__10;
+x_38 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_37);
+x_39 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_28, x_38, x_2, x_3, x_4, x_5, x_6, x_7, x_30);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -5000,7 +5011,7 @@ return x_43;
 }
 else
 {
-uint8_t x_57; 
+uint8_t x_56; 
 lean_dec(x_17);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -5008,29 +5019,29 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_57 = !lean_is_exclusive(x_21);
-if (x_57 == 0)
+x_56 = !lean_is_exclusive(x_21);
+if (x_56 == 0)
 {
 return x_21;
 }
 else
 {
-lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_58 = lean_ctor_get(x_21, 0);
-x_59 = lean_ctor_get(x_21, 1);
-lean_inc(x_59);
+lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_57 = lean_ctor_get(x_21, 0);
+x_58 = lean_ctor_get(x_21, 1);
 lean_inc(x_58);
+lean_inc(x_57);
 lean_dec(x_21);
-x_60 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_60, 0, x_58);
-lean_ctor_set(x_60, 1, x_59);
-return x_60;
+x_59 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_59, 0, x_57);
+lean_ctor_set(x_59, 1, x_58);
+return x_59;
 }
 }
 }
 else
 {
-uint8_t x_61; 
+uint8_t x_60; 
 lean_dec(x_14);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -5038,56 +5049,71 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_61 = !lean_is_exclusive(x_16);
-if (x_61 == 0)
+x_60 = !lean_is_exclusive(x_16);
+if (x_60 == 0)
 {
 return x_16;
 }
 else
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_62 = lean_ctor_get(x_16, 0);
-x_63 = lean_ctor_get(x_16, 1);
-lean_inc(x_63);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_61 = lean_ctor_get(x_16, 0);
+x_62 = lean_ctor_get(x_16, 1);
 lean_inc(x_62);
+lean_inc(x_61);
 lean_dec(x_16);
-x_64 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_64, 0, x_62);
-lean_ctor_set(x_64, 1, x_63);
-return x_64;
+x_63 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_63, 0, x_61);
+lean_ctor_set(x_63, 1, x_62);
+return x_63;
 }
 }
 }
 else
 {
-uint8_t x_65; 
+uint8_t x_64; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_65 = !lean_is_exclusive(x_13);
-if (x_65 == 0)
+x_64 = !lean_is_exclusive(x_13);
+if (x_64 == 0)
 {
 return x_13;
 }
 else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-x_66 = lean_ctor_get(x_13, 0);
-x_67 = lean_ctor_get(x_13, 1);
-lean_inc(x_67);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_65 = lean_ctor_get(x_13, 0);
+x_66 = lean_ctor_get(x_13, 1);
 lean_inc(x_66);
+lean_inc(x_65);
 lean_dec(x_13);
-x_68 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_68, 0, x_66);
-lean_ctor_set(x_68, 1, x_67);
-return x_68;
+x_67 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_67, 0, x_65);
+lean_ctor_set(x_67, 1, x_66);
+return x_67;
 }
 }
 }
 }
+lean_object* l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_10;
+}
+}
 lean_object* l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
@@ -5417,8 +5443,7 @@ x_29 = 0;
 x_30 = lean_usize_of_nat(x_22);
 lean_dec(x_22);
 x_31 = lean_box(0);
-x_32 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_20, x_29, x_30, x_31, x_2, x_3, x_21);
-lean_dec(x_2);
+x_32 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_20, x_29, x_30, x_31, x_2, x_3, x_21);
 lean_dec(x_20);
 if (lean_obj_tag(x_32) == 0)
 {
@@ -5522,8 +5547,7 @@ x_56 = 0;
 x_57 = lean_usize_of_nat(x_47);
 lean_dec(x_47);
 x_58 = lean_box(0);
-x_59 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_45, x_56, x_57, x_58, x_2, x_3, x_46);
-lean_dec(x_2);
+x_59 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_45, x_56, x_57, x_58, x_2, x_3, x_46);
 lean_dec(x_45);
 if (lean_obj_tag(x_59) == 0)
 {
@@ -5631,7 +5655,7 @@ lean_dec(x_1);
 return x_9;
 }
 }
-static lean_object* _init_l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2129____closed__1() {
+static lean_object* _init_l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2179____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -5639,12 +5663,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Elab_Deriving_BEq_mkBEqInstanceHandler),
 return x_1;
 }
 }
-lean_object* l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2129_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2179_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = l_Lean_Elab_Deriving_BEq_mkBEqHeader___rarg___closed__2;
-x_3 = l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2129____closed__1;
+x_3 = l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2179____closed__1;
 x_4 = l_Lean_Elab_registerBuiltinDerivingHandler(x_2, x_3, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
@@ -5941,9 +5965,9 @@ l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds__
 lean_mark_persistent(l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__9);
 l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__10 = _init_l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__10();
 lean_mark_persistent(l___private_Lean_Elab_Deriving_BEq_0__Lean_Elab_Deriving_BEq_mkBEqInstanceCmds___closed__10);
-l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2129____closed__1 = _init_l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2129____closed__1();
-lean_mark_persistent(l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2129____closed__1);
-res = l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2129_(lean_io_mk_world());
+l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2179____closed__1 = _init_l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2179____closed__1();
+lean_mark_persistent(l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2179____closed__1);
+res = l_Lean_Elab_Deriving_BEq_initFn____x40_Lean_Elab_Deriving_BEq___hyg_2179_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Elab/Deriving/Basic.c

@@ -57,7 +57,6 @@ static lean_object* l_Lean_Elab_elabDeriving___closed__7;
 static lean_object* l_Lean_Elab_defaultHandler___closed__6;
 lean_object* l_Lean_resolveGlobalConst___at_Lean_Elab_elabDeriving___spec__3___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_elabDeriving___spec__8(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Elab_Command_elabCommand___spec__13(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_LocalContext_empty;
 static lean_object* l_Lean_Elab_elabDeriving___closed__3;
 lean_object* l_Lean_ConstantInfo_levelParams(lean_object*);
@@ -67,7 +66,7 @@ lean_object* l_List_map___at_Lean_resolveGlobalConstNoOverload___spec__1(lean_ob
 lean_object* l_Lean_Elab_applyDerivingHandlers(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_elabDeriving___closed__2;
-lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603_(lean_object*);
+lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604_(lean_object*);
 lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_11_(lean_object*);
 lean_object* l_Lean_Elab_registerBuiltinDerivingHandler___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_elabDeriving___spec__9(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -78,6 +77,7 @@ lean_object* l_Lean_replaceRef(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_registerBuiltinDerivingHandler___lambda__2___closed__2;
 lean_object* l_Lean_Elab_registerBuiltinDerivingHandler___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_defaultHandler___closed__2;
+lean_object* l_Lean_throwError___at_Lean_Elab_Command_elabCommand___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_elabDeriving___closed__1;
 uint8_t l_Lean_Name_quickCmp(lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_getOptDerivingClasses___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*);
@@ -104,19 +104,19 @@ lean_object* l_Lean_ResolveName_resolveGlobalName(lean_object*, lean_object*, le
 static lean_object* l_Lean_resolveGlobalConstNoOverload___at_Lean_Elab_elabDeriving___spec__2___closed__2;
 static lean_object* l_Lean_resolveGlobalConstNoOverload___at_Lean_Elab_elabDeriving___spec__2___closed__1;
 size_t lean_usize_of_nat(lean_object*);
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__3;
 lean_object* l_Lean_resolveGlobalName___at_Lean_Elab_elabDeriving___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_DerivingClassView_applyHandlers(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__3;
 lean_object* l_Std_RBNode_find___at_Lean_Elab_applyDerivingHandlers___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_elabDeriving___lambda__1(lean_object*);
 lean_object* l_Lean_Elab_registerBuiltinDerivingHandler___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Command_elabNamespace___spec__1___rarg(lean_object*);
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__1;
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__1;
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_getOptDerivingClasses___spec__1___rarg___lambda__2(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*);
 lean_object* l_Lean_Syntax_getSepArgs(lean_object*);
-lean_object* l_Array_sequenceMap___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__1(lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__2;
 lean_object* l_Lean_throwError___at_Lean_Elab_elabDeriving___spec__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__2;
+lean_object* l_Array_sequenceMap___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_logException___at_Lean_Elab_Command_runLinters___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_addMacroStack___at_Lean_Elab_Command_instAddErrorMessageContextCommandElabM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_throwUnknownConstant___at_Lean_Elab_elabDeriving___spec__5___closed__3;
@@ -863,7 +863,7 @@ x_10 = l_Lean_throwUnknownConstant___at_Lean_Elab_elabDeriving___spec__5___close
 x_11 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_11, 0, x_9);
 lean_ctor_set(x_11, 1, x_10);
-x_12 = l_Lean_throwError___at_Lean_Elab_Command_elabCommand___spec__13(x_11, x_2, x_3, x_4);
+x_12 = l_Lean_throwError___at_Lean_Elab_Command_elabCommand___spec__1(x_11, x_2, x_3, x_4);
 return x_12;
 }
 }
@@ -1804,7 +1804,7 @@ block_78:
 {
 lean_object* x_15; lean_object* x_16; 
 x_15 = l_Lean_Elab_elabDeriving___closed__11;
-x_16 = l_Array_sequenceMap___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__1(x_14, x_15);
+x_16 = l_Array_sequenceMap___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__1(x_14, x_15);
 lean_dec(x_14);
 if (lean_obj_tag(x_16) == 0)
 {
@@ -1869,7 +1869,7 @@ goto block_64;
 block_64:
 {
 lean_object* x_20; 
-x_20 = l_Array_sequenceMap___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__1(x_19, x_15);
+x_20 = l_Array_sequenceMap___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__1(x_19, x_15);
 lean_dec(x_19);
 if (lean_obj_tag(x_20) == 0)
 {
@@ -2459,7 +2459,7 @@ return x_22;
 }
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__1() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -2469,7 +2469,7 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__2() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -2477,21 +2477,21 @@ x_1 = lean_mk_string("Deriving");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__3() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__1;
-x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__2;
+x_1 = l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__1;
+x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__2;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603_(lean_object* x_1) {
+lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__3;
+x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__3;
 x_3 = l_Lean_registerTraceClass(x_2, x_1);
 return x_3;
 }
@@ -2581,13 +2581,13 @@ lean_mark_persistent(l___regBuiltin_Lean_Elab_elabDeriving___closed__5);
 res = l___regBuiltin_Lean_Elab_elabDeriving(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__1();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__1);
-l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__2 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__2();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__2);
-l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__3 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__3();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603____closed__3);
-res = l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_603_(lean_io_mk_world());
+l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__1();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__1);
+l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__2 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__2();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__2);
+l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__3 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__3();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604____closed__3);
+res = l_Lean_Elab_initFn____x40_Lean_Elab_Deriving_Basic___hyg_604_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Elab/Deriving/FromToJson.c

@@ -37,6 +37,7 @@ lean_object* l_Lean_throwError___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstan
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__39;
 lean_object* l_Lean_Elab_Command_liftTermElabM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___spec__5(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__19;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__1___closed__13;
@@ -148,6 +149,7 @@ lean_object* l_Lean_getConstInfoInduct___at_Lean_Elab_Deriving_FromToJson_mkToJs
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__3___closed__9;
 uint8_t l_Lean_Name_hasMacroScopes(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Deriving_FromToJson_0__Lean_Elab_Deriving_FromToJson_parseTagged___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*);
+static lean_object* l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__2;
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__2___closed__3;
 lean_object* l_Lean_Elab_Deriving_FromToJson_mkJsonField___lambda__1___boxed(lean_object*);
 static lean_object* l_Lean_getConstInfoInduct___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___spec__1___closed__2;
@@ -174,6 +176,7 @@ lean_object* lean_array_swap(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__2___closed__23;
 lean_object* l_Lean_getStructureFieldsFlattened(lean_object*, lean_object*, uint8_t);
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___spec__5___closed__6;
+static lean_object* l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__1;
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__8;
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__1;
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__2___closed__29;
@@ -194,13 +197,11 @@ static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mk
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__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*);
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__2___closed__18;
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__1___closed__7;
-static lean_object* l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__2;
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts___spec__5___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___private_Lean_Elab_Deriving_FromToJson_0__Lean_Elab_Deriving_FromToJson_parseTagged_match__2___rarg(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__11;
 lean_object* l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__44;
-static lean_object* l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__1;
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__2___closed__2;
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__2___closed__1;
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__8;
@@ -215,7 +216,7 @@ static lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___la
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__1___closed__5;
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__17;
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__4;
-lean_object* l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403_(lean_object*);
+lean_object* l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413_(lean_object*);
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__2___closed__8;
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__1___closed__7;
 lean_object* l_Lean_Elab_addMacroStack___at_Lean_Elab_Term_instAddErrorMessageContextTermElabM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -303,7 +304,6 @@ static lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___la
 lean_object* l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts___boxed__const__1;
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
 static lean_object* l___private_Lean_Elab_Deriving_FromToJson_0__Lean_Elab_Deriving_FromToJson_parseTagged___closed__2;
-lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(size_t, size_t, lean_object*);
 lean_object* l_Lean_Name_getString_x21(lean_object*);
 lean_object* l_String_intercalate(lean_object*, lean_object*);
 static lean_object* l_Array_mapIdxM_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___spec__4___closed__4;
@@ -323,6 +323,7 @@ lean_object* l_Lean_Elab_addMacroStack___at_Lean_Elab_Command_instAddErrorMessag
 static lean_object* l___private_Lean_Elab_Deriving_FromToJson_0__Lean_Elab_Deriving_FromToJson_parseTagged___closed__1;
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___spec__3___closed__4;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(size_t, size_t, lean_object*);
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__10;
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts___spec__5___lambda__2___closed__1;
 lean_object* l_Lean_throwError___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -387,7 +388,6 @@ static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mk
 lean_object* l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts_match__3(lean_object*);
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__5;
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__1___closed__19;
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___spec__3___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*);
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__41;
@@ -2341,7 +2341,7 @@ x_77 = lean_usize_of_nat(x_76);
 lean_dec(x_76);
 x_78 = 0;
 x_79 = x_61;
-x_80 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_77, x_78, x_79);
+x_80 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_77, x_78, x_79);
 x_81 = x_80;
 x_82 = l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__14;
 x_83 = l_Lean_mkSepArray(x_81, x_82);
@@ -2383,7 +2383,7 @@ x_99 = lean_usize_of_nat(x_98);
 lean_dec(x_98);
 x_100 = 0;
 x_101 = x_61;
-x_102 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_99, x_100, x_101);
+x_102 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_99, x_100, x_101);
 x_103 = x_102;
 x_104 = l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__14;
 x_105 = l_Lean_mkSepArray(x_103, x_104);
@@ -4008,7 +4008,7 @@ x_79 = lean_array_get_size(x_26);
 x_80 = lean_usize_of_nat(x_79);
 lean_dec(x_79);
 x_81 = x_26;
-x_82 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_80, x_19, x_81);
+x_82 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_80, x_19, x_81);
 x_83 = x_82;
 x_84 = l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__14;
 x_85 = l_Lean_mkSepArray(x_83, x_84);
@@ -4187,7 +4187,7 @@ x_177 = lean_array_get_size(x_26);
 x_178 = lean_usize_of_nat(x_177);
 lean_dec(x_177);
 x_179 = x_26;
-x_180 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_178, x_19, x_179);
+x_180 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_178, x_19, x_179);
 x_181 = x_180;
 x_182 = l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__14;
 x_183 = l_Lean_mkSepArray(x_181, x_182);
@@ -4406,7 +4406,7 @@ x_283 = lean_usize_of_nat(x_282);
 lean_dec(x_282);
 x_284 = 0;
 x_285 = x_239;
-x_286 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_283, x_284, x_285);
+x_286 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_283, x_284, x_285);
 x_287 = x_286;
 x_288 = l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__14;
 x_289 = l_Lean_mkSepArray(x_287, x_288);
@@ -4561,7 +4561,7 @@ x_369 = lean_usize_of_nat(x_368);
 lean_dec(x_368);
 x_370 = 0;
 x_371 = x_239;
-x_372 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_369, x_370, x_371);
+x_372 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_369, x_370, x_371);
 x_373 = x_372;
 x_374 = l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__14;
 x_375 = l_Lean_mkSepArray(x_373, x_374);
@@ -5473,7 +5473,7 @@ x_41 = lean_usize_of_nat(x_40);
 lean_dec(x_40);
 x_42 = 0;
 x_43 = x_25;
-x_44 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_41, x_42, x_43);
+x_44 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_41, x_42, x_43);
 x_45 = x_44;
 x_46 = l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__14;
 x_47 = l_Lean_mkSepArray(x_45, x_46);
@@ -6473,8 +6473,7 @@ x_35 = 0;
 x_36 = lean_usize_of_nat(x_28);
 lean_dec(x_28);
 x_37 = lean_box(0);
-x_38 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_26, x_35, x_36, x_37, x_2, x_3, x_27);
-lean_dec(x_2);
+x_38 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_26, x_35, x_36, x_37, x_2, x_3, x_27);
 lean_dec(x_26);
 if (lean_obj_tag(x_38) == 0)
 {
@@ -6578,8 +6577,7 @@ x_62 = 0;
 x_63 = lean_usize_of_nat(x_53);
 lean_dec(x_53);
 x_64 = lean_box(0);
-x_65 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_51, x_62, x_63, x_64, x_2, x_3, x_52);
-lean_dec(x_2);
+x_65 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_51, x_62, x_63, x_64, x_2, x_3, x_52);
 lean_dec(x_51);
 if (lean_obj_tag(x_65) == 0)
 {
@@ -6741,8 +6739,7 @@ x_96 = 0;
 x_97 = lean_usize_of_nat(x_89);
 lean_dec(x_89);
 x_98 = lean_box(0);
-x_99 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_87, x_96, x_97, x_98, x_2, x_3, x_88);
-lean_dec(x_2);
+x_99 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_87, x_96, x_97, x_98, x_2, x_3, x_88);
 lean_dec(x_87);
 if (lean_obj_tag(x_99) == 0)
 {
@@ -6846,8 +6843,7 @@ x_123 = 0;
 x_124 = lean_usize_of_nat(x_114);
 lean_dec(x_114);
 x_125 = lean_box(0);
-x_126 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_112, x_123, x_124, x_125, x_2, x_3, x_113);
-lean_dec(x_2);
+x_126 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_112, x_123, x_124, x_125, x_2, x_3, x_113);
 lean_dec(x_112);
 if (lean_obj_tag(x_126) == 0)
 {
@@ -9326,7 +9322,7 @@ x_69 = lean_array_get_size(x_68);
 x_70 = lean_usize_of_nat(x_69);
 lean_dec(x_69);
 x_71 = x_68;
-x_72 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_70, x_64, x_71);
+x_72 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_70, x_64, x_71);
 x_73 = x_72;
 x_74 = l_Array_mapMUnsafe_map___at_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler_mkAlts___spec__5___lambda__1___closed__14;
 x_75 = l_Lean_mkSepArray(x_73, x_74);
@@ -12233,8 +12229,7 @@ x_35 = 0;
 x_36 = lean_usize_of_nat(x_28);
 lean_dec(x_28);
 x_37 = lean_box(0);
-x_38 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_26, x_35, x_36, x_37, x_2, x_3, x_27);
-lean_dec(x_2);
+x_38 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_26, x_35, x_36, x_37, x_2, x_3, x_27);
 lean_dec(x_26);
 if (lean_obj_tag(x_38) == 0)
 {
@@ -12338,8 +12333,7 @@ x_62 = 0;
 x_63 = lean_usize_of_nat(x_53);
 lean_dec(x_53);
 x_64 = lean_box(0);
-x_65 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_51, x_62, x_63, x_64, x_2, x_3, x_52);
-lean_dec(x_2);
+x_65 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_51, x_62, x_63, x_64, x_2, x_3, x_52);
 lean_dec(x_51);
 if (lean_obj_tag(x_65) == 0)
 {
@@ -12501,8 +12495,7 @@ x_96 = 0;
 x_97 = lean_usize_of_nat(x_89);
 lean_dec(x_89);
 x_98 = lean_box(0);
-x_99 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_87, x_96, x_97, x_98, x_2, x_3, x_88);
-lean_dec(x_2);
+x_99 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_87, x_96, x_97, x_98, x_2, x_3, x_88);
 lean_dec(x_87);
 if (lean_obj_tag(x_99) == 0)
 {
@@ -12606,8 +12599,7 @@ x_123 = 0;
 x_124 = lean_usize_of_nat(x_114);
 lean_dec(x_114);
 x_125 = lean_box(0);
-x_126 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_112, x_123, x_124, x_125, x_2, x_3, x_113);
-lean_dec(x_2);
+x_126 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_112, x_123, x_124, x_125, x_2, x_3, x_113);
 lean_dec(x_112);
 if (lean_obj_tag(x_126) == 0)
 {
@@ -12762,7 +12754,7 @@ lean_dec(x_2);
 return x_10;
 }
 }
-static lean_object* _init_l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__1() {
+static lean_object* _init_l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -12770,7 +12762,7 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanc
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__2() {
+static lean_object* _init_l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -12778,12 +12770,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Elab_Deriving_FromToJson_mkFromJsonInsta
 return x_1;
 }
 }
-lean_object* l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = l_Lean_Elab_Deriving_FromToJson_mkToJsonInstanceHandler___lambda__2___closed__2;
-x_3 = l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__1;
+x_3 = l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__1;
 x_4 = l_Lean_Elab_registerBuiltinDerivingHandler(x_2, x_3, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
@@ -12792,7 +12784,7 @@ x_5 = lean_ctor_get(x_4, 1);
 lean_inc(x_5);
 lean_dec(x_4);
 x_6 = l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__1___closed__2;
-x_7 = l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__2;
+x_7 = l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__2;
 x_8 = l_Lean_Elab_registerBuiltinDerivingHandler(x_6, x_7, x_5);
 return x_8;
 }
@@ -13373,11 +13365,11 @@ l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__2___closed__
 lean_mark_persistent(l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__2___closed__13);
 l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__2___closed__14 = _init_l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__2___closed__14();
 lean_mark_persistent(l_Lean_Elab_Deriving_FromToJson_mkFromJsonInstanceHandler___lambda__2___closed__14);
-l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__1 = _init_l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__1();
-lean_mark_persistent(l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__1);
-l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__2 = _init_l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__2();
-lean_mark_persistent(l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403____closed__2);
-res = l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4403_(lean_io_mk_world());
+l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__1 = _init_l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__1();
+lean_mark_persistent(l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__1);
+l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__2 = _init_l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__2();
+lean_mark_persistent(l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413____closed__2);
+res = l_Lean_Elab_Deriving_FromToJson_initFn____x40_Lean_Elab_Deriving_FromToJson___hyg_4413_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Elab/Deriving/Hashable.c

@@ -17,13 +17,13 @@ lean_object* l_Lean_getConstInfo___at_Lean_Elab_Term_mkConst___spec__1(lean_obje
 lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__5___lambda__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*);
 size_t l_USize_add(size_t, size_t);
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1587____closed__1;
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_Elab_Deriving_Hashable_mkHashableHandler(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__10;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__5___lambda__1___closed__9;
 lean_object* l_Lean_Elab_Command_liftTermElabM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4___closed__24;
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__24;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
@@ -73,6 +73,7 @@ static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_m
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__18;
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__5;
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__5;
 lean_object* l_Lean_Elab_Deriving_Hashable_mkHashFuncs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -98,6 +99,7 @@ static lean_object* l_Lean_Elab_Deriving_Hashable_mkMatch___closed__2;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4___closed__13;
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__29;
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1635____closed__1;
 static lean_object* l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__7;
 lean_object* l_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts_match__2(lean_object*);
 lean_object* l_Lean_Elab_Deriving_Hashable_mkMatch___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -134,6 +136,7 @@ lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkA
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__9;
 lean_object* l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkMatch___closed__4;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4___closed__5;
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__17;
@@ -146,7 +149,6 @@ lean_object* l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hasha
 lean_object* l_Lean_getConstInfoCtor___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___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*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4___closed__4;
-lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(size_t, size_t, lean_object*);
 lean_object* l_List_redLength___rarg(lean_object*);
 static lean_object* l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__2;
 lean_object* l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -160,12 +162,13 @@ uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_Hashable_mkHashableHeader(lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4___closed__19;
 lean_object* l_Lean_getConstInfoCtor___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(size_t, size_t, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__3___closed__6;
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__11;
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__7;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__3___closed__1;
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkAuxFunction___closed__3;
-lean_object* l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1587_(lean_object*);
+lean_object* l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1635_(lean_object*);
 static lean_object* l_Lean_getConstInfoCtor___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__1___closed__2;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__5___lambda__1___closed__10;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4___closed__2;
@@ -181,7 +184,6 @@ lean_object* l_Lean_Meta_inferType(lean_object*, lean_object*, lean_object*, lea
 lean_object* l_Lean_Elab_registerBuiltinDerivingHandler(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkHashFuncs___closed__1;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__4___closed__17;
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallTelescopeReducing___at_Lean_Elab_Deriving_mkInductArgNames___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__3___closed__2;
 static lean_object* l_Lean_Elab_Deriving_Hashable_mkHashFuncs___closed__2;
@@ -1539,7 +1541,7 @@ x_85 = lean_usize_of_nat(x_84);
 lean_dec(x_84);
 x_86 = 0;
 x_87 = x_73;
-x_88 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_85, x_86, x_87);
+x_88 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_85, x_86, x_87);
 x_89 = x_88;
 x_90 = l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__5___lambda__1___closed__10;
 x_91 = l_Lean_mkSepArray(x_89, x_90);
@@ -1581,7 +1583,7 @@ x_107 = lean_usize_of_nat(x_106);
 lean_dec(x_106);
 x_108 = 0;
 x_109 = x_73;
-x_110 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_107, x_108, x_109);
+x_110 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_107, x_108, x_109);
 x_111 = x_110;
 x_112 = l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__5___lambda__1___closed__10;
 x_113 = l_Lean_mkSepArray(x_111, x_112);
@@ -2142,7 +2144,7 @@ x_29 = lean_usize_of_nat(x_28);
 lean_dec(x_28);
 x_30 = 0;
 x_31 = x_13;
-x_32 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_29, x_30, x_31);
+x_32 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_29, x_30, x_31);
 x_33 = x_32;
 x_34 = l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__5___lambda__1___closed__10;
 x_35 = l_Lean_mkSepArray(x_33, x_34);
@@ -2200,7 +2202,7 @@ x_62 = lean_usize_of_nat(x_61);
 lean_dec(x_61);
 x_63 = 0;
 x_64 = x_13;
-x_65 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_62, x_63, x_64);
+x_65 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_62, x_63, x_64);
 x_66 = x_65;
 x_67 = l_List_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___spec__5___lambda__1___closed__10;
 x_68 = l_Lean_mkSepArray(x_66, x_67);
@@ -3598,6 +3600,16 @@ return x_12;
 }
 }
 }
+lean_object* l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+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;
+}
+}
 static lean_object* _init_l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__1() {
 _start:
 {
@@ -3732,7 +3744,7 @@ x_21 = l_Lean_Elab_Deriving_mkInstanceCmds(x_14, x_19, x_1, x_20, x_2, x_3, x_4,
 lean_dec(x_14);
 if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; 
+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; uint8_t x_29; lean_object* x_30; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; 
 x_22 = lean_ctor_get(x_21, 0);
 lean_inc(x_22);
 x_23 = lean_ctor_get(x_21, 1);
@@ -3749,6 +3761,7 @@ x_25 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Hashable_mkMatch_mkAlts___
 x_26 = lean_array_push(x_25, x_17);
 x_27 = l_Array_append___rarg(x_26, x_22);
 lean_dec(x_22);
+x_28 = l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__6;
 x_45 = lean_st_ref_get(x_7, x_23);
 x_46 = lean_ctor_get(x_45, 0);
 lean_inc(x_46);
@@ -3764,34 +3777,33 @@ x_49 = lean_ctor_get(x_45, 1);
 lean_inc(x_49);
 lean_dec(x_45);
 x_50 = 0;
-x_28 = x_50;
-x_29 = x_49;
+x_29 = x_50;
+x_30 = x_49;
 goto block_44;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; 
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
 x_51 = lean_ctor_get(x_45, 1);
 lean_inc(x_51);
 lean_dec(x_45);
-x_52 = l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__6;
-x_53 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_52, x_2, x_3, x_4, x_5, x_6, x_7, x_51);
-x_54 = lean_ctor_get(x_53, 0);
+x_52 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_28, x_2, x_3, x_4, x_5, x_6, x_7, x_51);
+x_53 = lean_ctor_get(x_52, 0);
+lean_inc(x_53);
+x_54 = lean_ctor_get(x_52, 1);
 lean_inc(x_54);
-x_55 = lean_ctor_get(x_53, 1);
-lean_inc(x_55);
+lean_dec(x_52);
+x_55 = lean_unbox(x_53);
 lean_dec(x_53);
-x_56 = lean_unbox(x_54);
-lean_dec(x_54);
-x_28 = x_56;
 x_29 = x_55;
+x_30 = x_54;
 goto block_44;
 }
 block_44:
 {
-if (x_28 == 0)
+if (x_29 == 0)
 {
-lean_object* x_30; 
+lean_object* x_31; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3799,33 +3811,32 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 if (lean_is_scalar(x_24)) {
- x_30 = lean_alloc_ctor(0, 2, 0);
+ x_31 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_30 = x_24;
+ x_31 = x_24;
 }
-lean_ctor_set(x_30, 0, x_27);
-lean_ctor_set(x_30, 1, x_29);
-return x_30;
+lean_ctor_set(x_31, 0, x_27);
+lean_ctor_set(x_31, 1, x_30);
+return x_31;
 }
 else
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; 
+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; uint8_t x_40; 
 lean_dec(x_24);
 lean_inc(x_27);
-x_31 = lean_array_to_list(lean_box(0), x_27);
-x_32 = l_List_map___at___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___spec__1(x_31);
-x_33 = l_Lean_MessageData_ofList(x_32);
-lean_dec(x_32);
-x_34 = l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__8;
-x_35 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_35, 0, x_34);
-lean_ctor_set(x_35, 1, x_33);
-x_36 = l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__10;
-x_37 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_36);
-x_38 = l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__6;
-x_39 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_38, x_37, x_2, x_3, x_4, x_5, x_6, x_7, x_29);
+x_32 = lean_array_to_list(lean_box(0), x_27);
+x_33 = l_List_map___at___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___spec__1(x_32);
+x_34 = l_Lean_MessageData_ofList(x_33);
+lean_dec(x_33);
+x_35 = l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__8;
+x_36 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_36, 0, x_35);
+lean_ctor_set(x_36, 1, x_34);
+x_37 = l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__10;
+x_38 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_37);
+x_39 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_28, x_38, x_2, x_3, x_4, x_5, x_6, x_7, x_30);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -3857,7 +3868,7 @@ return x_43;
 }
 else
 {
-uint8_t x_57; 
+uint8_t x_56; 
 lean_dec(x_17);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -3865,29 +3876,29 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_57 = !lean_is_exclusive(x_21);
-if (x_57 == 0)
+x_56 = !lean_is_exclusive(x_21);
+if (x_56 == 0)
 {
 return x_21;
 }
 else
 {
-lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_58 = lean_ctor_get(x_21, 0);
-x_59 = lean_ctor_get(x_21, 1);
-lean_inc(x_59);
+lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_57 = lean_ctor_get(x_21, 0);
+x_58 = lean_ctor_get(x_21, 1);
 lean_inc(x_58);
+lean_inc(x_57);
 lean_dec(x_21);
-x_60 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_60, 0, x_58);
-lean_ctor_set(x_60, 1, x_59);
-return x_60;
+x_59 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_59, 0, x_57);
+lean_ctor_set(x_59, 1, x_58);
+return x_59;
 }
 }
 }
 else
 {
-uint8_t x_61; 
+uint8_t x_60; 
 lean_dec(x_14);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -3895,56 +3906,71 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_61 = !lean_is_exclusive(x_16);
-if (x_61 == 0)
+x_60 = !lean_is_exclusive(x_16);
+if (x_60 == 0)
 {
 return x_16;
 }
 else
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_62 = lean_ctor_get(x_16, 0);
-x_63 = lean_ctor_get(x_16, 1);
-lean_inc(x_63);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_61 = lean_ctor_get(x_16, 0);
+x_62 = lean_ctor_get(x_16, 1);
 lean_inc(x_62);
+lean_inc(x_61);
 lean_dec(x_16);
-x_64 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_64, 0, x_62);
-lean_ctor_set(x_64, 1, x_63);
-return x_64;
+x_63 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_63, 0, x_61);
+lean_ctor_set(x_63, 1, x_62);
+return x_63;
 }
 }
 }
 else
 {
-uint8_t x_65; 
+uint8_t x_64; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_65 = !lean_is_exclusive(x_13);
-if (x_65 == 0)
+x_64 = !lean_is_exclusive(x_13);
+if (x_64 == 0)
 {
 return x_13;
 }
 else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-x_66 = lean_ctor_get(x_13, 0);
-x_67 = lean_ctor_get(x_13, 1);
-lean_inc(x_67);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_65 = lean_ctor_get(x_13, 0);
+x_66 = lean_ctor_get(x_13, 1);
 lean_inc(x_66);
+lean_inc(x_65);
 lean_dec(x_13);
-x_68 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_68, 0, x_66);
-lean_ctor_set(x_68, 1, x_67);
-return x_68;
+x_67 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_67, 0, x_65);
+lean_ctor_set(x_67, 1, x_66);
+return x_67;
 }
 }
 }
 }
+lean_object* l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_10;
+}
+}
 lean_object* l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
@@ -4274,8 +4300,7 @@ x_29 = 0;
 x_30 = lean_usize_of_nat(x_22);
 lean_dec(x_22);
 x_31 = lean_box(0);
-x_32 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_20, x_29, x_30, x_31, x_2, x_3, x_21);
-lean_dec(x_2);
+x_32 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_20, x_29, x_30, x_31, x_2, x_3, x_21);
 lean_dec(x_20);
 if (lean_obj_tag(x_32) == 0)
 {
@@ -4379,8 +4404,7 @@ x_56 = 0;
 x_57 = lean_usize_of_nat(x_47);
 lean_dec(x_47);
 x_58 = lean_box(0);
-x_59 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_45, x_56, x_57, x_58, x_2, x_3, x_46);
-lean_dec(x_2);
+x_59 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_45, x_56, x_57, x_58, x_2, x_3, x_46);
 lean_dec(x_45);
 if (lean_obj_tag(x_59) == 0)
 {
@@ -4488,7 +4512,7 @@ lean_dec(x_1);
 return x_9;
 }
 }
-static lean_object* _init_l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1587____closed__1() {
+static lean_object* _init_l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1635____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -4496,12 +4520,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Elab_Deriving_Hashable_mkHashableHandler
 return x_1;
 }
 }
-lean_object* l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1587_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1635_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = l_Lean_Elab_Deriving_Hashable_mkHashableHeader___rarg___closed__2;
-x_3 = l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1587____closed__1;
+x_3 = l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1635____closed__1;
 x_4 = l_Lean_Elab_registerBuiltinDerivingHandler(x_2, x_3, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
@@ -4768,9 +4792,9 @@ l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashabl
 lean_mark_persistent(l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__9);
 l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__10 = _init_l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__10();
 lean_mark_persistent(l___private_Lean_Elab_Deriving_Hashable_0__Lean_Elab_Deriving_Hashable_mkHashableInstanceCmds___closed__10);
-l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1587____closed__1 = _init_l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1587____closed__1();
-lean_mark_persistent(l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1587____closed__1);
-res = l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1587_(lean_io_mk_world());
+l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1635____closed__1 = _init_l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1635____closed__1();
+lean_mark_persistent(l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1635____closed__1);
+res = l_Lean_Elab_Deriving_Hashable_initFn____x40_Lean_Elab_Deriving_Hashable___hyg_1635_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Elab/Deriving/Ord.c

@@ -32,6 +32,7 @@ lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__3___closed__3;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__5___closed__31;
 lean_object* l_Lean_Elab_Command_liftTermElabM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
@@ -66,7 +67,6 @@ static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_m
 static lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___lambda__1___closed__20;
 static lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___lambda__1___closed__21;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__5___closed__29;
-static lean_object* l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2185____closed__1;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__3___closed__5;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__6___lambda__1___closed__17;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__6___lambda__1___closed__8;
@@ -76,6 +76,7 @@ lean_object* l_Lean_Elab_Term_getMainModule___rarg(lean_object*, lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Lean_Elab_Deriving_Ord_mkOrdInstanceHandler___spec__2(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_Ord_mkMutualBlock___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_mkLocalInstanceLetDecls(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__5___closed__23;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__3___closed__1;
 lean_object* lean_nat_add(lean_object*, lean_object*);
@@ -83,6 +84,7 @@ static lean_object* l_Lean_Elab_Deriving_Ord_mkMutualBlock___closed__3;
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMutualBlock___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* l_Lean_Elab_Deriving_Ord_mkAuxFunction___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_getConstInfoCtor___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__1___closed__4;
+lean_object* l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___lambda__1___closed__7;
 static lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___lambda__1___closed__24;
 lean_object* l_Lean_Elab_Deriving_mkDiscrs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -156,14 +158,13 @@ static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_m
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__5___closed__20;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__6___lambda__1___closed__10;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__6___lambda__1___closed__20;
-lean_object* l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2185_(lean_object*);
+lean_object* l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2233_(lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__5___closed__12;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__6___lambda__1___closed__12;
 static lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___lambda__1___closed__4;
 static lean_object* l_Lean_getConstInfoCtor___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__1___closed__3;
 lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___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*, lean_object*);
 static lean_object* l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__10;
-lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(size_t, size_t, lean_object*);
 lean_object* l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMutualBlock___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___closed__1;
@@ -171,7 +172,9 @@ static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_m
 static lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___lambda__1___closed__17;
 static lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___lambda__1___closed__8;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(size_t, size_t, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Ord_mkOrdHeader___rarg___closed__1;
+static lean_object* l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2233____closed__1;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__5___closed__9;
 static lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction___lambda__1___closed__1;
 lean_object* l_Lean_Elab_Deriving_Ord_mkOrdHeader___boxed(lean_object*);
@@ -191,7 +194,6 @@ lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts__
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__5___closed__1;
 lean_object* lean_array_pop(lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Lean_Elab_Deriving_Ord_mkOrdInstanceHandler___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_Ord_mkAuxFunction(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__5___closed__14;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__5___closed__28;
@@ -2148,7 +2150,7 @@ x_142 = lean_usize_of_nat(x_141);
 lean_dec(x_141);
 x_143 = 0;
 x_144 = x_103;
-x_145 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_142, x_143, x_144);
+x_145 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_142, x_143, x_144);
 x_146 = x_145;
 x_147 = l_List_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__6___lambda__1___closed__16;
 x_148 = l_Lean_mkSepArray(x_146, x_147);
@@ -2198,7 +2200,7 @@ x_170 = lean_array_get_size(x_118);
 x_171 = lean_usize_of_nat(x_170);
 lean_dec(x_170);
 x_172 = x_118;
-x_173 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_171, x_143, x_172);
+x_173 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_171, x_143, x_172);
 x_174 = x_173;
 x_175 = l_Lean_mkSepArray(x_174, x_147);
 lean_dec(x_174);
@@ -2258,7 +2260,7 @@ x_199 = lean_array_get_size(x_131);
 x_200 = lean_usize_of_nat(x_199);
 lean_dec(x_199);
 x_201 = x_131;
-x_202 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_200, x_143, x_201);
+x_202 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_200, x_143, x_201);
 x_203 = x_202;
 x_204 = l_Lean_mkSepArray(x_203, x_147);
 lean_dec(x_203);
@@ -2310,7 +2312,7 @@ x_225 = lean_array_get_size(x_131);
 x_226 = lean_usize_of_nat(x_225);
 lean_dec(x_225);
 x_227 = x_131;
-x_228 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_226, x_143, x_227);
+x_228 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_226, x_143, x_227);
 x_229 = x_228;
 x_230 = l_Lean_mkSepArray(x_229, x_147);
 lean_dec(x_229);
@@ -2588,7 +2590,7 @@ x_348 = lean_usize_of_nat(x_347);
 lean_dec(x_347);
 x_349 = 0;
 x_350 = x_309;
-x_351 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_348, x_349, x_350);
+x_351 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_348, x_349, x_350);
 x_352 = x_351;
 x_353 = l_List_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__6___lambda__1___closed__16;
 x_354 = l_Lean_mkSepArray(x_352, x_353);
@@ -2638,7 +2640,7 @@ x_376 = lean_array_get_size(x_324);
 x_377 = lean_usize_of_nat(x_376);
 lean_dec(x_376);
 x_378 = x_324;
-x_379 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_377, x_349, x_378);
+x_379 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_377, x_349, x_378);
 x_380 = x_379;
 x_381 = l_Lean_mkSepArray(x_380, x_353);
 lean_dec(x_380);
@@ -2705,7 +2707,7 @@ x_406 = lean_array_get_size(x_337);
 x_407 = lean_usize_of_nat(x_406);
 lean_dec(x_406);
 x_408 = x_337;
-x_409 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_407, x_349, x_408);
+x_409 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_407, x_349, x_408);
 x_410 = x_409;
 x_411 = l_Lean_mkSepArray(x_410, x_353);
 lean_dec(x_410);
@@ -3205,7 +3207,7 @@ x_28 = lean_usize_of_nat(x_27);
 lean_dec(x_27);
 x_29 = 0;
 x_30 = x_12;
-x_31 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_28, x_29, x_30);
+x_31 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_28, x_29, x_30);
 x_32 = x_31;
 x_33 = l_List_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__6___lambda__1___closed__16;
 x_34 = l_Lean_mkSepArray(x_32, x_33);
@@ -3263,7 +3265,7 @@ x_61 = lean_usize_of_nat(x_60);
 lean_dec(x_60);
 x_62 = 0;
 x_63 = x_12;
-x_64 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_61, x_62, x_63);
+x_64 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_61, x_62, x_63);
 x_65 = x_64;
 x_66 = l_List_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec__6___lambda__1___closed__16;
 x_67 = l_Lean_mkSepArray(x_65, x_66);
@@ -4853,6 +4855,16 @@ return x_12;
 }
 }
 }
+lean_object* l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+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;
+}
+}
 static lean_object* _init_l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__1() {
 _start:
 {
@@ -4986,7 +4998,7 @@ x_21 = l_Lean_Elab_Deriving_mkInstanceCmds(x_14, x_19, x_1, x_20, x_2, x_3, x_4,
 lean_dec(x_14);
 if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; 
+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; uint8_t x_29; lean_object* x_30; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; 
 x_22 = lean_ctor_get(x_21, 0);
 lean_inc(x_22);
 x_23 = lean_ctor_get(x_21, 1);
@@ -5003,6 +5015,7 @@ x_25 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Ord_mkMatch_mkAlts___spec_
 x_26 = lean_array_push(x_25, x_17);
 x_27 = l_Array_append___rarg(x_26, x_22);
 lean_dec(x_22);
+x_28 = l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__6;
 x_45 = lean_st_ref_get(x_7, x_23);
 x_46 = lean_ctor_get(x_45, 0);
 lean_inc(x_46);
@@ -5018,34 +5031,33 @@ x_49 = lean_ctor_get(x_45, 1);
 lean_inc(x_49);
 lean_dec(x_45);
 x_50 = 0;
-x_28 = x_50;
-x_29 = x_49;
+x_29 = x_50;
+x_30 = x_49;
 goto block_44;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; 
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
 x_51 = lean_ctor_get(x_45, 1);
 lean_inc(x_51);
 lean_dec(x_45);
-x_52 = l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__6;
-x_53 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_52, x_2, x_3, x_4, x_5, x_6, x_7, x_51);
-x_54 = lean_ctor_get(x_53, 0);
+x_52 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_28, x_2, x_3, x_4, x_5, x_6, x_7, x_51);
+x_53 = lean_ctor_get(x_52, 0);
+lean_inc(x_53);
+x_54 = lean_ctor_get(x_52, 1);
 lean_inc(x_54);
-x_55 = lean_ctor_get(x_53, 1);
-lean_inc(x_55);
+lean_dec(x_52);
+x_55 = lean_unbox(x_53);
 lean_dec(x_53);
-x_56 = lean_unbox(x_54);
-lean_dec(x_54);
-x_28 = x_56;
 x_29 = x_55;
+x_30 = x_54;
 goto block_44;
 }
 block_44:
 {
-if (x_28 == 0)
+if (x_29 == 0)
 {
-lean_object* x_30; 
+lean_object* x_31; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -5053,33 +5065,32 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 if (lean_is_scalar(x_24)) {
- x_30 = lean_alloc_ctor(0, 2, 0);
+ x_31 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_30 = x_24;
+ x_31 = x_24;
 }
-lean_ctor_set(x_30, 0, x_27);
-lean_ctor_set(x_30, 1, x_29);
-return x_30;
+lean_ctor_set(x_31, 0, x_27);
+lean_ctor_set(x_31, 1, x_30);
+return x_31;
 }
 else
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; 
+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; uint8_t x_40; 
 lean_dec(x_24);
 lean_inc(x_27);
-x_31 = lean_array_to_list(lean_box(0), x_27);
-x_32 = l_List_map___at___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___spec__1(x_31);
-x_33 = l_Lean_MessageData_ofList(x_32);
-lean_dec(x_32);
-x_34 = l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__8;
-x_35 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_35, 0, x_34);
-lean_ctor_set(x_35, 1, x_33);
-x_36 = l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__10;
-x_37 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_36);
-x_38 = l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__6;
-x_39 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_38, x_37, x_2, x_3, x_4, x_5, x_6, x_7, x_29);
+x_32 = lean_array_to_list(lean_box(0), x_27);
+x_33 = l_List_map___at___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___spec__1(x_32);
+x_34 = l_Lean_MessageData_ofList(x_33);
+lean_dec(x_33);
+x_35 = l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__8;
+x_36 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_36, 0, x_35);
+lean_ctor_set(x_36, 1, x_34);
+x_37 = l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__10;
+x_38 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_37);
+x_39 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_28, x_38, x_2, x_3, x_4, x_5, x_6, x_7, x_30);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -5111,7 +5122,7 @@ return x_43;
 }
 else
 {
-uint8_t x_57; 
+uint8_t x_56; 
 lean_dec(x_17);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -5119,29 +5130,29 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_57 = !lean_is_exclusive(x_21);
-if (x_57 == 0)
+x_56 = !lean_is_exclusive(x_21);
+if (x_56 == 0)
 {
 return x_21;
 }
 else
 {
-lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_58 = lean_ctor_get(x_21, 0);
-x_59 = lean_ctor_get(x_21, 1);
-lean_inc(x_59);
+lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_57 = lean_ctor_get(x_21, 0);
+x_58 = lean_ctor_get(x_21, 1);
 lean_inc(x_58);
+lean_inc(x_57);
 lean_dec(x_21);
-x_60 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_60, 0, x_58);
-lean_ctor_set(x_60, 1, x_59);
-return x_60;
+x_59 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_59, 0, x_57);
+lean_ctor_set(x_59, 1, x_58);
+return x_59;
 }
 }
 }
 else
 {
-uint8_t x_61; 
+uint8_t x_60; 
 lean_dec(x_14);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -5149,56 +5160,71 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_61 = !lean_is_exclusive(x_16);
-if (x_61 == 0)
+x_60 = !lean_is_exclusive(x_16);
+if (x_60 == 0)
 {
 return x_16;
 }
 else
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_62 = lean_ctor_get(x_16, 0);
-x_63 = lean_ctor_get(x_16, 1);
-lean_inc(x_63);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_61 = lean_ctor_get(x_16, 0);
+x_62 = lean_ctor_get(x_16, 1);
 lean_inc(x_62);
+lean_inc(x_61);
 lean_dec(x_16);
-x_64 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_64, 0, x_62);
-lean_ctor_set(x_64, 1, x_63);
-return x_64;
+x_63 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_63, 0, x_61);
+lean_ctor_set(x_63, 1, x_62);
+return x_63;
 }
 }
 }
 else
 {
-uint8_t x_65; 
+uint8_t x_64; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_65 = !lean_is_exclusive(x_13);
-if (x_65 == 0)
+x_64 = !lean_is_exclusive(x_13);
+if (x_64 == 0)
 {
 return x_13;
 }
 else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-x_66 = lean_ctor_get(x_13, 0);
-x_67 = lean_ctor_get(x_13, 1);
-lean_inc(x_67);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_65 = lean_ctor_get(x_13, 0);
+x_66 = lean_ctor_get(x_13, 1);
 lean_inc(x_66);
+lean_inc(x_65);
 lean_dec(x_13);
-x_68 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_68, 0, x_66);
-lean_ctor_set(x_68, 1, x_67);
-return x_68;
+x_67 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_67, 0, x_65);
+lean_ctor_set(x_67, 1, x_66);
+return x_67;
 }
 }
 }
 }
+lean_object* l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_10;
+}
+}
 lean_object* l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
@@ -5528,8 +5554,7 @@ x_29 = 0;
 x_30 = lean_usize_of_nat(x_22);
 lean_dec(x_22);
 x_31 = lean_box(0);
-x_32 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_20, x_29, x_30, x_31, x_2, x_3, x_21);
-lean_dec(x_2);
+x_32 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_20, x_29, x_30, x_31, x_2, x_3, x_21);
 lean_dec(x_20);
 if (lean_obj_tag(x_32) == 0)
 {
@@ -5633,8 +5658,7 @@ x_56 = 0;
 x_57 = lean_usize_of_nat(x_47);
 lean_dec(x_47);
 x_58 = lean_box(0);
-x_59 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_45, x_56, x_57, x_58, x_2, x_3, x_46);
-lean_dec(x_2);
+x_59 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_45, x_56, x_57, x_58, x_2, x_3, x_46);
 lean_dec(x_45);
 if (lean_obj_tag(x_59) == 0)
 {
@@ -5742,7 +5766,7 @@ lean_dec(x_1);
 return x_9;
 }
 }
-static lean_object* _init_l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2185____closed__1() {
+static lean_object* _init_l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2233____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -5750,12 +5774,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Elab_Deriving_Ord_mkOrdInstanceHandler),
 return x_1;
 }
 }
-lean_object* l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2185_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2233_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = l_Lean_Elab_Deriving_Ord_mkOrdHeader___rarg___closed__2;
-x_3 = l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2185____closed__1;
+x_3 = l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2233____closed__1;
 x_4 = l_Lean_Elab_registerBuiltinDerivingHandler(x_2, x_3, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
@@ -6046,9 +6070,9 @@ l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds__
 lean_mark_persistent(l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__9);
 l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__10 = _init_l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__10();
 lean_mark_persistent(l___private_Lean_Elab_Deriving_Ord_0__Lean_Elab_Deriving_Ord_mkOrdInstanceCmds___closed__10);
-l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2185____closed__1 = _init_l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2185____closed__1();
-lean_mark_persistent(l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2185____closed__1);
-res = l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2185_(lean_io_mk_world());
+l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2233____closed__1 = _init_l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2233____closed__1();
+lean_mark_persistent(l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2233____closed__1);
+res = l_Lean_Elab_Deriving_Ord_initFn____x40_Lean_Elab_Deriving_Ord___hyg_2233_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Elab/Deriving/Repr.c

@@ -27,6 +27,7 @@ lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__1___closed__2;
 static lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForStruct___rarg___lambda__2___closed__7;
 lean_object* l_Lean_Elab_Command_liftTermElabM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
@@ -37,6 +38,7 @@ static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForIndu
 static lean_object* l_Lean_Elab_Deriving_Repr_mkReprHeader___rarg___closed__5;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__43;
 lean_object* l_Array_append___rarg(lean_object*, lean_object*);
+lean_object* l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForStruct___rarg___lambda__1___closed__3;
 static lean_object* l_Lean_Elab_Deriving_Repr_mkReprHeader___rarg___closed__28;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__20;
@@ -44,12 +46,14 @@ lean_object* l_List_head_x21___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec
 static lean_object* l_Lean_getConstInfoCtor___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__2___closed__3;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__4___lambda__1___closed__19;
 lean_object* l_Array_anyMUnsafe_any___at_Lean_Elab_Deriving_Repr_mkReprInstanceHandler___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2763____closed__1;
 static lean_object* l_Lean_Elab_Deriving_Repr_mkReprHeader___rarg___closed__18;
 static lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForStruct___rarg___lambda__1___closed__5;
 static lean_object* l_Lean_Elab_Deriving_Repr_mkReprHeader___rarg___closed__30;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__33;
 static lean_object* l_Lean_Elab_Deriving_Repr_mkAuxFunction___lambda__1___closed__22;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__4___closed__4;
+lean_object* l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_environment_find(lean_object*, lean_object*);
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__46;
 static lean_object* l_Lean_getConstInfoCtor___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__2___closed__4;
@@ -70,7 +74,6 @@ static lean_object* l_Lean_Elab_Deriving_Repr_mkAuxFunction___lambda__1___closed
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__25;
 static lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForStruct___rarg___lambda__2___closed__14;
 lean_object* l_Lean_MessageData_ofList(lean_object*);
-static lean_object* l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2712____closed__1;
 static lean_object* l_Lean_Elab_Deriving_Repr_mkReprHeader___rarg___closed__12;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__2___closed__9;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__37;
@@ -205,7 +208,6 @@ static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyFo
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__2___closed__2;
 static lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForInduct___rarg___closed__3;
 lean_object* l_Lean_Elab_Deriving_Repr_mkAuxFunction(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(size_t, size_t, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForInduct___rarg___closed__2;
 lean_object* l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Repr_mkReprHeader___rarg___closed__23;
@@ -214,6 +216,7 @@ static lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForInduct___rarg___closed__1
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__12;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForStruct___rarg___lambda__2___closed__11;
+lean_object* l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(size_t, size_t, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_Repr_mkAuxFunction___lambda__1___closed__25;
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__35;
 lean_object* l_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts_match__1(lean_object*);
@@ -260,7 +263,6 @@ lean_object* l_Lean_Elab_Deriving_Repr_mkAuxFunction___boxed(lean_object*, lean_
 static lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__24;
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__4___boxed(lean_object**);
 lean_object* l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3(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_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_List_head_x21___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__1___closed__1;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__4___closed__1;
 lean_object* l_Lean_Meta_forallTelescopeReducing___at_Lean_Elab_Deriving_mkInductArgNames___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -324,7 +326,7 @@ static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyFo
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__4___lambda__1(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*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_getBetterRef(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2712_(lean_object*);
+lean_object* l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2763_(lean_object*);
 static lean_object* _init_l_Lean_Elab_Deriving_Repr_mkReprHeader___rarg___closed__1() {
 _start:
 {
@@ -4278,7 +4280,7 @@ x_99 = lean_usize_of_nat(x_98);
 lean_dec(x_98);
 x_100 = 0;
 x_101 = x_86;
-x_102 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_99, x_100, x_101);
+x_102 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_99, x_100, x_101);
 x_103 = x_102;
 x_104 = l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__16;
 x_105 = l_Lean_mkSepArray(x_103, x_104);
@@ -4530,7 +4532,7 @@ x_226 = lean_usize_of_nat(x_225);
 lean_dec(x_225);
 x_227 = 0;
 x_228 = x_86;
-x_229 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_226, x_227, x_228);
+x_229 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_226, x_227, x_228);
 x_230 = x_229;
 x_231 = l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__16;
 x_232 = l_Lean_mkSepArray(x_230, x_231);
@@ -5173,7 +5175,7 @@ x_28 = lean_usize_of_nat(x_27);
 lean_dec(x_27);
 x_29 = 0;
 x_30 = x_12;
-x_31 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_28, x_29, x_30);
+x_31 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_28, x_29, x_30);
 x_32 = x_31;
 x_33 = l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__16;
 x_34 = l_Lean_mkSepArray(x_32, x_33);
@@ -5231,7 +5233,7 @@ x_61 = lean_usize_of_nat(x_60);
 lean_dec(x_60);
 x_62 = 0;
 x_63 = x_12;
-x_64 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4440____spec__3(x_61, x_62, x_63);
+x_64 = l_Array_mapMUnsafe_map___at_myMacro____x40_Init_NotationExtra___hyg_4451____spec__3(x_61, x_62, x_63);
 x_65 = x_64;
 x_66 = l_List_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForInduct_mkAlts___spec__3___lambda__1___closed__16;
 x_67 = l_Lean_mkSepArray(x_65, x_66);
@@ -6750,6 +6752,16 @@ return x_12;
 }
 }
 }
+lean_object* l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+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;
+}
+}
 static lean_object* _init_l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__1() {
 _start:
 {
@@ -6875,7 +6887,7 @@ x_21 = l_Lean_Elab_Deriving_mkInstanceCmds(x_14, x_19, x_1, x_20, x_2, x_3, x_4,
 lean_dec(x_14);
 if (lean_obj_tag(x_21) == 0)
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; 
+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; uint8_t x_29; lean_object* x_30; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; 
 x_22 = lean_ctor_get(x_21, 0);
 lean_inc(x_22);
 x_23 = lean_ctor_get(x_21, 1);
@@ -6892,6 +6904,7 @@ x_25 = l_Lean_Elab_Deriving_Repr_mkReprHeader___rarg___closed__18;
 x_26 = lean_array_push(x_25, x_17);
 x_27 = l_Array_append___rarg(x_26, x_22);
 lean_dec(x_22);
+x_28 = l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__5;
 x_45 = lean_st_ref_get(x_7, x_23);
 x_46 = lean_ctor_get(x_45, 0);
 lean_inc(x_46);
@@ -6907,34 +6920,33 @@ x_49 = lean_ctor_get(x_45, 1);
 lean_inc(x_49);
 lean_dec(x_45);
 x_50 = 0;
-x_28 = x_50;
-x_29 = x_49;
+x_29 = x_50;
+x_30 = x_49;
 goto block_44;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; 
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
 x_51 = lean_ctor_get(x_45, 1);
 lean_inc(x_51);
 lean_dec(x_45);
-x_52 = l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__5;
-x_53 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_52, x_2, x_3, x_4, x_5, x_6, x_7, x_51);
-x_54 = lean_ctor_get(x_53, 0);
+x_52 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_28, x_2, x_3, x_4, x_5, x_6, x_7, x_51);
+x_53 = lean_ctor_get(x_52, 0);
+lean_inc(x_53);
+x_54 = lean_ctor_get(x_52, 1);
 lean_inc(x_54);
-x_55 = lean_ctor_get(x_53, 1);
-lean_inc(x_55);
+lean_dec(x_52);
+x_55 = lean_unbox(x_53);
 lean_dec(x_53);
-x_56 = lean_unbox(x_54);
-lean_dec(x_54);
-x_28 = x_56;
 x_29 = x_55;
+x_30 = x_54;
 goto block_44;
 }
 block_44:
 {
-if (x_28 == 0)
+if (x_29 == 0)
 {
-lean_object* x_30; 
+lean_object* x_31; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -6942,33 +6954,32 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 if (lean_is_scalar(x_24)) {
- x_30 = lean_alloc_ctor(0, 2, 0);
+ x_31 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_30 = x_24;
+ x_31 = x_24;
 }
-lean_ctor_set(x_30, 0, x_27);
-lean_ctor_set(x_30, 1, x_29);
-return x_30;
+lean_ctor_set(x_31, 0, x_27);
+lean_ctor_set(x_31, 1, x_30);
+return x_31;
 }
 else
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; 
+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; uint8_t x_40; 
 lean_dec(x_24);
 lean_inc(x_27);
-x_31 = lean_array_to_list(lean_box(0), x_27);
-x_32 = l_List_map___at___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___spec__1(x_31);
-x_33 = l_Lean_MessageData_ofList(x_32);
-lean_dec(x_32);
-x_34 = l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__7;
-x_35 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_35, 0, x_34);
-lean_ctor_set(x_35, 1, x_33);
-x_36 = l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__9;
-x_37 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_36);
-x_38 = l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__5;
-x_39 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_38, x_37, x_2, x_3, x_4, x_5, x_6, x_7, x_29);
+x_32 = lean_array_to_list(lean_box(0), x_27);
+x_33 = l_List_map___at___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___spec__1(x_32);
+x_34 = l_Lean_MessageData_ofList(x_33);
+lean_dec(x_33);
+x_35 = l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__7;
+x_36 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_36, 0, x_35);
+lean_ctor_set(x_36, 1, x_34);
+x_37 = l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__9;
+x_38 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_37);
+x_39 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_28, x_38, x_2, x_3, x_4, x_5, x_6, x_7, x_30);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -7000,7 +7011,7 @@ return x_43;
 }
 else
 {
-uint8_t x_57; 
+uint8_t x_56; 
 lean_dec(x_17);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -7008,29 +7019,29 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_57 = !lean_is_exclusive(x_21);
-if (x_57 == 0)
+x_56 = !lean_is_exclusive(x_21);
+if (x_56 == 0)
 {
 return x_21;
 }
 else
 {
-lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_58 = lean_ctor_get(x_21, 0);
-x_59 = lean_ctor_get(x_21, 1);
-lean_inc(x_59);
+lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_57 = lean_ctor_get(x_21, 0);
+x_58 = lean_ctor_get(x_21, 1);
 lean_inc(x_58);
+lean_inc(x_57);
 lean_dec(x_21);
-x_60 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_60, 0, x_58);
-lean_ctor_set(x_60, 1, x_59);
-return x_60;
+x_59 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_59, 0, x_57);
+lean_ctor_set(x_59, 1, x_58);
+return x_59;
 }
 }
 }
 else
 {
-uint8_t x_61; 
+uint8_t x_60; 
 lean_dec(x_14);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -7038,56 +7049,71 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_61 = !lean_is_exclusive(x_16);
-if (x_61 == 0)
+x_60 = !lean_is_exclusive(x_16);
+if (x_60 == 0)
 {
 return x_16;
 }
 else
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_62 = lean_ctor_get(x_16, 0);
-x_63 = lean_ctor_get(x_16, 1);
-lean_inc(x_63);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; 
+x_61 = lean_ctor_get(x_16, 0);
+x_62 = lean_ctor_get(x_16, 1);
 lean_inc(x_62);
+lean_inc(x_61);
 lean_dec(x_16);
-x_64 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_64, 0, x_62);
-lean_ctor_set(x_64, 1, x_63);
-return x_64;
+x_63 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_63, 0, x_61);
+lean_ctor_set(x_63, 1, x_62);
+return x_63;
 }
 }
 }
 else
 {
-uint8_t x_65; 
+uint8_t x_64; 
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_65 = !lean_is_exclusive(x_13);
-if (x_65 == 0)
+x_64 = !lean_is_exclusive(x_13);
+if (x_64 == 0)
 {
 return x_13;
 }
 else
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; 
-x_66 = lean_ctor_get(x_13, 0);
-x_67 = lean_ctor_get(x_13, 1);
-lean_inc(x_67);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_65 = lean_ctor_get(x_13, 0);
+x_66 = lean_ctor_get(x_13, 1);
 lean_inc(x_66);
+lean_inc(x_65);
 lean_dec(x_13);
-x_68 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_68, 0, x_66);
-lean_ctor_set(x_68, 1, x_67);
-return x_68;
+x_67 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_67, 0, x_65);
+lean_ctor_set(x_67, 1, x_66);
+return x_67;
 }
 }
 }
 }
+lean_object* l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_10;
+}
+}
 lean_object* l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
@@ -7417,8 +7443,7 @@ x_29 = 0;
 x_30 = lean_usize_of_nat(x_22);
 lean_dec(x_22);
 x_31 = lean_box(0);
-x_32 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_20, x_29, x_30, x_31, x_2, x_3, x_21);
-lean_dec(x_2);
+x_32 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_20, x_29, x_30, x_31, x_2, x_3, x_21);
 lean_dec(x_20);
 if (lean_obj_tag(x_32) == 0)
 {
@@ -7522,8 +7547,7 @@ x_56 = 0;
 x_57 = lean_usize_of_nat(x_47);
 lean_dec(x_47);
 x_58 = lean_box(0);
-x_59 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__12(x_45, x_56, x_57, x_58, x_2, x_3, x_46);
-lean_dec(x_2);
+x_59 = l_Array_foldlMUnsafe_fold___at_Lean_Elab_Command_elabCommand___spec__10(x_45, x_56, x_57, x_58, x_2, x_3, x_46);
 lean_dec(x_45);
 if (lean_obj_tag(x_59) == 0)
 {
@@ -7631,7 +7655,7 @@ lean_dec(x_1);
 return x_9;
 }
 }
-static lean_object* _init_l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2712____closed__1() {
+static lean_object* _init_l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2763____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -7639,12 +7663,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Elab_Deriving_Repr_mkReprInstanceHandler
 return x_1;
 }
 }
-lean_object* l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2712_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2763_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = l_Lean_Elab_Deriving_Repr_mkReprHeader___rarg___closed__2;
-x_3 = l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2712____closed__1;
+x_3 = l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2763____closed__1;
 x_4 = l_Lean_Elab_registerBuiltinDerivingHandler(x_2, x_3, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
@@ -8091,9 +8115,9 @@ l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmd
 lean_mark_persistent(l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__8);
 l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__9 = _init_l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__9();
 lean_mark_persistent(l___private_Lean_Elab_Deriving_Repr_0__Lean_Elab_Deriving_Repr_mkReprInstanceCmds___closed__9);
-l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2712____closed__1 = _init_l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2712____closed__1();
-lean_mark_persistent(l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2712____closed__1);
-res = l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2712_(lean_io_mk_world());
+l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2763____closed__1 = _init_l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2763____closed__1();
+lean_mark_persistent(l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2763____closed__1);
+res = l_Lean_Elab_Deriving_Repr_initFn____x40_Lean_Elab_Deriving_Repr___hyg_2763_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Elab/Deriving/SizeOf.c

@@ -21,7 +21,7 @@ lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* lean_environment_find(lean_object*, lean_object*);
 lean_object* l_Lean_isInductive___at_Lean_Elab_Deriving_SizeOf_mkSizeOfHandler___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52_(lean_object*);
+lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53_(lean_object*);
 lean_object* l_Lean_Elab_Deriving_SizeOf_mkSizeOfHandler(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Lean_Elab_Deriving_SizeOf_mkSizeOfHandler___spec__2(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*);
@@ -31,14 +31,14 @@ lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyMUnsafe_any___at_Lean_Elab_Deriving_SizeOf_mkSizeOfHandler___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__2;
 extern lean_object* l_Lean_instInhabitedName;
 lean_object* l_Lean_Elab_registerBuiltinDerivingHandler(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_SizeOf_mkSizeOfHandler___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__1;
+static lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__2;
+static lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__1;
 lean_object* l_Lean_Elab_Deriving_SizeOf_mkSizeOfHandler___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_isInductive___at_Lean_Elab_Deriving_SizeOf_mkSizeOfHandler___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__3;
+static lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__3;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Lean_isInductive___at_Lean_Elab_Deriving_SizeOf_mkSizeOfHandler___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
@@ -418,7 +418,7 @@ lean_dec(x_1);
 return x_5;
 }
 }
-static lean_object* _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__1() {
+static lean_object* _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -426,17 +426,17 @@ x_1 = lean_mk_string("SizeOf");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__2() {
+static lean_object* _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__1;
+x_2 = l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__3() {
+static lean_object* _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -444,12 +444,12 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Elab_Deriving_SizeOf_mkSizeOfHandler___b
 return x_1;
 }
 }
-lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__2;
-x_3 = l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__3;
+x_2 = l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__2;
+x_3 = l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__3;
 x_4 = l_Lean_Elab_registerBuiltinDerivingHandler(x_2, x_3, x_1);
 return x_4;
 }
@@ -471,13 +471,13 @@ lean_dec_ref(res);
 res = initialize_Lean_Elab_Deriving_Basic(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__1 = _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__1();
-lean_mark_persistent(l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__1);
-l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__2 = _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__2();
-lean_mark_persistent(l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__2);
-l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__3 = _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__3();
-lean_mark_persistent(l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52____closed__3);
-res = l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_52_(lean_io_mk_world());
+l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__1 = _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__1();
+lean_mark_persistent(l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__1);
+l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__2 = _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__2();
+lean_mark_persistent(l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__2);
+l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__3 = _init_l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__3();
+lean_mark_persistent(l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53____closed__3);
+res = l_Lean_Elab_Deriving_SizeOf_initFn____x40_Lean_Elab_Deriving_SizeOf___hyg_53_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Elab/Deriving/Util.c

@@ -76,6 +76,7 @@ uint8_t l_USize_decLt(size_t, size_t);
 static lean_object* l_Lean_Elab_Deriving_mkDiscr___closed__2;
 lean_object* l_Lean_Elab_Deriving_mkLocalInstanceLetDecls(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_mkLocalInstanceLetDecls___spec__1___closed__14;
+lean_object* l_Lean_Elab_Deriving_mkContext___lambda__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* l_Lean_Elab_Deriving_mkDiscr___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Deriving_instBinderF;
@@ -181,6 +182,7 @@ static lean_object* l_Array_foldrMUnsafe_fold___at_Lean_Elab_Deriving_mkLet___sp
 lean_object* l_Lean_Meta_forallTelescopeReducing___at_Lean_Elab_Deriving_mkInductArgNames___spec__2___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Deriving_mkInductiveApp___closed__6;
 lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_mkHeader___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Deriving_mkContext___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_forallTelescopeReducing___at_Lean_Elab_Deriving_mkInductArgNames___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Deriving_mkInductiveApp___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_mkInstanceCmds___spec__1___lambda__1___closed__8;
@@ -1793,6 +1795,42 @@ return x_12;
 }
 }
 }
+lean_object* l_Lean_Elab_Deriving_mkContext___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
+_start:
+{
+uint8_t x_12; 
+x_12 = lean_ctor_get_uint8(x_1, sizeof(void*)*5 + 3);
+if (x_12 == 0)
+{
+lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; 
+x_13 = lean_array_get_size(x_2);
+x_14 = lean_unsigned_to_nat(1u);
+x_15 = lean_nat_dec_lt(x_14, x_13);
+lean_dec(x_13);
+x_16 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_16, 0, x_2);
+lean_ctor_set(x_16, 1, x_3);
+lean_ctor_set_uint8(x_16, sizeof(void*)*2, x_15);
+x_17 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_17, 0, x_16);
+lean_ctor_set(x_17, 1, x_11);
+return x_17;
+}
+else
+{
+uint8_t x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = 1;
+x_19 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_19, 0, x_2);
+lean_ctor_set(x_19, 1, x_3);
+lean_ctor_set_uint8(x_19, sizeof(void*)*2, x_18);
+x_20 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_11);
+return x_20;
+}
+}
+}
 static lean_object* _init_l_Lean_Elab_Deriving_mkContext___closed__1() {
 _start:
 {
@@ -1886,7 +1924,7 @@ lean_inc(x_13);
 x_15 = l_List_forIn_loop___at_Lean_Elab_Deriving_mkContext___spec__3(x_13, x_14, x_3, x_4, x_5, x_6, x_7, x_8, x_12);
 if (lean_obj_tag(x_15) == 0)
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; 
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; 
 x_16 = lean_ctor_get(x_15, 0);
 lean_inc(x_16);
 x_17 = lean_ctor_get(x_15, 1);
@@ -1897,174 +1935,134 @@ x_19 = lean_ctor_get(x_18, 0);
 lean_inc(x_19);
 x_20 = lean_ctor_get(x_18, 1);
 lean_inc(x_20);
-if (lean_is_exclusive(x_18)) {
- lean_ctor_release(x_18, 0);
- lean_ctor_release(x_18, 1);
- x_21 = x_18;
-} else {
- lean_dec_ref(x_18);
- x_21 = lean_box(0);
-}
-x_33 = lean_st_ref_get(x_8, x_20);
-x_34 = lean_ctor_get(x_33, 0);
-lean_inc(x_34);
-x_35 = lean_ctor_get(x_34, 3);
-lean_inc(x_35);
-lean_dec(x_34);
-x_36 = lean_ctor_get_uint8(x_35, sizeof(void*)*1);
-lean_dec(x_35);
-if (x_36 == 0)
-{
-lean_object* x_37; 
-lean_dec(x_3);
-x_37 = lean_ctor_get(x_33, 1);
-lean_inc(x_37);
-lean_dec(x_33);
-x_22 = x_37;
-goto block_32;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; 
-x_38 = lean_ctor_get(x_33, 1);
+lean_dec(x_18);
+x_21 = l_Lean_Elab_Deriving_mkContext___closed__6;
+x_37 = lean_st_ref_get(x_8, x_20);
+x_38 = lean_ctor_get(x_37, 0);
 lean_inc(x_38);
-lean_dec(x_33);
-x_39 = l_Lean_Elab_Deriving_mkContext___closed__6;
-x_40 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_39, x_3, x_4, x_5, x_6, x_7, x_8, x_38);
-x_41 = lean_ctor_get(x_40, 0);
+x_39 = lean_ctor_get(x_38, 3);
+lean_inc(x_39);
+lean_dec(x_38);
+x_40 = lean_ctor_get_uint8(x_39, sizeof(void*)*1);
+lean_dec(x_39);
+if (x_40 == 0)
+{
+lean_object* x_41; uint8_t x_42; 
+x_41 = lean_ctor_get(x_37, 1);
 lean_inc(x_41);
-x_42 = lean_unbox(x_41);
-lean_dec(x_41);
-if (x_42 == 0)
+lean_dec(x_37);
+x_42 = 0;
+x_22 = x_42;
+x_23 = x_41;
+goto block_36;
+}
+else
 {
-lean_object* x_43; 
-lean_dec(x_3);
-x_43 = lean_ctor_get(x_40, 1);
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; 
+x_43 = lean_ctor_get(x_37, 1);
 lean_inc(x_43);
-lean_dec(x_40);
-x_22 = x_43;
-goto block_32;
+lean_dec(x_37);
+x_44 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__2(x_21, x_3, x_4, x_5, x_6, x_7, x_8, x_43);
+x_45 = lean_ctor_get(x_44, 0);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_44, 1);
+lean_inc(x_46);
+lean_dec(x_44);
+x_47 = lean_unbox(x_45);
+lean_dec(x_45);
+x_22 = x_47;
+x_23 = x_46;
+goto block_36;
 }
-else
+block_36:
 {
-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; 
-x_44 = lean_ctor_get(x_40, 1);
-lean_inc(x_44);
-lean_dec(x_40);
-lean_inc(x_19);
-x_45 = lean_array_to_list(lean_box(0), x_19);
-x_46 = l_List_map___at_Lean_Elab_Deriving_mkContext___spec__5(x_45);
-x_47 = l_Lean_MessageData_ofList(x_46);
-lean_dec(x_46);
-x_48 = l_Lean_Elab_Deriving_mkContext___closed__8;
-x_49 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_49, 0, x_48);
-lean_ctor_set(x_49, 1, x_47);
-x_50 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_50, 0, x_49);
-lean_ctor_set(x_50, 1, x_48);
-x_51 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_39, x_50, x_3, x_4, x_5, x_6, x_7, x_8, x_44);
+if (x_22 == 0)
+{
+lean_object* x_24; lean_object* x_25; 
+x_24 = lean_box(0);
+x_25 = l_Lean_Elab_Deriving_mkContext___lambda__1(x_11, x_16, x_19, x_24, x_3, x_4, x_5, x_6, x_7, x_8, x_23);
 lean_dec(x_3);
-x_52 = lean_ctor_get(x_51, 1);
-lean_inc(x_52);
-lean_dec(x_51);
-x_22 = x_52;
-goto block_32;
-}
-}
-block_32:
-{
-uint8_t x_23; 
-x_23 = lean_ctor_get_uint8(x_11, sizeof(void*)*5 + 3);
 lean_dec(x_11);
-if (x_23 == 0)
-{
-lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; 
-x_24 = lean_array_get_size(x_16);
-x_25 = lean_unsigned_to_nat(1u);
-x_26 = lean_nat_dec_lt(x_25, x_24);
-lean_dec(x_24);
-x_27 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_27, 0, x_16);
-lean_ctor_set(x_27, 1, x_19);
-lean_ctor_set_uint8(x_27, sizeof(void*)*2, x_26);
-if (lean_is_scalar(x_21)) {
- x_28 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_28 = x_21;
-}
-lean_ctor_set(x_28, 0, x_27);
-lean_ctor_set(x_28, 1, x_22);
-return x_28;
+return x_25;
 }
 else
 {
-uint8_t x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = 1;
-x_30 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_30, 0, x_16);
-lean_ctor_set(x_30, 1, x_19);
-lean_ctor_set_uint8(x_30, sizeof(void*)*2, x_29);
-if (lean_is_scalar(x_21)) {
- x_31 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_31 = x_21;
-}
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+lean_inc(x_19);
+x_26 = lean_array_to_list(lean_box(0), x_19);
+x_27 = l_List_map___at_Lean_Elab_Deriving_mkContext___spec__5(x_26);
+x_28 = l_Lean_MessageData_ofList(x_27);
+lean_dec(x_27);
+x_29 = l_Lean_Elab_Deriving_mkContext___closed__8;
+x_30 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_30, 0, x_29);
+lean_ctor_set(x_30, 1, x_28);
+x_31 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_31, 0, x_30);
-lean_ctor_set(x_31, 1, x_22);
-return x_31;
+lean_ctor_set(x_31, 1, x_29);
+x_32 = l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(x_21, x_31, x_3, x_4, x_5, x_6, x_7, x_8, x_23);
+x_33 = lean_ctor_get(x_32, 0);
+lean_inc(x_33);
+x_34 = lean_ctor_get(x_32, 1);
+lean_inc(x_34);
+lean_dec(x_32);
+x_35 = l_Lean_Elab_Deriving_mkContext___lambda__1(x_11, x_16, x_19, x_33, x_3, x_4, x_5, x_6, x_7, x_8, x_34);
+lean_dec(x_3);
+lean_dec(x_33);
+lean_dec(x_11);
+return x_35;
 }
 }
 }
 else
 {
-uint8_t x_53; 
+uint8_t x_48; 
 lean_dec(x_13);
 lean_dec(x_11);
 lean_dec(x_3);
 lean_dec(x_1);
-x_53 = !lean_is_exclusive(x_15);
-if (x_53 == 0)
+x_48 = !lean_is_exclusive(x_15);
+if (x_48 == 0)
 {
 return x_15;
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_54 = lean_ctor_get(x_15, 0);
-x_55 = lean_ctor_get(x_15, 1);
-lean_inc(x_55);
-lean_inc(x_54);
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+x_49 = lean_ctor_get(x_15, 0);
+x_50 = lean_ctor_get(x_15, 1);
+lean_inc(x_50);
+lean_inc(x_49);
 lean_dec(x_15);
-x_56 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_56, 0, x_54);
-lean_ctor_set(x_56, 1, x_55);
-return x_56;
+x_51 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_51, 0, x_49);
+lean_ctor_set(x_51, 1, x_50);
+return x_51;
 }
 }
 }
 else
 {
-uint8_t x_57; 
+uint8_t x_52; 
 lean_dec(x_3);
 lean_dec(x_1);
-x_57 = !lean_is_exclusive(x_10);
-if (x_57 == 0)
+x_52 = !lean_is_exclusive(x_10);
+if (x_52 == 0)
 {
 return x_10;
 }
 else
 {
-lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_58 = lean_ctor_get(x_10, 0);
-x_59 = lean_ctor_get(x_10, 1);
-lean_inc(x_59);
-lean_inc(x_58);
+lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+x_53 = lean_ctor_get(x_10, 0);
+x_54 = lean_ctor_get(x_10, 1);
+lean_inc(x_54);
+lean_inc(x_53);
 lean_dec(x_10);
-x_60 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_60, 0, x_58);
-lean_ctor_set(x_60, 1, x_59);
-return x_60;
+x_55 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_55, 0, x_53);
+lean_ctor_set(x_55, 1, x_54);
+return x_55;
 }
 }
 }
@@ -2122,6 +2120,22 @@ lean_dec(x_4);
 return x_11;
 }
 }
+lean_object* l_Lean_Elab_Deriving_mkContext___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
+_start:
+{
+lean_object* x_12; 
+x_12 = l_Lean_Elab_Deriving_mkContext___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11);
+lean_dec(x_10);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+return x_12;
+}
+}
 lean_object* l_Lean_Elab_Deriving_mkContext___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
 _start:
 {

stage0/stdlib/Lean/Elab/Frontend.c

@@ -20,31 +20,31 @@ lean_object* l_Lean_Elab_Frontend_runCommandElabM_match__1___rarg(lean_object*,
 static lean_object* l_Lean_Elab_process___closed__2;
 lean_object* l_Lean_Elab_IO_processCommands_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_elabCommandAtFrontend___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__2;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_parseHeader(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_State_commands___default;
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__2;
 lean_object* l_Lean_Elab_IO_processCommands(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_processCommand_match__1___rarg(lean_object*, lean_object*);
 lean_object* lean_run_frontend(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__1;
 static lean_object* l_Lean_Elab_process___closed__1;
 lean_object* lean_environment_set_main_module(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_setCommandState___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_checkTraceOption(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_getCommandState___rarg___boxed(lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__4;
 lean_object* l_Lean_Elab_Frontend_elabCommandAtFrontend___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkInputContext(lean_object*, lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_runCommandElabM(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__4;
 lean_object* l_Lean_Elab_Frontend_processCommand_match__1(lean_object*);
 lean_object* lean_profileit(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_enableInfoTree___at_Lean_Elab_Frontend_elabCommandAtFrontend___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__1;
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__3;
 lean_object* l_Lean_Elab_processHeader(lean_object*, lean_object*, lean_object*, lean_object*, uint32_t, lean_object*);
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__3;
 lean_object* l_Lean_Elab_runFrontend_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_List_forIn_loop___at_Lean_Elab_runFrontend___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MessageLog_toList(lean_object*);
@@ -57,7 +57,7 @@ lean_object* l_Lean_Elab_Frontend_getInputContext___boxed(lean_object*, lean_obj
 uint8_t l_Lean_KVMap_getBool(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Elab_Frontend_setParserState___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_print___at_IO_println___spec__1(lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__5;
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__5;
 lean_object* l_Lean_Elab_Command_mkState(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forIn_loop___at_Lean_Elab_runFrontend___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
@@ -65,10 +65,9 @@ lean_object* l_Lean_Elab_Frontend_elabCommandAtFrontend(lean_object*, lean_objec
 lean_object* l_Lean_Elab_getPrintMessageEndPos___boxed(lean_object*);
 static lean_object* l_Lean_Elab_Frontend_runCommandElabM___rarg___closed__1;
 static lean_object* l_Lean_Elab_Frontend_processCommand___closed__1;
-lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753_(lean_object*);
+lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761_(lean_object*);
 lean_object* l_Lean_Elab_Frontend_updateCmdPos(lean_object*);
 extern lean_object* l_Lean_firstFrontendMacroScope;
-lean_object* l_Lean_Elab_Command_elabCommand(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_setCommandState(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_runCommandElabM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Frontend_processCommand___closed__2;
@@ -94,6 +93,7 @@ lean_object* l_Lean_Elab_IO_processCommands_match__1(lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_setParserState(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_enableInfoTree___at_Lean_Elab_Frontend_elabCommandAtFrontend___spec__1(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Command_elabCommandTopLevel(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Frontend_elabCommandAtFrontend___closed__3;
 lean_object* l_Lean_profileitIOUnsafe___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Frontend_updateCmdPos___boxed(lean_object*);
@@ -641,7 +641,8 @@ _start:
 {
 lean_object* x_7; 
 lean_inc(x_5);
-x_7 = l_Lean_Elab_Command_elabCommand(x_1, x_4, x_5, x_6);
+lean_inc(x_4);
+x_7 = l_Lean_Elab_Command_elabCommandTopLevel(x_1, x_4, x_5, x_6);
 if (lean_obj_tag(x_7) == 0)
 {
 lean_object* x_8; lean_object* x_9; 
@@ -650,12 +651,14 @@ lean_inc(x_8);
 lean_dec(x_7);
 x_9 = l_Lean_Elab_enableInfoTree___at_Lean_Elab_Frontend_elabCommandAtFrontend___spec__1(x_2, x_4, x_5, x_8);
 lean_dec(x_5);
+lean_dec(x_4);
 return x_9;
 }
 else
 {
 uint8_t x_10; 
 lean_dec(x_5);
+lean_dec(x_4);
 x_10 = !lean_is_exclusive(x_7);
 if (x_10 == 0)
 {
@@ -784,7 +787,6 @@ lean_object* x_74; lean_object* x_75;
 x_74 = lean_box(0);
 lean_inc(x_51);
 x_75 = l_Lean_Elab_Frontend_elabCommandAtFrontend___lambda__1(x_1, x_65, x_74, x_48, x_51, x_68);
-lean_dec(x_48);
 if (lean_obj_tag(x_75) == 0)
 {
 lean_object* x_76; lean_object* x_77; 
@@ -825,7 +827,6 @@ lean_inc(x_84);
 lean_dec(x_82);
 lean_inc(x_51);
 x_85 = l_Lean_Elab_Frontend_elabCommandAtFrontend___lambda__1(x_1, x_65, x_83, x_48, x_51, x_84);
-lean_dec(x_48);
 lean_dec(x_83);
 if (lean_obj_tag(x_85) == 0)
 {
@@ -1002,7 +1003,6 @@ uint8_t x_7; lean_object* x_8;
 x_7 = lean_unbox(x_2);
 lean_dec(x_2);
 x_8 = l_Lean_Elab_Frontend_elabCommandAtFrontend___lambda__1(x_1, x_7, x_3, x_4, x_5, x_6);
-lean_dec(x_4);
 lean_dec(x_3);
 return x_8;
 }
@@ -2450,7 +2450,7 @@ return x_47;
 }
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__1() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -2458,17 +2458,17 @@ x_1 = lean_mk_string("printMessageEndPos");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__2() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__1;
+x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__3() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__3() {
 _start:
 {
 uint8_t x_1; lean_object* x_2; 
@@ -2478,7 +2478,7 @@ lean_ctor_set_uint8(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__4() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -2486,13 +2486,13 @@ x_1 = lean_mk_string("print end position of each message in addition to start po
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__5() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__3;
+x_1 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__3;
 x_2 = l_Lean_Elab_Frontend_runCommandElabM___rarg___closed__2;
-x_3 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__4;
+x_3 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__4;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -2500,12 +2500,12 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753_(lean_object* x_1) {
+lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__2;
-x_3 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__5;
+x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__2;
+x_3 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__5;
 x_4 = lean_register_option(x_2, x_3, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
@@ -2545,7 +2545,7 @@ uint8_t l_Lean_Elab_getPrintMessageEndPos(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; uint8_t x_3; uint8_t x_4; 
-x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__2;
+x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__2;
 x_3 = 0;
 x_4 = l_Lean_KVMap_getBool(x_1, x_2, x_3);
 return x_4;
@@ -3109,17 +3109,17 @@ l_Lean_Elab_process___closed__4 = _init_l_Lean_Elab_process___closed__4();
 lean_mark_persistent(l_Lean_Elab_process___closed__4);
 l_Lean_Elab_process___closed__5 = _init_l_Lean_Elab_process___closed__5();
 lean_mark_persistent(l_Lean_Elab_process___closed__5);
-l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__1();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__1);
-l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__2 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__2();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__2);
-l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__3 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__3();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__3);
-l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__4 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__4();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__4);
-l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__5 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__5();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753____closed__5);
-res = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_753_(lean_io_mk_world());
+l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__1();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__1);
+l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__2 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__2();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__2);
+l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__3 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__3();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__3);
+l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__4 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__4();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__4);
+l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__5 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__5();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761____closed__5);
+res = l_Lean_Elab_initFn____x40_Lean_Elab_Frontend___hyg_761_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Elab/GenInjective.c

@@ -31,12 +31,12 @@ lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_obj
 lean_object* l_Lean_resolveGlobalName___at_Lean_Elab_Command_elabGenInjectiveTheorems___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___regBuiltin_Lean_Elab_Command_elabGenInjectiveTheorems___closed__2;
 static lean_object* l___regBuiltin_Lean_Elab_Command_elabGenInjectiveTheorems___closed__4;
-lean_object* l_Lean_throwError___at_Lean_Elab_Command_elabCommand___spec__13(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___at_Lean_resolveGlobalConstNoOverload___spec__1(lean_object*, lean_object*);
 static lean_object* l___regBuiltin_Lean_Elab_Command_elabGenInjectiveTheorems___closed__9;
 static lean_object* l___regBuiltin_Lean_Elab_Command_elabGenInjectiveTheorems___closed__8;
 lean_object* l_Lean_resolveGlobalConst___at_Lean_Elab_Command_elabGenInjectiveTheorems___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwUnknownConstant___at_Lean_Elab_Command_elabGenInjectiveTheorems___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_Elab_Command_elabCommand___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___regBuiltin_Lean_Elab_Command_elabGenInjectiveTheorems___closed__1;
 lean_object* l_Lean_Syntax_getId(lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Command_elabExport___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -176,7 +176,7 @@ x_10 = l_Lean_throwUnknownConstant___at_Lean_Elab_Command_elabGenInjectiveTheore
 x_11 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_11, 0, x_9);
 lean_ctor_set(x_11, 1, x_10);
-x_12 = l_Lean_throwError___at_Lean_Elab_Command_elabCommand___spec__13(x_11, x_2, x_3, x_4);
+x_12 = l_Lean_throwError___at_Lean_Elab_Command_elabCommand___spec__1(x_11, x_2, x_3, x_4);
 return x_12;
 }
 }

stage0/stdlib/Lean/Elab/Level.c

@@ -62,13 +62,13 @@ lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Level_mkFreshLevelMVar(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Level_instMonadOptionsLevelElabM___closed__1;
 lean_object* l_Lean_Elab_Level_maxUniverseOffset;
-static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__2;
-static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__1;
+static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__2;
+static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__1;
 lean_object* lean_level_mk_max_simp(lean_object*, lean_object*);
 lean_object* l_Lean_replaceRef(lean_object*, lean_object*);
 lean_object* l_Array_foldrMUnsafe_fold___at_Lean_Elab_Level_elabLevel___spec__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_level_mk_imax_simp(lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212_(lean_object*);
+lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213_(lean_object*);
 static lean_object* l_Lean_Elab_Level_elabLevel___closed__12;
 lean_object* l_Lean_Elab_Level_elabLevel_match__1(lean_object*);
 lean_object* l_Lean_Syntax_getId(lean_object*);
@@ -80,9 +80,7 @@ lean_object* l_Lean_Elab_Level_instMonadNameGeneratorLevelElabM___lambda__3(lean
 static lean_object* l_Lean_Elab_Level_elabLevel___closed__2;
 lean_object* l_Array_foldrMUnsafe_fold___at_Lean_Elab_Level_elabLevel___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Level_instMonadRefLevelElabM___lambda__1(lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__3;
 static lean_object* l_Lean_Elab_Level_instMonadOptionsLevelElabM___closed__3;
-static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__5;
 lean_object* l_Lean_Elab_Level_elabLevel_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Level_0__Lean_Elab_Level_checkUniverseOffset___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Level_0__Lean_Elab_Level_checkUniverseOffset___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -109,11 +107,13 @@ lean_object* l_Lean_throwError___at_Lean_Elab_Level_elabLevel___spec__4(lean_obj
 lean_object* l_Lean_Syntax_getKind(lean_object*);
 static lean_object* l_Lean_Elab_Level_elabLevel___closed__14;
 lean_object* l_Array_foldrMUnsafe_fold___at_Lean_Elab_Level_elabLevel___spec__7(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__5;
 static lean_object* l_Lean_Elab_throwIllFormedSyntax___at_Lean_Elab_Level_elabLevel___spec__2___closed__2;
 lean_object* l_Lean_throwError___at_Lean_Elab_Level_elabLevel___spec__4___boxed(lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_Level_0__Lean_Elab_Level_checkUniverseOffset___rarg___lambda__1___closed__2;
 lean_object* l_Lean_mkFreshId___at_Lean_Elab_Level_mkFreshLevelMVar___spec__1___boxed(lean_object*);
 static lean_object* l_Lean_Elab_Level_elabLevel___closed__3;
+static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__3;
 static lean_object* l_Lean_Elab_Level_elabLevel___closed__15;
 static lean_object* l_Lean_Elab_Level_elabLevel___closed__18;
 lean_object* l_Lean_throwError___rarg(lean_object*, lean_object*, lean_object*);
@@ -128,8 +128,8 @@ lean_object* l_Lean_Elab_Level_instAddMessageContextLevelElabM___boxed(lean_obje
 lean_object* l_ReaderT_read___at_Lean_Elab_Level_instMonadOptionsLevelElabM___spec__1(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Level_instMonadNameGeneratorLevelElabM___closed__1;
 static lean_object* l_Lean_Elab_Level_instMonadRefLevelElabM___closed__1;
+static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__4;
 lean_object* l___private_Lean_Elab_Level_0__Lean_Elab_Level_checkUniverseOffset___at_Lean_Elab_Level_elabLevel___spec__3___boxed(lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__4;
 lean_object* l_Lean_Level_ofNat(lean_object*);
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Level_elabLevel___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -736,7 +736,7 @@ lean_dec(x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__1() {
+static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -744,17 +744,17 @@ x_1 = lean_mk_string("maxUniverseOffset");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__2() {
+static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__1;
+x_2 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__3() {
+static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -762,7 +762,7 @@ x_1 = lean_mk_string("");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__4() {
+static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -770,13 +770,13 @@ x_1 = lean_mk_string("maximum universe level offset");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__5() {
+static lean_object* _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = lean_unsigned_to_nat(32u);
-x_2 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__3;
-x_3 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__4;
+x_2 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__3;
+x_3 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__4;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -784,12 +784,12 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212_(lean_object* x_1) {
+lean_object* l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__2;
-x_3 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__5;
+x_2 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__2;
+x_3 = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__5;
 x_4 = l_Lean_Option_register___at_Lean_initFn____x40_Lean_Util_RecDepth___hyg_4____spec__1(x_2, x_3, x_1);
 return x_4;
 }
@@ -3015,19 +3015,19 @@ l_Lean_Elab_Level_instMonadNameGeneratorLevelElabM___closed__5 = _init_l_Lean_El
 lean_mark_persistent(l_Lean_Elab_Level_instMonadNameGeneratorLevelElabM___closed__5);
 l_Lean_Elab_Level_instMonadNameGeneratorLevelElabM = _init_l_Lean_Elab_Level_instMonadNameGeneratorLevelElabM();
 lean_mark_persistent(l_Lean_Elab_Level_instMonadNameGeneratorLevelElabM);
-l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__1 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__1();
-lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__1);
-l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__2 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__2();
-lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__2);
-l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__3 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__3();
-lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__3);
-l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__4 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__4();
-lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__4);
-l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__5 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__5();
-lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212____closed__5);
+l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__1 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__1();
+lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__1);
+l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__2 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__2();
+lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__2);
+l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__3 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__3();
+lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__3);
+l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__4 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__4();
+lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__4);
+l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__5 = _init_l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__5();
+lean_mark_persistent(l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213____closed__5);
 l_Lean_Elab_Level_maxUniverseOffset___closed__1 = _init_l_Lean_Elab_Level_maxUniverseOffset___closed__1();
 lean_mark_persistent(l_Lean_Elab_Level_maxUniverseOffset___closed__1);
-res = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_212_(lean_io_mk_world());
+res = l_Lean_Elab_Level_initFn____x40_Lean_Elab_Level___hyg_213_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_Elab_Level_maxUniverseOffset = lean_io_result_get_value(res);
 lean_mark_persistent(l_Lean_Elab_Level_maxUniverseOffset);

stage0/stdlib/Lean/Elab/MatchAltView.c

@@ -0,0 +1,73 @@
+// Lean compiler output
+// Module: Lean.Elab.MatchAltView
+// Imports: Init Lean.Elab.Term
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* lean_mk_empty_array_with_capacity(lean_object*);
+static lean_object* l_Lean_Elab_Term_instInhabitedMatchAltView___closed__1;
+static lean_object* l_Lean_Elab_Term_instInhabitedMatchAltView___closed__2;
+lean_object* l_Lean_Elab_Term_instInhabitedMatchAltView;
+static lean_object* _init_l_Lean_Elab_Term_instInhabitedMatchAltView___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = lean_unsigned_to_nat(0u);
+x_2 = lean_mk_empty_array_with_capacity(x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Elab_Term_instInhabitedMatchAltView___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_Lean_Elab_Term_instInhabitedMatchAltView___closed__1;
+x_3 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+lean_ctor_set(x_3, 2, x_1);
+return x_3;
+}
+}
+static lean_object* _init_l_Lean_Elab_Term_instInhabitedMatchAltView() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Elab_Term_instInhabitedMatchAltView___closed__2;
+return x_1;
+}
+}
+lean_object* initialize_Init(lean_object*);
+lean_object* initialize_Lean_Elab_Term(lean_object*);
+static bool _G_initialized = false;
+lean_object* initialize_Lean_Elab_MatchAltView(lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Elab_Term(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+l_Lean_Elab_Term_instInhabitedMatchAltView___closed__1 = _init_l_Lean_Elab_Term_instInhabitedMatchAltView___closed__1();
+lean_mark_persistent(l_Lean_Elab_Term_instInhabitedMatchAltView___closed__1);
+l_Lean_Elab_Term_instInhabitedMatchAltView___closed__2 = _init_l_Lean_Elab_Term_instInhabitedMatchAltView___closed__2();
+lean_mark_persistent(l_Lean_Elab_Term_instInhabitedMatchAltView___closed__2);
+l_Lean_Elab_Term_instInhabitedMatchAltView = _init_l_Lean_Elab_Term_instInhabitedMatchAltView();
+lean_mark_persistent(l_Lean_Elab_Term_instInhabitedMatchAltView);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif