chore: update stage0

stage0/src/Init/Classical.lean

@@ -125,7 +125,7 @@ theorem byCases {p q : Prop} (hpq : p → q) (hnpq : ¬p → q) : q :=
 theorem byContradiction {p : Prop} (h : ¬p → False) : p :=
   Decidable.byContradiction (dec := propDecidable _) h
 
-macro "byCases" h:ident ":" e:term : tactic =>
+macro "by_cases" h:ident ":" e:term : tactic =>
   `(cases em $e:term with
     | inl $h:ident => _
     | inr $h:ident => _)

stage0/src/Init/Data/Array.lean

@@ -8,3 +8,4 @@ import Init.Data.Array.Basic
 import Init.Data.Array.QSort
 import Init.Data.Array.BinSearch
 import Init.Data.Array.InsertionSort
+import Init.Data.Array.DecidableEq

stage0/src/Init/Data/Array/Basic.lean

@@ -514,11 +514,7 @@ namespace Array
 @[specialize]
 def isEqvAux (a b : Array α) (hsz : a.size = b.size) (p : α → α → Bool) (i : Nat) : Bool :=
   if h : i < a.size then
-     let aidx : Fin a.size := ⟨i, h⟩;
-     let bidx : Fin b.size := ⟨i, hsz ▸ h⟩;
-     match p (a.get aidx) (b.get bidx) with
-     | true  => isEqvAux a b hsz p (i+1)
-     | false => false
+     p (a.get ⟨i, h⟩) (b.get ⟨i, hsz ▸ h⟩) && isEqvAux a b hsz p (i+1)
   else
     true
 termination_by _ => a.size - i

stage0/src/Init/Data/Array/DecidableEq.lean

@@ -0,0 +1,52 @@
+/-
+Copyright (c) 2022 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Init.Data.Array.Basic
+import Init.Classical
+
+namespace Array
+
+theorem eq_of_isEqvAux [DecidableEq α] (a b : Array α) (hsz : a.size = b.size) (i : Nat) (hi : i ≤ a.size) (heqv : Array.isEqvAux a b hsz (fun x y => x = y) i) : ∀ (j : Nat) (hl : i ≤ j) (hj : j < a.size), a.get ⟨j, hj⟩ = b.get ⟨j, hsz ▸ hj⟩ := by
+  by_cases h : i < a.size
+  . intro j low high
+    unfold Array.isEqvAux at heqv
+    simp [h] at heqv
+    have hind := eq_of_isEqvAux a b hsz (i+1) (Nat.succ_le_of_lt h) heqv.2
+    by_cases heq : i = j
+    . subst heq; exact heqv.1
+    . exact hind j (Nat.succ_le_of_lt (Nat.lt_of_le_and_ne low heq)) high
+  . intro j low high
+    have heq : i = a.size := Nat.le_antisymm hi (Nat.ge_of_not_lt h)
+    subst heq
+    exact absurd (Nat.lt_of_lt_of_le high low) (Nat.lt_irrefl j)
+termination_by _ => a.size - i
+
+theorem eq_of_isEqv [DecidableEq α] (a b : Array α) : Array.isEqv a b (fun x y => x = y) → a = b := by
+  simp [Array.isEqv]
+  split
+  case inr => intro; contradiction
+  case inl hsz =>
+   intro h
+   have aux := eq_of_isEqvAux a b hsz 0 (Nat.zero_le ..) h
+   exact ext a b hsz fun i h _ => aux i (Nat.zero_le ..) _
+
+theorem isEqvAux_self [DecidableEq α] (a : Array α) (i : Nat) : Array.isEqvAux a a rfl (fun x y => x = y) i = true := by
+  unfold Array.isEqvAux
+  split
+  case inl h => simp [h, isEqvAux_self a (i+1)]
+  case inr h => simp [h]
+termination_by _ => a.size - i
+
+theorem isEqv_self [DecidableEq α] (a : Array α) : Array.isEqv a a (fun x y => x = y) = true := by
+  simp [isEqv, isEqvAux_self]
+
+instance [DecidableEq α] : DecidableEq (Array α) :=
+  fun a b =>
+    match h:isEqv a b (fun a b => a = b) with
+    | true  => isTrue (eq_of_isEqv a b h)
+    | false => isFalse fun h' => by subst h'; rw [isEqv_self] at h; contradiction
+
+end Array

stage0/src/Init/Data/Nat/Basic.lean

@@ -306,6 +306,11 @@ theorem gt_of_not_le {n m : Nat} (h : ¬ n ≤ m) : n > m :=
   | Or.inl h₁ => h₁
   | Or.inr h₁ => absurd h₁ h
 
+theorem ge_of_not_lt {n m : Nat} (h : ¬ n < m) : n ≥ m :=
+  match Nat.lt_or_ge n m with
+  | Or.inl h₁ => absurd h₁ h
+  | Or.inr h₁ => h₁
+
 protected theorem add_le_add_left {n m : Nat} (h : n ≤ m) (k : Nat) : k + n ≤ k + m :=
   match le.dest h with
   | ⟨w, hw⟩ =>

stage0/src/Init/SimpLemmas.lean

@@ -117,9 +117,13 @@ theorem dite_congr {s : Decidable b} [Decidable c]
 @[simp] theorem Bool.false_or (b : Bool) : (false || b) = b  := by cases b <;> rfl
 @[simp] theorem Bool.true_or (b : Bool) : (true || b) = true := by cases b <;> rfl
 @[simp] theorem Bool.or_self (b : Bool) : (b || b) = b       := by cases b <;> rfl
+@[simp] theorem Bool.or_eq_true (a b : Bool) : ((a || b) = true) = (a = true ∨ b = true) := by cases a <;> cases b <;> decide
 
 @[simp] theorem Bool.and_false (b : Bool) : (b && false) = false := by cases b <;> rfl
 @[simp] theorem Bool.and_true (b : Bool) : (b && true) = b       := by cases b <;> rfl
 @[simp] theorem Bool.false_and (b : Bool) : (false && b) = false := by cases b <;> rfl
 @[simp] theorem Bool.true_and (b : Bool) : (true && b) = b       := by cases b <;> rfl
 @[simp] theorem Bool.and_self (b : Bool) : (b && b) = b          := by cases b <;> rfl
+@[simp] theorem Bool.and_eq_true (a b : Bool) : ((a && b) = true) = (a = true ∧ b = true) := by cases a <;> cases b <;> decide
+
+@[simp] theorem decide_eq_true_eq [Decidable p] : (decide p = true) = p := propext <| Iff.intro of_decide_eq_true decide_eq_true

stage0/src/Lean/Elab/AutoBound.lean

@@ -9,11 +9,17 @@ import Lean.Data.Options
 
 namespace Lean.Elab
 
-register_builtin_option autoBoundImplicitLocal : Bool := {
+register_builtin_option autoImplicit : Bool := {
     defValue := true
-    descr    := "Unbound local variables in declaration headers become implicit arguments if they are a lower case or greek letter followed by numeric digits. For example, `def f (x : Vector α n) : Vector α n :=` automatically introduces the implicit variables {α n}."
+    descr    := "Unbound local variables in declaration headers become implicit arguments. In \"relaxed\" mode (default), any atomic identifier is eligible, otherwise only a lower case or greek letter followed by numeric digits are eligible. For example, `def f (x : Vector α n) : Vector α n :=` automatically introduces the implicit variables {α n}."
   }
 
+register_builtin_option relaxedAutoImplicit : Bool := {
+    defValue := true
+    descr    := "When \"relaxed\" mode is enabled, any atomic nonempty identifier is eligible for auto bound implicit locals (see optin `autoBoundImplicitLocal`."
+  }
+
+
 private def isValidAutoBoundSuffix (s : String) : Bool :=
   s.toSubstring.drop 1 |>.all fun c => c.isDigit || isSubScriptAlnum c || c == '_' || c == '\''
 
@@ -31,14 +37,14 @@ When, we try again, a `x` with a new macro scope is created and this process kee
 Therefore, we do consider identifier with macro scopes anymore.
 -/
 
-def isValidAutoBoundImplicitName (n : Name) : Bool :=
+def isValidAutoBoundImplicitName (n : Name) (relaxed : Bool) : Bool :=
   match n with
-  | Name.str Name.anonymous s _ => s.length > 0 && (isGreek s[0] || s[0].isLower) && isValidAutoBoundSuffix s
+  | Name.str Name.anonymous s _ => s.length > 0 && (relaxed || ((isGreek s[0] || s[0].isLower) && isValidAutoBoundSuffix s))
   | _ => false
 
-def isValidAutoBoundLevelName (n : Name) : Bool :=
+def isValidAutoBoundLevelName (n : Name) (relaxed : Bool) : Bool :=
   match n with
-  | Name.str Name.anonymous s _ => s.length > 0 && s[0].isLower && isValidAutoBoundSuffix s
+  | Name.str Name.anonymous s _ => s.length > 0 && (relaxed || (s[0].isLower && isValidAutoBoundSuffix s))
   | _ => false
 
 end Lean.Elab

stage0/src/Lean/Elab/LetRec.lean

@@ -57,23 +57,11 @@ private def mkLetRecDeclView (letRec : Syntax) : TermElabM LetRecView := do
         if decl.isOfKind `Lean.Parser.Term.letIdDecl then
           pure decl[4]
         else
-          liftMacroM $ expandMatchAltsIntoMatch decl decl[3]
-      pure {
-        ref           := declId
-        attrs         := attrs
-        shortDeclName := shortDeclName
-        declName      := declName
-        binderIds     := binderIds
-        type          := type
-        mvar          := mvar
-        valStx        := valStx
-        : LetRecDeclView }
+          liftMacroM <| expandMatchAltsIntoMatch decl decl[3]
+      pure { ref := declId, attrs, shortDeclName, declName, binderIds, type, mvar, valStx : LetRecDeclView }
     else
       throwUnsupportedSyntax
-  pure {
-    decls := decls,
-    body  := letRec[3]
-  }
+  return { decls, body := letRec[3] }
 
 private partial def withAuxLocalDecls {α} (views : Array LetRecDeclView) (k : Array Expr → TermElabM α) : TermElabM α :=
   let rec loop (i : Nat) (fvars : Array Expr) : TermElabM α :=
@@ -101,17 +89,17 @@ private def registerLetRecsToLift (views : Array LetRecDeclView) (fvars : Array
       withRef view.ref do
         throwError "'{view.declName}' has already been declared"
   let lctx ← getLCtx
-  let localInsts ← getLocalInstances
+  let localInstances ← getLocalInstances
   let toLift := views.mapIdx fun i view => {
-    ref            := view.ref,
-    fvarId         := fvars[i].fvarId!,
-    attrs          := view.attrs,
-    shortDeclName  := view.shortDeclName,
-    declName       := view.declName,
-    lctx           := lctx,
-    localInstances := localInsts,
-    type           := view.type,
-    val            := values[i],
+    ref            := view.ref
+    fvarId         := fvars[i].fvarId!
+    attrs          := view.attrs
+    shortDeclName  := view.shortDeclName
+    declName       := view.declName
+    lctx
+    localInstances
+    type           := view.type
+    val            := values[i]
     mvarId         := view.mvar.mvarId!
     : LetRecToLift }
   modify fun s => { s with letRecsToLift := toLift.toList ++ s.letRecsToLift }
@@ -125,6 +113,6 @@ private def registerLetRecsToLift (views : Array LetRecDeclView) (fvars : Array
     let body ← elabTermEnsuringType view.body expectedType?
     registerLetRecsToLift view.decls fvars values
     let mvars := view.decls.map (·.mvar)
-    pure $ mkAppN (← mkLambdaFVars fvars body) mvars
+    return mkAppN (← mkLambdaFVars fvars body) mvars
 
 end Lean.Elab.Term

stage0/src/Lean/Elab/Level.lean

@@ -72,7 +72,7 @@ partial def elabLevel (stx : Syntax) : LevelElabM Level := withRef stx do
   else if kind == identKind then
     let paramName := stx.getId
     unless (← get).levelNames.contains paramName do
-      if (← read).autoBoundImplicit && isValidAutoBoundLevelName paramName then
+      if (← read).autoBoundImplicit && isValidAutoBoundLevelName paramName (relaxedAutoImplicit.get (← read).options) then
         modify fun s => { s with levelNames := paramName :: s.levelNames }
       else
         throwError "unknown universe level '{paramName}'"

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

@@ -170,4 +170,16 @@ def addAndCompilePartialRec (preDefs : Array PreDefinition) : TermElabM Unit :=
           | _ => none
         modifiers := {} }
 
+private def containsRecFn (recFnName : Name) (e : Expr) : Bool :=
+  (e.find? fun e => e.isConstOf recFnName).isSome
+
+def ensureNoRecFn (recFnName : Name) (e : Expr) : MetaM Expr := do
+  if containsRecFn recFnName e then
+    Meta.forEachExpr e fun e => do
+      if e.isAppOf recFnName then
+        throwError "unexpected occurrence of recursive application{indentExpr e}"
+    pure e
+  else
+    pure e
+
 end Lean.Elab

stage0/src/Lean/Elab/PreDefinition/Eqns.lean

@@ -125,15 +125,17 @@ private def saveEqn (mvarId : MVarId) : StateRefT (Array Expr) MetaM Unit := wit
       return collectFVars fvarState (← instantiateMVars decl.type)
     else
       return fvarState
+  let mut fvarSet := fvarState.fvarSet
   let mut fvarIds ← sortFVarIds <| fvarState.fvarSet.toArray
-  -- Include propositions that are not in fvarState.fvarSet, and only contains variables in
+  -- Include propositions that are not in fvarState.fvarSet, and only contains variables in fvarSet
   for decl in (← getLCtx) do
-    unless fvarState.fvarSet.contains decl.fvarId do
+    unless fvarSet.contains decl.fvarId do
       if (← isProp decl.type) then
         let type ← instantiateMVars decl.type
-        let missing? := type.find? fun e => e.isFVar && !fvarState.fvarSet.contains e.fvarId!
+        let missing? := type.find? fun e => e.isFVar && !fvarSet.contains e.fvarId!
         if missing?.isNone then
           fvarIds := fvarIds.push decl.fvarId
+          fvarSet := fvarSet.insert decl.fvarId
   let type ← mkForallFVars (fvarIds.map mkFVar) target
   let type ← simpEqnType type
   modify (·.push type)
@@ -143,6 +145,7 @@ partial def mkEqnTypes (declNames : Array Name) (mvarId : MVarId) : MetaM (Array
   return eqnTypes
 where
   go (mvarId : MVarId) : ReaderT Context (StateRefT (Array Expr) MetaM) Unit := do
+    trace[Elab.definition.structural.eqns] "mkEqnTypes step\n{MessageData.ofGoal mvarId}"
     if !(← keepGoing mvarId) then
       saveEqn mvarId
     else if let some mvarId ← expandRHS? mvarId then
@@ -151,7 +154,7 @@ where
       go mvarId
     else if let some mvarId ← simpMatch? mvarId then
       go mvarId
-    else if let some mvarIds ← splitTarget? mvarId then
+    else if let some mvarIds ← splitTarget? mvarId (splitIte := false) then
       mvarIds.forM go
     else
       saveEqn mvarId
@@ -236,7 +239,7 @@ partial def mkUnfoldProof (declName : Name) (mvarId : MVarId) : MetaM Unit := do
       go mvarId
     else if let some mvarId ← simpMatch? mvarId then
       go mvarId
-    else if let some mvarIds ← splitTarget? mvarId then
+    else if let some mvarIds ← splitTarget? mvarId (splitIte := false) then
       mvarIds.forM go
     else
      throwError "failed to generate unfold theorem for '{declName}'\n{MessageData.ofGoal mvarId}"

stage0/src/Lean/Elab/PreDefinition/Main.lean

@@ -63,10 +63,23 @@ private def ensureNoUnassignedMVarsAtPreDef (preDef : PreDefinition) : TermElabM
   else
     return preDef
 
+/--
+  Letrec declarations produce terms of the form `(fun .. => ..) d` where `d` is a (partial) application of an auxiliary declaration for a letrec declaration.
+  This method beta-reduces them to make sure they can be eliminated by the well-founded recursion module. -/
+private def betaReduceLetRecApps (preDefs : Array PreDefinition) : MetaM (Array PreDefinition) :=
+  preDefs.mapM fun preDef => do
+    let value ← transform preDef.value fun e => do
+      if e.isApp && e.getAppFn.isLambda && e.getAppArgs.all fun arg => arg.getAppFn.isConst && preDefs.any fun preDef => preDef.declName == arg.getAppFn.constName! then
+        return TransformStep.visit e.headBeta
+      else
+        return TransformStep.visit e
+    return { preDef with value }
+
 def addPreDefinitions (preDefs : Array PreDefinition) (hints : TerminationHints) : TermElabM Unit := withLCtx {} {} do
   for preDef in preDefs do
     trace[Elab.definition.body] "{preDef.declName} : {preDef.type} :=\n{preDef.value}"
   let preDefs ← preDefs.mapM ensureNoUnassignedMVarsAtPreDef
+  let preDefs ← betaReduceLetRecApps preDefs
   let cliques := partitionPreDefs preDefs
   let mut terminationBy ← liftMacroM <| WF.expandTerminationBy hints.terminationBy? (cliques.map fun ds => ds.map (·.declName))
   let mut decreasingBy  ← liftMacroM <| WF.expandTerminationHint hints.decreasingBy? (cliques.map fun ds => ds.map (·.declName))

stage0/src/Lean/Elab/PreDefinition/Structural/BRecOn.lean

@@ -5,6 +5,7 @@ Authors: Leonardo de Moura
 -/
 import Lean.Meta.Match.Match
 import Lean.Elab.RecAppSyntax
+import Lean.Elab.PreDefinition.Basic
 import Lean.Elab.PreDefinition.Structural.Basic
 
 namespace Lean.Elab.Structural
@@ -80,6 +81,21 @@ private partial def toBelow (below : Expr) (numIndParams : Nat) (recArg : Expr)
   withBelowDict below numIndParams fun C belowDict =>
     toBelowAux C belowDict recArg below
 
+/--
+  This method is used after `matcherApp.addArg arg` to check whether the new type of `arg` has been "refined/modified"
+  in at least one alternative.
+-/
+def refinedArgType (matcherApp : MatcherApp) (arg : Expr) : MetaM Bool := do
+  let argType ← inferType arg
+  (Array.zip matcherApp.alts matcherApp.altNumParams).anyM fun (alt, numParams) =>
+    lambdaTelescope alt fun xs altBody => do
+      if xs.size >= numParams then
+        let refinedArg := xs[numParams - 1]
+        trace[Meta.debug] "refinedArgType {argType} =?= {← inferType refinedArg}"
+        return !(← isDefEq (← inferType refinedArg) argType)
+      else
+        return false
+
 private partial def replaceRecApps (recFnName : Name) (recArgInfo : RecArgInfo) (below : Expr) (e : Expr) : M Expr :=
   let rec loop (below : Expr) (e : Expr) : M Expr := do
     match e with
@@ -146,14 +162,17 @@ private partial def replaceRecApps (recFnName : Name) (recArgInfo : RecArgInfo)
              this may generate weird error messages, when it doesn't work. -/
           trace[Elab.definition.structural] "below before matcherApp.addArg: {below} : {← inferType below}"
           let matcherApp ← mapError (matcherApp.addArg below) (fun msg => "failed to add `below` argument to 'matcher' application" ++ indentD msg)
-          let altsNew ← (Array.zip matcherApp.alts matcherApp.altNumParams).mapM fun (alt, numParams) =>
-            lambdaTelescope alt fun xs altBody => do
-              trace[Elab.definition.structural] "altNumParams: {numParams}, xs: {xs}"
-              unless xs.size >= numParams do
-                throwError "unexpected matcher application alternative{indentExpr alt}\nat application{indentExpr e}"
-              let belowForAlt := xs[numParams - 1]
-              mkLambdaFVars xs (← loop belowForAlt altBody)
-          pure { matcherApp with alts := altsNew }.toExpr
+          if !(← refinedArgType matcherApp below) then
+            processApp e
+          else
+            let altsNew ← (Array.zip matcherApp.alts matcherApp.altNumParams).mapM fun (alt, numParams) =>
+              lambdaTelescope alt fun xs altBody => do
+                trace[Elab.definition.structural] "altNumParams: {numParams}, xs: {xs}"
+                unless xs.size >= numParams do
+                  throwError "unexpected matcher application alternative{indentExpr alt}\nat application{indentExpr e}"
+                let belowForAlt := xs[numParams - 1]
+                mkLambdaFVars xs (← loop belowForAlt altBody)
+            pure { matcherApp with alts := altsNew }.toExpr
       | none => processApp e
     | e => ensureNoRecFn recFnName e
   loop below e

stage0/src/Lean/Elab/PreDefinition/Structural/Basic.lean

@@ -54,16 +54,4 @@ def recArgHasLooseBVarsAt (recFnName : Name) (recArgPos : Nat) (e : Expr) : Bool
      e.isAppOf recFnName && e.getAppNumArgs > recArgPos && (e.getArg! recArgPos).hasLooseBVars
   app?.isSome
 
-private def containsRecFn (recFnName : Name) (e : Expr) : Bool :=
-  (e.find? fun e => e.isConstOf recFnName).isSome
-
-def ensureNoRecFn (recFnName : Name) (e : Expr) : MetaM Expr := do
-  if containsRecFn recFnName e then
-    Meta.forEachExpr e fun e => do
-      if e.isAppOf recFnName then
-        throwError "unexpected occurrence of recursive application{indentExpr e}"
-    pure e
-  else
-    pure e
-
 end Lean.Elab.Structural

stage0/src/Lean/Elab/PreDefinition/Structural/Eqns.lean

@@ -5,6 +5,7 @@ Authors: Leonardo de Moura
 -/
 import Lean.Meta.Eqns
 import Lean.Meta.Tactic.Split
+import Lean.Meta.Tactic.Simp.Main
 import Lean.Meta.Tactic.Apply
 import Lean.Elab.PreDefinition.Basic
 import Lean.Elab.PreDefinition.Eqns
@@ -41,12 +42,18 @@ where
       go mvarId
     else if let some mvarId ← whnfReducibleLHS? mvarId then
       go mvarId
-    else if let some mvarId ← deltaRHS? mvarId declName then
-      go mvarId
-    else if let some mvarIds ← casesOnStuckLHS? mvarId then
-      mvarIds.forM go
-    else
-      throwError "failed to generate equational theorem for '{declName}'\n{MessageData.ofGoal mvarId}"
+    else match (← simpTargetStar mvarId {}) with
+      | TacticResultCNM.closed => return ()
+      | TacticResultCNM.modified mvarId => go mvarId
+      | TacticResultCNM.noChange =>
+        if let some mvarId ← deltaRHS? mvarId declName then
+          go mvarId
+        else if let some mvarIds ← casesOnStuckLHS? mvarId then
+          mvarIds.forM go
+        else if let some mvarIds ← splitTarget? mvarId then
+          mvarIds.forM go
+        else
+          throwError "failed to generate equational theorem for '{declName}'\n{MessageData.ofGoal mvarId}"
 
 def mkEqns (info : EqnInfo) : MetaM (Array Name) :=
   withOptions (tactic.hygienic.set . false) do

stage0/src/Lean/Elab/PreDefinition/WF/Eqns.lean

@@ -51,10 +51,16 @@ where
       go mvarId
     else if let some mvarId ← whnfReducibleLHS? mvarId then
       go mvarId
-    else if let some mvarIds ← casesOnStuckLHS? mvarId then
-      mvarIds.forM go
-    else
-      throwError "failed to generate equational theorem for '{declName}'\n{MessageData.ofGoal mvarId}"
+    else match (← simpTargetStar mvarId {}) with
+      | TacticResultCNM.closed => return ()
+      | TacticResultCNM.modified mvarId => go mvarId
+      | TacticResultCNM.noChange =>
+        if let some mvarIds ← casesOnStuckLHS? mvarId then
+          mvarIds.forM go
+        else if let some mvarIds ← splitTarget? mvarId then
+          mvarIds.forM go
+        else
+          throwError "failed to generate equational theorem for '{declName}'\n{MessageData.ofGoal mvarId}"
 
 def mkEqns (declName : Name) (info : EqnInfo) : MetaM (Array Name) :=
   withOptions (tactic.hygienic.set . false) do

stage0/src/Lean/Elab/PreDefinition/WF/Fix.lean

@@ -10,6 +10,7 @@ import Lean.Elab.Tactic.Basic
 import Lean.Elab.RecAppSyntax
 import Lean.Elab.PreDefinition.Basic
 import Lean.Elab.PreDefinition.Structural.Basic
+import Lean.Elab.PreDefinition.Structural.BRecOn
 
 namespace Lean.Elab.WF
 open Meta
@@ -62,15 +63,18 @@ private partial def replaceRecApps (recFnName : Name) (decrTactic? : Option Synt
           processApp e
         else
           let matcherApp ← mapError (matcherApp.addArg F) (fun msg => "failed to add functional argument to 'matcher' application" ++ indentD msg)
-          let altsNew ← (Array.zip matcherApp.alts matcherApp.altNumParams).mapM fun (alt, numParams) =>
-            lambdaTelescope alt fun xs altBody => do
-              unless xs.size >= numParams do
-                throwError "unexpected matcher application alternative{indentExpr alt}\nat application{indentExpr e}"
-              let FAlt := xs[numParams - 1]
-              mkLambdaFVars xs (← loop FAlt altBody)
-          return { matcherApp with alts := altsNew, discrs := (← matcherApp.discrs.mapM (loop F)) }.toExpr
+          if !(← Structural.refinedArgType matcherApp F) then
+            processApp e
+          else
+            let altsNew ← (Array.zip matcherApp.alts matcherApp.altNumParams).mapM fun (alt, numParams) =>
+              lambdaTelescope alt fun xs altBody => do
+                unless xs.size >= numParams do
+                  throwError "unexpected matcher application alternative{indentExpr alt}\nat application{indentExpr e}"
+                let FAlt := xs[numParams - 1]
+                mkLambdaFVars xs (← loop FAlt altBody)
+            return { matcherApp with alts := altsNew, discrs := (← matcherApp.discrs.mapM (loop F)) }.toExpr
       | none => processApp e
-    | e => Structural.ensureNoRecFn recFnName e
+    | e => ensureNoRecFn recFnName e
   loop F e
 
 /-- Refine `F` over `Sum.casesOn` -/

stage0/src/Lean/Elab/PreDefinition/WF/PackDomain.lean

@@ -57,7 +57,7 @@ private partial def mkPSigmaCasesOn (y : Expr) (codomain : Expr) (xs : Array Exp
   Convert the given pre-definitions into unary functions.
   We "pack" the arguments using `PSigma`.
 -/
-def packDomain (preDefs : Array PreDefinition) : MetaM (Array PreDefinition) := do
+partial def packDomain (preDefs : Array PreDefinition) : MetaM (Array PreDefinition) := do
   let mut preDefsNew := #[]
   let mut arities := #[]
   let mut modified := false
@@ -86,16 +86,6 @@ def packDomain (preDefs : Array PreDefinition) : MetaM (Array PreDefinition) :=
     preDefsNew := preDefsNew.push preDefNew
   if !modified then
     return preDefs
-  /- Return `some i` if `e` is a `preDefs[i]` application -/
-  let isAppOfPreDef? (e : Expr) : OptionM Nat := do
-    let f := e.getAppFn
-    guard f.isConst
-    preDefs.findIdx? (·.declName == f.constName!)
-  /- Return `some i` if `e` is a `preDefs[i]` application with `arities[i]` arguments.  -/
-  let isTargetApp? (e : Expr) : OptionM Nat := do
-    let i ← isAppOfPreDef? e
-    guard (e.getAppNumArgs == arities[i])
-    return i
   -- Update values
   for i in [:preDefs.size] do
     let preDef := preDefs[i]
@@ -105,20 +95,67 @@ def packDomain (preDefs : Array PreDefinition) : MetaM (Array PreDefinition) :=
       forallBoundedTelescope preDefNew.type (some 1) fun y codomain => do
         let y := y[0]
         let newBody ← mkPSigmaCasesOn y codomain xs body
-        let visit (e : Expr) : MetaM TransformStep := do
-          if let some idx := isTargetApp? e |>.run then
-            let f := e.getAppFn
-            let fNew := mkConst preDefsNew[idx].declName f.constLevels!
-            let Expr.forallE _ d .. ← inferType fNew | unreachable!
-            let argNew ← mkUnaryArg d e.getAppArgs
-            return TransformStep.done <| mkApp fNew argNew
-          else
-            return TransformStep.done e
-        mkLambdaFVars #[y] (← transform newBody (post := visit))
-    if let some bad := valueNew.find? fun e => (isAppOfPreDef? e).isSome && e.getAppNumArgs > 1 then
+        mkLambdaFVars #[y] (← packApplications newBody arities preDefsNew)
+    let isBad (e : Expr) : Bool :=
+      match isAppOfPreDef? e with
+      | none   => false
+      | some i => e.getAppNumArgs > 1 || preDefsNew[i].declName != preDefs[i].declName
+    if let some bad := valueNew.find? isBad then
       if let some i := isAppOfPreDef? bad then
         throwErrorAt preDef.ref "well-founded recursion cannot be used, function '{preDef.declName}' contains application of function '{preDefs[i].declName}' with #{bad.getAppNumArgs} argument(s), but function has arity {arities[i]}"
     preDefsNew := preDefsNew.set! i { preDefNew with value := valueNew }
   return preDefsNew
+where
+  /-- Return `some i` if `e` is a `preDefs[i]` application -/
+  isAppOfPreDef? (e : Expr) : OptionM Nat := do
+    let f := e.getAppFn
+    guard f.isConst
+    preDefs.findIdx? (·.declName == f.constName!)
+
+  packApplications (e : Expr) (arities : Array Nat) (preDefsNew : Array PreDefinition) : MetaM Expr := do
+    let pack (e : Expr) (funIdx : Nat) : MetaM Expr := do
+      let f := e.getAppFn
+      let fNew := mkConst preDefsNew[funIdx].declName f.constLevels!
+      let Expr.forallE _ d .. ← inferType fNew | unreachable!
+      let argNew ← mkUnaryArg d e.getAppArgs
+      return mkApp fNew argNew
+    let rec
+      visit (e : Expr) : MetaM Expr := do
+        match e with
+        | Expr.lam ..          => lambdaTelescope e fun xs b => do mkLambdaFVars (usedLetOnly := false) xs (← visit b)
+        | Expr.letE n t v b _  => withLetDecl n t (← visit v) fun x => do mkLambdaFVars (usedLetOnly := false) #[x] (← visit (b.instantiate1 x))
+        | Expr.forallE ..      => forallTelescope e fun xs b => do mkForallFVars (usedLetOnly := false) xs (← visit b)
+        | Expr.proj n i s ..   => return mkProj n i (← visit s)
+        | Expr.mdata d b _     => return mkMData d (← visit b)
+        | Expr.app ..          => visitApp e
+        | Expr.const ..        => visitApp e
+        | e                    => return e,
+      visitApp (e : Expr) : MetaM Expr := e.withApp fun f args => do
+        let args ← args.mapM visit
+        if let some funIdx := isAppOfPreDef? f then
+          let numArgs := args.size
+          let arity   := arities[funIdx]
+          if numArgs < arity then
+            -- Partial application
+            let extra := arity - numArgs
+            withDefault do forallBoundedTelescope (← inferType e) extra fun xs _ => do
+              if xs.size != extra then
+                return (mkAppN f args) -- It will fail later
+              else
+                mkLambdaFVars xs (← pack (mkAppN (mkAppN f args) xs) funIdx)
+          else if numArgs > arity then
+            -- Over application
+            let r ← pack (mkAppN f args[:arity]) funIdx
+            let rType ← inferType r
+            -- Make sure the new auxiliary definition has only one argument.
+            withLetDecl (← mkFreshUserName `aux) rType r fun aux =>
+              mkLetFVars #[aux] (mkAppN aux args[arity:])
+          else
+            pack (mkAppN f args) funIdx
+        else if args.isEmpty then
+          return f
+        else
+          return mkAppN (← visit f) args
+    visit e
 
 end Lean.Elab.WF

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

@@ -162,15 +162,6 @@ where
     else
       Term.elabCDotFunctionAlias? simpArgTerm
 
--- TODO: move?
-private def getPropHyps : MetaM (Array FVarId) := do
-  let mut result := #[]
-  for localDecl in (← getLCtx) do
-    unless localDecl.isAuxDecl do
-      if (← isProp localDecl.type) then
-        result := result.push localDecl.fvarId
-  return result
-
 structure MkSimpContextResult where
   ctx              : Simp.Context
   dischargeWrapper : Simp.DischargeWrapper

stage0/src/Lean/Elab/Term.lean

@@ -1297,7 +1297,7 @@ def elabType (stx : Syntax) : TermElabM Expr := do
   Enable auto-bound implicits, and execute `k` while catching auto bound implicit exceptions. When an exception is caught,
   a new local declaration is created, registered, and `k` is tried to be executed again. -/
 partial def withAutoBoundImplicit (k : TermElabM α) : TermElabM α := do
-  let flag := autoBoundImplicitLocal.get (← getOptions)
+  let flag := autoImplicit.get (← getOptions)
   if flag then
     withReader (fun ctx => { ctx with autoBoundImplicit := flag, autoBoundImplicits := {} }) do
       let rec loop (s : SavedState) : TermElabM α := do
@@ -1418,7 +1418,7 @@ def resolveName (stx : Syntax) (n : Name) (preresolved : List (Name × List Stri
     throw ex
 where process (candidates : List (Name × List String)) : TermElabM (List (Expr × List String)) := do
   if candidates.isEmpty then
-    if (← read).autoBoundImplicit && isValidAutoBoundImplicitName n then
+    if (← read).autoBoundImplicit && isValidAutoBoundImplicitName n (relaxedAutoImplicit.get (← getOptions)) then
       throwAutoBoundImplicitLocal n
     else
       throwError "unknown identifier '{Lean.mkConst n}'"

stage0/src/Lean/Expr.lean

@@ -841,46 +841,59 @@ private partial def mkAppRevRangeAux (revArgs : Array Expr) (start : Nat) (b : E
 def mkAppRevRange (f : Expr) (beginIdx endIdx : Nat) (revArgs : Array Expr) : Expr :=
   mkAppRevRangeAux revArgs beginIdx f endIdx
 
-private def betaRevAux (revArgs : Array Expr) (sz : Nat) : Expr → Nat → Expr
-  | Expr.lam _ _ b _, i =>
-    if i + 1 < sz then
-      betaRevAux revArgs sz b (i+1)
-    else
-      let n := sz - (i + 1)
-      mkAppRevRange (b.instantiateRange n sz revArgs) 0 n revArgs
-  | Expr.mdata _ b _, i => betaRevAux revArgs sz b i
-  | b,                i =>
-    let n := sz - i
-    mkAppRevRange (b.instantiateRange n sz revArgs) 0 n revArgs
+/--
+  If `f` is a lambda expression, than "beta-reduce" it using `revArgs`.
+  This function is often used with `getAppRev` or `withAppRev`.
+  Examples:
+  - `betaRev (fun x y => t x y) #[]` ==> `fun x y => t x y`
+  - `betaRev (fun x y => t x y) #[a]` ==> `fun y => t a y`
+  - `betaRev (fun x y => t x y) #[a, b]` ==> t b a`
+  - `betaRev (fun x y => t x y) #[a, b, c, d]` ==> t d c b a`
+  Suppose `t` is `(fun x y => t x y) a b c d`, then
+  `args := t.getAppRev` is `#[d, c, b, a]`,
+  and `betaRev (fun x y => t x y) #[d, c, b, a]` is `t a b c d`.
 
-/-- If `f` is a lambda expression, than "beta-reduce" it using `revArgs`.
-    This function is often used with `getAppRev` or `withAppRev`.
-    Examples:
-    - `betaRev (fun x y => t x y) #[]` ==> `fun x y => t x y`
-    - `betaRev (fun x y => t x y) #[a]` ==> `fun y => t a y`
-    - `betaRev (fun x y => t x y) #[a, b]` ==> t b a`
-    - `betaRev (fun x y => t x y) #[a, b, c, d]` ==> t d c b a`
-    Suppose `t` is `(fun x y => t x y) a b c d`, then
-    `args := t.getAppRev` is `#[d, c, b, a]`,
-    and `betaRev (fun x y => t x y) #[d, c, b, a]` is `t a b c d`. -/
-def betaRev (f : Expr) (revArgs : Array Expr) : Expr :=
+  If `useZeta` is true, the function also performs zeta-reduction to create further
+  opportunities for beta reduction.
+-/
+partial def betaRev (f : Expr) (revArgs : Array Expr) (useZeta := false) : Expr :=
   if revArgs.size == 0 then f
-  else betaRevAux revArgs revArgs.size f 0
+  else
+    let sz := revArgs.size
+    let rec go : Expr → Nat → Expr
+      | Expr.lam _ _ b _, i =>
+        if i + 1 < sz then
+          go b (i+1)
+        else
+          let n := sz - (i + 1)
+          mkAppRevRange (b.instantiateRange n sz revArgs) 0 n revArgs
+      | e@(Expr.letE _ _ v b _), i =>
+        if useZeta && i < sz then
+          go (b.instantiate1 v) i
+        else
+          let n := sz - i
+          mkAppRevRange (e.instantiateRange n sz revArgs) 0 n revArgs
+      | Expr.mdata _ b _, i => go b i
+      | b,                i =>
+        let n := sz - i
+        mkAppRevRange (b.instantiateRange n sz revArgs) 0 n revArgs
+    go f 0
 
 def beta (f : Expr) (args : Array Expr) : Expr :=
   betaRev f args.reverse
 
-def isHeadBetaTargetFn : Expr → Bool
-  | Expr.lam _ _ _ _ => true
-  | Expr.mdata _ b _ => isHeadBetaTargetFn b
-  | _                => false
+def isHeadBetaTargetFn (useZeta : Bool) : Expr → Bool
+  | Expr.lam ..         => true
+  | Expr.letE _ _ _ b _ => useZeta && isHeadBetaTargetFn useZeta b
+  | Expr.mdata _ b _    => isHeadBetaTargetFn useZeta b
+  | _                   => false
 
 def headBeta (e : Expr) : Expr :=
   let f := e.getAppFn
-  if f.isHeadBetaTargetFn then betaRev f e.getAppRevArgs else e
+  if f.isHeadBetaTargetFn false then betaRev f e.getAppRevArgs else e
 
-def isHeadBetaTarget (e : Expr) : Bool :=
-  e.getAppFn.isHeadBetaTargetFn
+def isHeadBetaTarget (e : Expr) (useZeta := false) : Bool :=
+  e.getAppFn.isHeadBetaTargetFn useZeta
 
 private def etaExpandedBody : Expr → Nat → Nat → Option Expr
   | app f (bvar j _) _, n+1, i => if j == i then etaExpandedBody f n (i+1) else none

stage0/src/Lean/Meta/Basic.lean

@@ -1295,6 +1295,17 @@ abbrev isDefEqGuarded (t s : Expr) : MetaM Bool :=
 def isDefEqNoConstantApprox (t s : Expr) : MetaM Bool :=
   approxDefEq <| isDefEq t s
 
+/--
+  Eta expand the given expression.
+  Example:
+  ```
+  etaExpand (mkConst `Nat.add)
+  ```
+  produces `fun x y => Nat.add x y`
+-/
+def etaExpand (e : Expr) : MetaM Expr :=
+  withDefault do forallTelescopeReducing (← inferType e) fun xs _ => mkLambdaFVars xs (mkAppN e xs)
+
 end Meta
 
 builtin_initialize

stage0/src/Lean/Meta/CongrTheorems.lean

@@ -160,12 +160,44 @@ private def hasCastLike (kinds : Array CongrArgKind) : Bool :=
 private def withNext (type : Expr) (k : Expr → Expr → MetaM α) : MetaM α := do
   forallBoundedTelescope type (some 1) fun xs type => k xs[0] type
 
+/--
+  Test whether we should use `subsingletonInst` kind for instances which depend on `eq`.
+  (Otherwise `fixKindsForDependencies`will downgrade them to Fixed -/
+private def shouldUseSubsingletonInst (info : FunInfo) (kinds : Array CongrArgKind) (i : Nat) : Bool := Id.run do
+  if info.paramInfo[i].isDecInst then
+    for j in info.paramInfo[i].backDeps do
+      if kinds[j] matches CongrArgKind.eq then
+        return true
+  return false
+
+def getCongrSimpKinds (info : FunInfo) : Array CongrArgKind := Id.run do
+  /- The default `CongrArgKind` is `eq`, which allows `simp` to rewrite this
+     argument. However, if there are references from `i` to `j`, we cannot
+     rewrite both `i` and `j`. So we must change the `CongrArgKind` at
+     either `i` or `j`. In principle, if there is a dependency with `i`
+     appearing after `j`, then we set `j` to `fixed` (or `cast`). But there is
+     an optimization: if `i` is a subsingleton, we can fix it instead of
+     `j`, since all subsingletons are equal anyway. The fixing happens in
+      two loops: one for the special cases, and one for the general case. -/
+  let mut result := #[]
+  for i in [:info.paramInfo.size] do
+    if info.resultDeps.contains i then
+      result := result.push CongrArgKind.fixed
+    else if info.paramInfo[i].isProp then
+      result := result.push CongrArgKind.cast
+    else if info.paramInfo[i].isInstImplicit then
+      if shouldUseSubsingletonInst info result i then
+        result := result.push CongrArgKind.subsingletonInst
+      else
+        result := result.push CongrArgKind.fixed
+    else
+      result := result.push CongrArgKind.eq
+  return fixKindsForDependencies info result
+
 /--
   Create a congruence theorem that is useful for the simplifier.
 -/
-partial def mkCongrSimpWithArity? (f : Expr) (numArgs : Nat) : MetaM (Option CongrTheorem) := do
-  let info ← getFunInfo f
-  let kinds := getKinds info
+partial def mkCongrSimpCore? (f : Expr) (info : FunInfo) (kinds : Array CongrArgKind) : MetaM (Option CongrTheorem) := do
   if let some result ← mk? f info kinds then
     return some result
   else if hasCastLike kinds then
@@ -246,41 +278,8 @@ where
             mkLambdaFVars #[lhs, rhs] (← mkEqNDRec motive proofSub heq)
      go 0 type
 
-  getKinds (info : FunInfo) : Array CongrArgKind := Id.run do
-    /- The default `CongrArgKind` is `eq`, which allows `simp` to rewrite this
-       argument. However, if there are references from `i` to `j`, we cannot
-       rewrite both `i` and `j`. So we must change the `CongrArgKind` at
-       either `i` or `j`. In principle, if there is a dependency with `i`
-       appearing after `j`, then we set `j` to `fixed` (or `cast`). But there is
-       an optimization: if `i` is a subsingleton, we can fix it instead of
-       `j`, since all subsingletons are equal anyway. The fixing happens in
-        two loops: one for the special cases, and one for the general case. -/
-    let mut result := #[]
-    for i in [:info.paramInfo.size] do
-      if info.resultDeps.contains i then
-        result := result.push CongrArgKind.fixed
-      else if info.paramInfo[i].isProp then
-        result := result.push CongrArgKind.cast
-      else if info.paramInfo[i].isInstImplicit then
-        if shouldUseSubsingletonInst info result i then
-          result := result.push CongrArgKind.subsingletonInst
-        else
-          result := result.push CongrArgKind.fixed
-      else
-        result := result.push CongrArgKind.eq
-    return fixKindsForDependencies info result
-
-  /--
-    Test whether we should use `subsingletonInst` kind for instances which depend on `eq`.
-    (Otherwise `fixKindsForDependencies`will downgrade them to Fixed -/
-  shouldUseSubsingletonInst (info : FunInfo) (kinds : Array CongrArgKind) (i : Nat) : Bool := Id.run do
-    if info.paramInfo[i].isDecInst then
-      for j in info.paramInfo[i].backDeps do
-        if kinds[j] matches CongrArgKind.eq then
-          return true
-    return false
-
 def mkCongrSimp? (f : Expr) : MetaM (Option CongrTheorem) := do
-  mkCongrSimpWithArity? f (← getFunInfo f).getArity
+  let info ← getFunInfo f
+  mkCongrSimpCore? f info (getCongrSimpKinds info)
 
 end Lean.Meta

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

@@ -21,6 +21,19 @@ structure Contradiction.Config where
      This kind of hypotheses appear when proving conditional equation theorems for match expressions. -/
   genDiseq : Bool := false
 
+/--
+  Try to close the current goal by looking for a proof of `False` nested in a `False.Elim` application in the target.
+  Return `true` iff the goal has been closed.
+-/
+private def nestedFalseElim (mvarId : MVarId) : MetaM Bool := do
+  let target ← getMVarType mvarId
+  if let some falseElim := target.find? fun e => e.isAppOfArity ``False.elim 2 && !e.appArg!.hasLooseBVars then
+    let falseProof := falseElim.appArg!
+    assignExprMVar mvarId (← mkFalseElim (← getMVarType mvarId) falseProof)
+    return true
+  else
+    return false
+
 -- We only consider inductives with no constructors and indexed families
 private def isElimEmptyInductiveCandidate (fvarId : FVarId) : MetaM Bool := do
   let localDecl ← getLocalDecl fvarId
@@ -106,6 +119,8 @@ private def processGenDiseq (mvarId : MVarId) (localDecl : LocalDecl) : MetaM Bo
 def contradictionCore (mvarId : MVarId) (config : Contradiction.Config) : MetaM Bool := do
   withMVarContext mvarId do
     checkNotAssigned mvarId `contradiction
+    if (← nestedFalseElim mvarId) then
+      return true
     for localDecl in (← getLCtx) do
       unless localDecl.isAuxDecl do
         -- (h : ¬ p) (h' : p)

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

@@ -12,7 +12,7 @@ def delta? (e : Expr) (p : Name → Bool := fun _ => true) : CoreM (Option Expr)
   matchConst e.getAppFn (fun _ => return none) fun fInfo fLvls => do
     if p fInfo.name && fInfo.hasValue && fInfo.levelParams.length == fLvls.length then
       let f := fInfo.instantiateValueLevelParams fLvls
-      return some (f.betaRev e.getAppRevArgs)
+      return some (f.betaRev e.getAppRevArgs (useZeta := true))
     else
       return none
 

stage0/src/Lean/Meta/Tactic/Simp/Main.lean

@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
 import Lean.Meta.Transform
+import Lean.Meta.CongrTheorems
 import Lean.Meta.Tactic.Replace
 import Lean.Meta.Tactic.Util
 import Lean.Meta.Tactic.Clear
@@ -141,6 +142,29 @@ def getSimpLetCase (n : Name) (t : Expr) (v : Expr) (b : Expr) : MetaM SimpLetCa
     else
       return SimpLetCase.dep
 
+/-- Given the application `e`, remove unnecessary casts of the form `Eq.rec a rfl` and `Eq.ndrec a rfl`. -/
+partial def removeUnnecessaryCasts (e : Expr) : MetaM Expr := do
+  let mut args := e.getAppArgs
+  let mut modified := false
+  for i in [:args.size] do
+    let arg := args[i]
+    if isDummyEqRec arg then
+      args := args.set! i (elimDummyEqRec arg)
+      modified := true
+  if modified then
+    return mkAppN e.getAppFn args
+  else
+    return e
+where
+  isDummyEqRec (e : Expr) : Bool :=
+    (e.isAppOfArity ``Eq.rec 6 || e.isAppOfArity ``Eq.ndrec 6) && e.appArg!.isAppOf ``Eq.refl
+
+  elimDummyEqRec (e : Expr) : Expr :=
+    if isDummyEqRec e then
+      elimDummyEqRec e.appFn!.appFn!.appArg!
+    else
+      e
+
 partial def simp (e : Expr) : M Result := withIncRecDepth do
   checkMaxHeartbeats "simp"
   let cfg ← getConfig
@@ -243,9 +267,106 @@ where
         i := i + 1
       return r
 
-  congrDefault (e : Expr) : M Result :=
-    withParent e <| e.withApp fun f args => do
-      congrArgs (← simp f) args
+  visitFn (e : Expr) : M Result := do
+    let f := e.getAppFn
+    let fNew ← simp f
+    if fNew.expr == f then
+      return { expr := e }
+    else
+      let args := e.getAppArgs
+      let eNew := mkAppN fNew.expr args
+      if fNew.proof?.isNone then return { expr := eNew }
+      let mut proof ← fNew.getProof
+      for arg in args do
+        proof ← Meta.mkCongrFun proof arg
+      return { expr := eNew, proof? := proof }
+
+  mkCongrSimp? (f : Expr) : M (Option CongrTheorem) := do
+    if f.isConst then if (← isMatcher f.constName!) then
+      -- We always use simple congruence theorems for auxiliary match applications
+      return none
+    let info ← getFunInfo f
+    let kinds := getCongrSimpKinds info
+    if kinds.all fun k => match k with | CongrArgKind.fixed => true | CongrArgKind.eq => true | _ => false then
+      /- If all argument kinds are `fixed` or `eq`, then using
+         simple congruence theorems `congr`, `congrArg`, and `congrFun` produces a more compact proof -/
+      return none
+    match (← get).congrCache.find? f with
+    | some thm? => return thm?
+    | none =>
+      let thm? ← mkCongrSimpCore? f info kinds
+      modify fun s => { s with congrCache := s.congrCache.insert f thm? }
+      return thm?
+
+  /-- Try to use automatically generated congruence theorems. See `mkCongrSimp?`. -/
+  tryAutoCongrTheorem? (e : Expr) : M (Option Result) := do
+    let f := e.getAppFn
+    -- TODO: cache
+    let some cgrThm ← mkCongrSimp? f | return none
+    if cgrThm.argKinds.size != e.getAppNumArgs then return none
+    let mut simplified := false
+    let mut hasProof   := false
+    let mut hasCast    := false
+    let mut argsNew    := #[]
+    let mut argResults := #[]
+    let args := e.getAppArgs
+    for arg in args, kind in cgrThm.argKinds do
+      match kind with
+      | CongrArgKind.fixed => argsNew := argsNew.push arg
+      | CongrArgKind.cast  => hasCast := true; argsNew := argsNew.push arg
+      | CongrArgKind.subsingletonInst => argsNew := argsNew.push arg
+      | CongrArgKind.eq =>
+        let argResult ← simp arg
+        argResults := argResults.push argResult
+        argsNew    := argsNew.push argResult.expr
+        if argResult.proof?.isSome then hasProof := true
+        if arg != argResult.expr then simplified := true
+      | _ => unreachable!
+    if !simplified then return some { expr := e }
+    if !hasProof then return some { expr := mkAppN f argsNew }
+    let mut proof := cgrThm.proof
+    let mut type  := cgrThm.type
+    let mut j := 0 -- index at argResults
+    let mut subst := #[]
+    for arg in args, kind in cgrThm.argKinds do
+      proof := mkApp proof arg
+      subst := subst.push arg
+      type := type.bindingBody!
+      match kind with
+      | CongrArgKind.fixed => pure ()
+      | CongrArgKind.cast  => pure ()
+      | CongrArgKind.subsingletonInst =>
+        let clsNew := type.bindingDomain!.instantiateRev subst
+        let instNew ←
+          if (← isDefEq (← inferType arg) clsNew) then
+            pure arg
+          else
+            match (← trySynthInstance clsNew) with
+            | LOption.some val => pure val
+            | _ =>
+              trace[Meta.Tactic.simp.congr] "failed to synthesize instance{indentExpr clsNew}"
+              return none
+        proof := mkApp proof instNew
+        subst := subst.push instNew
+        type := type.bindingBody!
+      | CongrArgKind.eq =>
+        let argResult := argResults[j]
+        let argProof ← argResult.getProof
+        j := j + 1
+        proof := mkApp2 proof argResult.expr argProof
+        subst := subst.push argResult.expr |>.push argProof
+        type := type.bindingBody!.bindingBody!
+      | _ => unreachable!
+    let some (_, _, rhs) := type.instantiateRev subst |>.eq? | unreachable!
+    let rhs ← if hasCast then removeUnnecessaryCasts rhs else pure rhs
+    return some { expr := rhs, proof? := proof }
+
+  congrDefault (e : Expr) : M Result := do
+    if let some result ← tryAutoCongrTheorem? e then
+      mkEqTrans result (← visitFn result.expr)
+    else
+      withParent e <| e.withApp fun f args => do
+        congrArgs (← simp f) args
 
   /- Return true iff processing the given congruence theorem hypothesis produced a non-refl proof. -/
   processCongrHypothesis (h : Expr) : M Bool := do
@@ -264,8 +385,8 @@ where
   /- Try to rewrite `e` children using the given congruence theorem -/
   trySimpCongrTheorem? (c : SimpCongrTheorem) (e : Expr) : M (Option Result) := withNewMCtxDepth do
     trace[Debug.Meta.Tactic.simp.congr] "{c.theoremName}, {e}"
-    let lemma ← mkConstWithFreshMVarLevels c.theoremName
-    let (xs, bis, type) ← forallMetaTelescopeReducing (← inferType lemma)
+    let thm ← mkConstWithFreshMVarLevels c.theoremName
+    let (xs, bis, type) ← forallMetaTelescopeReducing (← inferType thm)
     if c.hypothesesPos.any (· ≥ xs.size) then
       return none
     let lhs := type.appFn!.appArg!
@@ -298,7 +419,7 @@ where
         trace[Meta.Tactic.simp.congr] "{c.theoremName} synthesizeArgs failed"
         return none
       let eNew ← instantiateMVars rhs
-      let proof ← instantiateMVars (mkAppN lemma xs)
+      let proof ← instantiateMVars (mkAppN thm xs)
       congrArgs { expr := eNew, proof? := proof } extraArgs
     else
       return none
@@ -430,7 +551,10 @@ where
 
 def main (e : Expr) (ctx : Context) (methods : Methods := {}) : MetaM Result :=
   withConfig (fun c => { c with etaStruct := ctx.config.etaStruct }) <| withReducible do
-    simp e methods ctx |>.run' {}
+    try
+      simp e methods ctx |>.run' {}
+    catch ex =>
+      if ex.isMaxHeartbeat then throwNestedTacticEx `simp ex else throw ex
 
 partial def isEqnThmHypothesis (e : Expr) : Bool :=
   e.isForall && go e
@@ -610,4 +734,22 @@ def simpGoal (mvarId : MVarId) (ctx : Simp.Context) (discharge? : Option Simp.Di
     let mvarIdNew ← tryClearMany mvarIdNew fvarIdsToSimp
     return (fvarIdsNew, mvarIdNew)
 
+def simpTargetStar (mvarId : MVarId) (ctx : Simp.Context) (discharge? : Option Simp.Discharge := none) : MetaM TacticResultCNM := withMVarContext mvarId do
+  trace[Meta.debug] "simpTargetStar:\n{mvarId}"
+  let mut ctx := ctx
+  for h in (← getPropHyps) do
+    let localDecl ← getLocalDecl h
+    let proof  := localDecl.toExpr
+    trace[Meta.debug] "adding {localDecl.toExpr}"
+    let simpTheorems ← ctx.simpTheorems.add #[] proof
+    ctx := { ctx with simpTheorems }
+  match (← simpTarget mvarId ctx discharge?) with
+  | none => return TacticResultCNM.closed
+  | some mvarId' =>
+    trace[Meta.debug] "simpTargetStar result:\n{mvarId'}"
+    if (← getMVarType mvarId) == (← getMVarType mvarId') then
+      return TacticResultCNM.noChange
+    else
+      return TacticResultCNM.modified mvarId'
+
 end Lean.Meta

stage0/src/Lean/Meta/Tactic/Simp/Types.lean

@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
 import Lean.Meta.AppBuilder
+import Lean.Meta.CongrTheorems
 import Lean.Meta.Tactic.Simp.SimpTheorems
 import Lean.Meta.Tactic.Simp.SimpCongrTheorems
 
@@ -17,6 +18,8 @@ structure Result where
 
 abbrev Cache := ExprMap Result
 
+abbrev CongrCache := ExprMap (Option CongrTheorem)
+
 structure Context where
   config         : Config      := {}
   simpTheorems   : SimpTheorems  := {}
@@ -29,8 +32,9 @@ def Context.mkDefault : MetaM Context :=
   return { config := {}, simpTheorems := (← getSimpTheorems), congrTheorems := (← getSimpCongrTheorems) }
 
 structure State where
-  cache    : Cache := {}
-  numSteps : Nat := 0
+  cache      : Cache := {}
+  congrCache : CongrCache := {}
+  numSteps   : Nat := 0
 
 abbrev SimpM := ReaderT Context $ StateRefT State MetaM
 

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

@@ -119,19 +119,24 @@ def splitMatch (mvarId : MVarId) (e : Expr) : MetaM (List MVarId) := do
     throwNestedTacticEx `splitMatch ex
 
 /-- Return an `if-then-else` or `match-expr` to split. -/
-partial def findSplit? (env : Environment) (e : Expr) : Option Expr :=
-  if let some target := e.find? isCandidate then
-    if e.isIte || e.isDIte then
-      let cond := target.getArg! 1 5
-      -- Try to find a nested `if` in `cond`
-      findSplit? env cond |>.getD target
-    else
-      some target
-  else
-    none
+partial def findSplit? (env : Environment) (e : Expr) (splitIte := true) (exceptionSet : ExprSet := {}) : Option Expr :=
+  go e
 where
+  go (e : Expr) : Option Expr :=
+    if let some target := e.find? isCandidate then
+      if e.isIte || e.isDIte then
+        let cond := target.getArg! 1 5
+        -- Try to find a nested `if` in `cond`
+        go cond |>.getD target
+      else
+        some target
+    else
+      none
+
   isCandidate (e : Expr) : Bool := Id.run <| do
-    if e.isIte || e.isDIte then
+    if exceptionSet.contains e then
+      false
+    else if splitIte && (e.isIte || e.isDIte) then
       !(e.getArg! 1 5).hasLooseBVars
     else if let some info := isMatcherAppCore? env e then
       let args := e.getAppArgs
@@ -146,15 +151,20 @@ end Split
 
 open Split
 
-def splitTarget? (mvarId : MVarId) : MetaM (Option (List MVarId)) := commitWhenSome? do
-  if let some e := findSplit? (← getEnv) (← instantiateMVars (← getMVarType mvarId)) then
-    if e.isIte || e.isDIte then
-      return (← splitIfTarget? mvarId).map fun (s₁, s₂) => [s₁.mvarId, s₂.mvarId]
+partial def splitTarget? (mvarId : MVarId) (splitIte := true) : MetaM (Option (List MVarId)) := commitWhenSome? do
+  let rec go (badCases : ExprSet) : MetaM (Option (List MVarId)) := do
+    if let some e := findSplit? (← getEnv) (← instantiateMVars (← getMVarType mvarId)) splitIte badCases then
+      if e.isIte || e.isDIte then
+        return (← splitIfTarget? mvarId).map fun (s₁, s₂) => [s₁.mvarId, s₂.mvarId]
+      else
+        try
+          splitMatch mvarId e
+        catch _ =>
+          go (badCases.insert e)
     else
-      splitMatch mvarId e
-  else
-    trace[Meta.Tactic.split] "did not find term to split\n{MessageData.ofGoal mvarId}"
-    return none
+      trace[Meta.Tactic.split] "did not find term to split\n{MessageData.ofGoal mvarId}"
+      return none
+  go {}
 
 def splitLocalDecl? (mvarId : MVarId) (fvarId : FVarId) : MetaM (Option (List MVarId)) := commitWhenSome? do
   withMVarContext mvarId do

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

@@ -109,4 +109,18 @@ def ensureAtMostOne (mvarIds : List MVarId) (msg : MessageData := "unexpected nu
   | [mvarId] => return some mvarId
   | _        => throwError msg
 
+/-- Return all propositions in the local context. -/
+def getPropHyps : MetaM (Array FVarId) := do
+  let mut result := #[]
+  for localDecl in (← getLCtx) do
+    unless localDecl.isAuxDecl do
+      if (← isProp localDecl.type) then
+        result := result.push localDecl.fvarId
+  return result
+
+inductive TacticResultCNM where
+  | closed
+  | noChange
+  | modified (mvarId : MVarId)
+
 end Lean.Meta

stage0/src/Lean/Meta/Transform.lean

@@ -79,19 +79,19 @@ partial def transform {m} [Monad m] [MonadLiftT MetaM m] [MonadControlT MetaM m]
         | Expr.lam n d b c =>
           withLocalDecl n c.binderInfo (← visit (d.instantiateRev fvars)) fun x =>
             visitLambda (fvars.push x) b
-        | e => visitPost (← mkLambdaFVars fvars (← visit (e.instantiateRev fvars)))
+        | e => visitPost (← mkLambdaFVars (usedLetOnly := false) fvars (← visit (e.instantiateRev fvars)))
       let rec visitForall (fvars : Array Expr) (e : Expr) : MonadCacheT ExprStructEq Expr m Expr := do
         match e with
         | Expr.forallE n d b c =>
           withLocalDecl n c.binderInfo (← visit (d.instantiateRev fvars)) fun x =>
             visitForall (fvars.push x) b
-        | e => visitPost (← mkForallFVars fvars (← visit (e.instantiateRev fvars)))
+        | e => visitPost (← mkForallFVars (usedLetOnly := false) fvars (← visit (e.instantiateRev fvars)))
       let rec visitLet (fvars : Array Expr) (e : Expr) : MonadCacheT ExprStructEq Expr m Expr := do
         match e with
         | Expr.letE n t v b _ =>
           withLetDecl n (← visit (t.instantiateRev fvars)) (← visit (v.instantiateRev fvars)) fun x =>
             visitLet (fvars.push x) b
-        | e => visitPost (← mkLetFVars fvars (← visit (e.instantiateRev fvars)))
+        | e => visitPost (← mkLetFVars (usedLetOnly := false) fvars (← visit (e.instantiateRev fvars)))
       let visitApp (e : Expr) : MonadCacheT ExprStructEq Expr m Expr :=
         e.withApp fun f args => do
           visitPost (mkAppN (← visit f) (← args.mapM visit))

stage0/src/Lean/PrettyPrinter/Delaborator/Builtins.lean

@@ -311,7 +311,8 @@ structure AppMatchState where
 private partial def delabPatterns (st : AppMatchState) : DelabM (Array (Array Syntax)) :=
   withReader (fun ctx => { ctx with inPattern := true, optionsPerPos := {} }) do
     let ty ← instantiateForall st.matcherTy st.params
-    forallTelescope ty fun params _ => do
+    -- need to reduce `let`s that are lifted into the matcher type
+    forallTelescopeReducing ty fun params _ => do
       -- skip motive and discriminators
       let alts := Array.ofSubarray params[1 + st.discrs.size:]
       alts.mapIdxM fun idx alt => do

stage0/src/Lean/Server/FileWorker/RequestHandling.lean

@@ -252,8 +252,7 @@ partial def handleDocumentHighlight (p : DocumentHighlightParams)
         return #[hi]
       return #[]
 
-section -- TODO https://github.com/leanprover/lean4/issues/529
-open Parser.Command
+open Parser.Command in
 partial def handleDocumentSymbol (p : DocumentSymbolParams)
     : RequestM (RequestTask DocumentSymbolResult) := do
   let doc ← readDoc
@@ -313,7 +312,6 @@ partial def handleDocumentSymbol (p : DocumentSymbolParams)
           selectionRange := selection.getRange? |>.map (·.toLspRange text) |>.getD range
           children? := syms.toArray
         } :: syms', stxs'')
-end
 
 def noHighlightKinds : Array SyntaxNodeKind := #[
   -- usually have special highlighting by the client

stage0/src/shell/CMakeLists.txt

@@ -126,6 +126,17 @@ FOREACH(T ${LEANT0TESTS})
            COMMAND bash -c "${TEST_VARS} ./test_single.sh ${T_NAME}")
 ENDFOREACH(T)
 
+# LEAN PACKAGE TESTS
+file(GLOB LEANPKGTESTS "${LEAN_SOURCE_DIR}/../tests/pkg/*")
+FOREACH(T ${LEANPKGTESTS})
+  if(IS_DIRECTORY ${T})
+    GET_FILENAME_COMPONENT(T_NAME ${T} NAME)
+    add_test(NAME "leanpkgtest_${T_NAME}"
+            WORKING_DIRECTORY "${T}"
+            COMMAND bash -c "${TEST_VARS} ./test.sh")
+  endif()
+ENDFOREACH(T)
+
 # LEAN SERVER TESTS
 file(GLOB LEANTESTS "${LEAN_SOURCE_DIR}/../tests/lean/server/*.lean")
 FOREACH(T ${LEANTESTS})
@@ -149,7 +160,6 @@ FOREACH(T ${LEANTESTS})
 ENDFOREACH(T)
 
 # Create a lake test for each subdirectory of `lake/examples` which contains a `test.sh` file.
-# We skip the subdirectories `lean_packages` and `bootstrap` since `lake/examples/Makefile` does not consider them either.
 file(GLOB_RECURSE LEANLAKETESTS "${LEAN_SOURCE_DIR}/lake/examples/test.sh")
 FOREACH(T ${LEANLAKETESTS})
   if(NOT T MATCHES ".*lean_packages.*")

stage0/stdlib/Init/Data/Array.c

@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Init.Data.Array
-// Imports: Init.Data.Array.Basic Init.Data.Array.QSort Init.Data.Array.BinSearch Init.Data.Array.InsertionSort
+// Imports: Init.Data.Array.Basic Init.Data.Array.QSort Init.Data.Array.BinSearch Init.Data.Array.InsertionSort Init.Data.Array.DecidableEq
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -17,6 +17,7 @@ lean_object* initialize_Init_Data_Array_Basic(uint8_t builtin, lean_object*);
 lean_object* initialize_Init_Data_Array_QSort(uint8_t builtin, lean_object*);
 lean_object* initialize_Init_Data_Array_BinSearch(uint8_t builtin, lean_object*);
 lean_object* initialize_Init_Data_Array_InsertionSort(uint8_t builtin, lean_object*);
+lean_object* initialize_Init_Data_Array_DecidableEq(uint8_t builtin, lean_object*);
 static bool _G_initialized = false;
 LEAN_EXPORT lean_object* initialize_Init_Data_Array(uint8_t builtin, lean_object* w) {
 lean_object * res;
@@ -34,6 +35,9 @@ lean_dec_ref(res);
 res = initialize_Init_Data_Array_InsertionSort(builtin, lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Init_Data_Array_DecidableEq(builtin, 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/Init/Data/Array/Basic.c

@@ -8753,7 +8753,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Array_swapAt_x21___rarg___closed__3;
 x_2 = l_Array_insertAt___rarg___closed__1;
-x_3 = lean_unsigned_to_nat(686u);
+x_3 = lean_unsigned_to_nat(682u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Array_insertAt___rarg___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

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

@@ -0,0 +1,154 @@
+// Lean compiler output
+// Module: Init.Data.Array.DecidableEq
+// Imports: Init.Data.Array.Basic Init.Classical
+#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_EXPORT lean_object* l_Array_isEqvAux___at_Array_instDecidableEqArray___spec__1(lean_object*);
+LEAN_EXPORT lean_object* l_Array_instDecidableEqArray(lean_object*);
+lean_object* lean_array_get_size(lean_object*);
+LEAN_EXPORT lean_object* l_Array_instDecidableEqArray___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* lean_nat_add(lean_object*, lean_object*);
+lean_object* lean_array_fget(lean_object*, lean_object*);
+uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
+LEAN_EXPORT uint8_t l_Array_isEqvAux___at_Array_instDecidableEqArray___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT uint8_t l_Array_instDecidableEqArray___rarg(lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Array_isEqvAux___at_Array_instDecidableEqArray___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
+LEAN_EXPORT uint8_t l_Array_isEqvAux___at_Array_instDecidableEqArray___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+_start:
+{
+lean_object* x_8; uint8_t x_9; 
+x_8 = lean_array_get_size(x_5);
+x_9 = lean_nat_dec_lt(x_7, x_8);
+lean_dec(x_8);
+if (x_9 == 0)
+{
+uint8_t x_10; 
+lean_dec(x_7);
+lean_dec(x_1);
+x_10 = 1;
+return x_10;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; 
+x_11 = lean_array_fget(x_5, x_7);
+x_12 = lean_array_fget(x_6, x_7);
+lean_inc(x_1);
+x_13 = lean_apply_2(x_1, x_11, x_12);
+x_14 = lean_unbox(x_13);
+lean_dec(x_13);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_7);
+lean_dec(x_1);
+x_15 = 0;
+return x_15;
+}
+else
+{
+lean_object* x_16; lean_object* x_17; 
+x_16 = lean_unsigned_to_nat(1u);
+x_17 = lean_nat_add(x_7, x_16);
+lean_dec(x_7);
+x_4 = lean_box(0);
+x_7 = x_17;
+goto _start;
+}
+}
+}
+}
+LEAN_EXPORT lean_object* l_Array_isEqvAux___at_Array_instDecidableEqArray___spec__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Array_isEqvAux___at_Array_instDecidableEqArray___spec__1___rarg___boxed), 7, 0);
+return x_2;
+}
+}
+LEAN_EXPORT uint8_t l_Array_instDecidableEqArray___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; uint8_t x_6; 
+x_4 = lean_array_get_size(x_2);
+x_5 = lean_array_get_size(x_3);
+x_6 = lean_nat_dec_eq(x_4, x_5);
+lean_dec(x_5);
+lean_dec(x_4);
+if (x_6 == 0)
+{
+uint8_t x_7; 
+lean_dec(x_1);
+x_7 = 0;
+return x_7;
+}
+else
+{
+lean_object* x_8; uint8_t x_9; 
+x_8 = lean_unsigned_to_nat(0u);
+x_9 = l_Array_isEqvAux___at_Array_instDecidableEqArray___spec__1___rarg(x_1, x_2, x_3, lean_box(0), x_2, x_3, x_8);
+return x_9;
+}
+}
+}
+LEAN_EXPORT lean_object* l_Array_instDecidableEqArray(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Array_instDecidableEqArray___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+LEAN_EXPORT lean_object* l_Array_isEqvAux___at_Array_instDecidableEqArray___spec__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* x_6, lean_object* x_7) {
+_start:
+{
+uint8_t x_8; lean_object* x_9; 
+x_8 = l_Array_isEqvAux___at_Array_instDecidableEqArray___spec__1___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_9 = lean_box(x_8);
+return x_9;
+}
+}
+LEAN_EXPORT lean_object* l_Array_instDecidableEqArray___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; lean_object* x_5; 
+x_4 = l_Array_instDecidableEqArray___rarg(x_1, x_2, x_3);
+lean_dec(x_3);
+lean_dec(x_2);
+x_5 = lean_box(x_4);
+return x_5;
+}
+}
+lean_object* initialize_Init_Data_Array_Basic(uint8_t builtin, lean_object*);
+lean_object* initialize_Init_Classical(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_Init_Data_Array_DecidableEq(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init_Data_Array_Basic(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Init_Classical(builtin, 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/AutoBound.c

@@ -14,36 +14,42 @@
 extern "C" {
 #endif
 static lean_object* l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix___closed__1;
+LEAN_EXPORT lean_object* l_Lean_Elab_relaxedAutoImplicit;
 LEAN_EXPORT lean_object* l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix___boxed(lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
-LEAN_EXPORT uint8_t l_Lean_Elab_isValidAutoBoundImplicitName(lean_object*);
+LEAN_EXPORT uint8_t l_Lean_Elab_isValidAutoBoundImplicitName(lean_object*, uint8_t);
 uint8_t l_String_anyAux_loop(lean_object*, lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Elab_autoBoundImplicitLocal;
 uint8_t l_Char_isDigit(uint32_t);
+LEAN_EXPORT lean_object* l_Lean_Elab_autoImplicit;
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____closed__3;
 static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____closed__5;
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__3;
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__1;
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__2;
 uint8_t l_Char_isLower(uint32_t);
 static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____closed__1;
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__4;
 static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____closed__2;
 lean_object* l_Substring_nextn(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix___lambda__1___boxed(lean_object*);
 static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____closed__4;
 uint8_t lean_uint32_dec_eq(uint32_t, uint32_t);
 LEAN_EXPORT uint8_t l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix(lean_object*);
-LEAN_EXPORT uint8_t l_Lean_Elab_isValidAutoBoundLevelName(lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Elab_isValidAutoBoundImplicitName___boxed(lean_object*);
+LEAN_EXPORT uint8_t l_Lean_Elab_isValidAutoBoundLevelName(lean_object*, uint8_t);
+LEAN_EXPORT lean_object* l_Lean_Elab_isValidAutoBoundImplicitName___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_isGreek(uint32_t);
 lean_object* lean_register_option(lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29_(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6_(lean_object*);
 lean_object* lean_string_length(lean_object*);
 uint8_t l_Lean_isSubScriptAlnum(uint32_t);
 LEAN_EXPORT uint8_t l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix___lambda__1(uint32_t);
 LEAN_EXPORT lean_object* l_Lean_Option_register___at_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____spec__1(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Option_register___at_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____spec__1___boxed(lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Elab_isValidAutoBoundLevelName___boxed(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Elab_isValidAutoBoundLevelName___boxed(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Option_register___at_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
@@ -124,7 +130,7 @@ static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6_
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("autoBoundImplicitLocal");
+x_1 = lean_mk_string("autoImplicit");
 return x_1;
 }
 }
@@ -150,7 +156,7 @@ static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6_
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("Unbound local variables in declaration headers become implicit arguments if they are a lower case or greek letter followed by numeric digits. For example, `def f (x : Vector α n) : Vector α n :=` automatically introduces the implicit variables {α n}.");
+x_1 = lean_mk_string("Unbound local variables in declaration headers become implicit arguments. In \"relaxed\" mode (default), any atomic identifier is eligible, otherwise only a lower case or greek letter followed by numeric digits are eligible. For example, `def f (x : Vector α n) : Vector α n :=` automatically introduces the implicit variables {α n}.");
 return x_1;
 }
 }
@@ -188,6 +194,57 @@ lean_dec(x_2);
 return x_4;
 }
 }
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("relaxedAutoImplicit");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____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_AutoBound___hyg_29____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_AutoBound___hyg_29____closed__3() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("When \"relaxed\" mode is enabled, any atomic nonempty identifier is eligible for auto bound implicit locals (see optin `autoBoundImplicitLocal`.");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__4() {
+_start:
+{
+uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_1 = 1;
+x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____closed__3;
+x_3 = l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__3;
+x_4 = lean_box(x_1);
+x_5 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_5, 0, x_4);
+lean_ctor_set(x_5, 1, x_2);
+lean_ctor_set(x_5, 2, x_3);
+return x_5;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29_(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_AutoBound___hyg_29____closed__2;
+x_3 = l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__4;
+x_4 = l_Lean_Option_register___at_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____spec__1(x_2, x_3, x_1);
+return x_4;
+}
+}
 LEAN_EXPORT uint8_t l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix___lambda__1(uint32_t x_1) {
 _start:
 {
@@ -305,58 +362,152 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
-LEAN_EXPORT uint8_t l_Lean_Elab_isValidAutoBoundImplicitName(lean_object* x_1) {
+LEAN_EXPORT uint8_t l_Lean_Elab_isValidAutoBoundImplicitName(lean_object* x_1, uint8_t x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 1)
 {
-lean_object* x_2; 
-x_2 = lean_ctor_get(x_1, 0);
-lean_inc(x_2);
-if (lean_obj_tag(x_2) == 0)
-{
-lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; 
-x_3 = lean_ctor_get(x_1, 1);
+lean_object* x_3; 
+x_3 = lean_ctor_get(x_1, 0);
 lean_inc(x_3);
-lean_dec(x_1);
-x_4 = lean_string_length(x_3);
-x_5 = lean_unsigned_to_nat(0u);
-x_6 = lean_nat_dec_lt(x_5, x_4);
-lean_dec(x_4);
-if (x_6 == 0)
+if (lean_obj_tag(x_3) == 0)
 {
-uint8_t x_7; 
-lean_dec(x_3);
-x_7 = 0;
-return x_7;
+lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_string_length(x_4);
+x_6 = lean_unsigned_to_nat(0u);
+x_7 = lean_nat_dec_lt(x_6, x_5);
+lean_dec(x_5);
+if (x_7 == 0)
+{
+uint8_t x_8; 
+lean_dec(x_4);
+x_8 = 0;
+return x_8;
 }
 else
 {
-uint32_t x_8; uint8_t x_9; 
-x_8 = lean_string_utf8_get(x_3, x_5);
-x_9 = l_Lean_isGreek(x_8);
-if (x_9 == 0)
+if (x_2 == 0)
 {
-uint8_t x_10; 
-x_10 = l_Char_isLower(x_8);
+uint32_t x_9; uint8_t x_10; 
+x_9 = lean_string_utf8_get(x_4, x_6);
+x_10 = l_Lean_isGreek(x_9);
 if (x_10 == 0)
 {
 uint8_t x_11; 
+x_11 = l_Char_isLower(x_9);
+if (x_11 == 0)
+{
+uint8_t x_12; 
+lean_dec(x_4);
+x_12 = 0;
+return x_12;
+}
+else
+{
+uint8_t x_13; 
+x_13 = l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix(x_4);
+return x_13;
+}
+}
+else
+{
+uint8_t x_14; 
+x_14 = l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix(x_4);
+return x_14;
+}
+}
+else
+{
+uint8_t x_15; 
+lean_dec(x_4);
+x_15 = 1;
+return x_15;
+}
+}
+}
+else
+{
+uint8_t x_16; 
 lean_dec(x_3);
+lean_dec(x_1);
+x_16 = 0;
+return x_16;
+}
+}
+else
+{
+uint8_t x_17; 
+lean_dec(x_1);
+x_17 = 0;
+return x_17;
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Elab_isValidAutoBoundImplicitName___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; uint8_t x_4; lean_object* x_5; 
+x_3 = lean_unbox(x_2);
+lean_dec(x_2);
+x_4 = l_Lean_Elab_isValidAutoBoundImplicitName(x_1, x_3);
+x_5 = lean_box(x_4);
+return x_5;
+}
+}
+LEAN_EXPORT uint8_t l_Lean_Elab_isValidAutoBoundLevelName(lean_object* x_1, uint8_t x_2) {
+_start:
+{
+if (lean_obj_tag(x_1) == 1)
+{
+lean_object* x_3; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+if (lean_obj_tag(x_3) == 0)
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_string_length(x_4);
+x_6 = lean_unsigned_to_nat(0u);
+x_7 = lean_nat_dec_lt(x_6, x_5);
+lean_dec(x_5);
+if (x_7 == 0)
+{
+uint8_t x_8; 
+lean_dec(x_4);
+x_8 = 0;
+return x_8;
+}
+else
+{
+if (x_2 == 0)
+{
+uint32_t x_9; uint8_t x_10; 
+x_9 = lean_string_utf8_get(x_4, x_6);
+x_10 = l_Char_isLower(x_9);
+if (x_10 == 0)
+{
+uint8_t x_11; 
+lean_dec(x_4);
 x_11 = 0;
 return x_11;
 }
 else
 {
 uint8_t x_12; 
-x_12 = l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix(x_3);
+x_12 = l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix(x_4);
 return x_12;
 }
 }
 else
 {
 uint8_t x_13; 
-x_13 = l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix(x_3);
+lean_dec(x_4);
+x_13 = 1;
 return x_13;
 }
 }
@@ -364,7 +515,7 @@ return x_13;
 else
 {
 uint8_t x_14; 
-lean_dec(x_2);
+lean_dec(x_3);
 lean_dec(x_1);
 x_14 = 0;
 return x_14;
@@ -379,85 +530,15 @@ return x_15;
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Elab_isValidAutoBoundImplicitName___boxed(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Elab_isValidAutoBoundLevelName___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = l_Lean_Elab_isValidAutoBoundImplicitName(x_1);
-x_3 = lean_box(x_2);
-return x_3;
-}
-}
-LEAN_EXPORT uint8_t l_Lean_Elab_isValidAutoBoundLevelName(lean_object* x_1) {
-_start:
-{
-if (lean_obj_tag(x_1) == 1)
-{
-lean_object* x_2; 
-x_2 = lean_ctor_get(x_1, 0);
-lean_inc(x_2);
-if (lean_obj_tag(x_2) == 0)
-{
-lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; 
-x_3 = lean_ctor_get(x_1, 1);
-lean_inc(x_3);
-lean_dec(x_1);
-x_4 = lean_string_length(x_3);
-x_5 = lean_unsigned_to_nat(0u);
-x_6 = lean_nat_dec_lt(x_5, x_4);
-lean_dec(x_4);
-if (x_6 == 0)
-{
-uint8_t x_7; 
-lean_dec(x_3);
-x_7 = 0;
-return x_7;
-}
-else
-{
-uint32_t x_8; uint8_t x_9; 
-x_8 = lean_string_utf8_get(x_3, x_5);
-x_9 = l_Char_isLower(x_8);
-if (x_9 == 0)
-{
-uint8_t x_10; 
-lean_dec(x_3);
-x_10 = 0;
-return x_10;
-}
-else
-{
-uint8_t x_11; 
-x_11 = l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix(x_3);
-return x_11;
-}
-}
-}
-else
-{
-uint8_t x_12; 
+uint8_t x_3; uint8_t x_4; lean_object* x_5; 
+x_3 = lean_unbox(x_2);
 lean_dec(x_2);
-lean_dec(x_1);
-x_12 = 0;
-return x_12;
-}
-}
-else
-{
-uint8_t x_13; 
-lean_dec(x_1);
-x_13 = 0;
-return x_13;
-}
-}
-}
-LEAN_EXPORT lean_object* l_Lean_Elab_isValidAutoBoundLevelName___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = l_Lean_Elab_isValidAutoBoundLevelName(x_1);
-x_3 = lean_box(x_2);
-return x_3;
+x_4 = l_Lean_Elab_isValidAutoBoundLevelName(x_1, x_3);
+x_5 = lean_box(x_4);
+return x_5;
 }
 }
 lean_object* initialize_Init(uint8_t builtin, lean_object*);
@@ -485,8 +566,21 @@ l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____closed__5 = _init_l_Lea
 lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____closed__5);
 if (builtin) {res = l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
-l_Lean_Elab_autoBoundImplicitLocal = lean_io_result_get_value(res);
-lean_mark_persistent(l_Lean_Elab_autoBoundImplicitLocal);
+l_Lean_Elab_autoImplicit = lean_io_result_get_value(res);
+lean_mark_persistent(l_Lean_Elab_autoImplicit);
+lean_dec_ref(res);
+}l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__1();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__1);
+l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__2 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__2();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__2);
+l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__3 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__3();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__3);
+l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__4 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__4();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29____closed__4);
+if (builtin) {res = l_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_29_(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+l_Lean_Elab_relaxedAutoImplicit = lean_io_result_get_value(res);
+lean_mark_persistent(l_Lean_Elab_relaxedAutoImplicit);
 lean_dec_ref(res);
 }l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix___closed__1 = _init_l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix___closed__1();
 lean_mark_persistent(l___private_Lean_Elab_AutoBound_0__Lean_Elab_isValidAutoBoundSuffix___closed__1);

stage0/stdlib/Lean/Elab/MutualDef.c

@@ -595,6 +595,7 @@ LEAN_EXPORT lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0_
 LEAN_EXPORT lean_object* l_Std_RBNode_find___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_addDeclarationRanges___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_List_mapM___at_Lean_Elab_Term_elabMutualDef_go___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_WF_Fix_0__Lean_Elab_WF_replaceRecApps_loop___spec__12___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_registerFailedToInferDefTypeInfo___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_MutualClosure_ClosureState_newLetDecls___default;
 static lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_expandWhereStructInst___spec__2___lambda__3___closed__1;
@@ -726,7 +727,6 @@ lean_object* l_Lean_Elab_Term_withAutoBoundImplicit___rarg(lean_object*, lean_ob
 static lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkKinds___lambda__1___closed__1;
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabFunValues___spec__2___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_WF_Fix_0__Lean_Elab_WF_replaceRecApps_loop___spec__9___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_liftMacroM___at_Lean_Elab_Term_processDefDeriving___spec__1___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_collectUsed___spec__3(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__2___closed__5;
@@ -16520,7 +16520,7 @@ lean_closure_set(x_13, 0, x_1);
 lean_closure_set(x_13, 1, x_2);
 lean_closure_set(x_13, 2, x_10);
 lean_closure_set(x_13, 3, x_11);
-x_14 = lean_alloc_closure((void*)(l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_WF_Fix_0__Lean_Elab_WF_replaceRecApps_loop___spec__9___rarg), 9, 2);
+x_14 = lean_alloc_closure((void*)(l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_WF_Fix_0__Lean_Elab_WF_replaceRecApps_loop___spec__12___rarg), 9, 2);
 lean_closure_set(x_14, 0, x_12);
 lean_closure_set(x_14, 1, x_13);
 x_15 = l_Lean_Meta_withLCtx___at___private_Lean_Elab_Binders_0__Lean_Elab_Term_FunBinders_elabFunBinderViews___spec__3___rarg(x_10, x_11, x_14, x_3, x_4, x_5, x_6, x_7, x_8, x_9);

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

@@ -23,9 +23,12 @@ size_t lean_usize_add(size_t, size_t);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_compileDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_levelMVarToParamPreDeclsAux___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_EXPORT uint8_t l_Array_anyMUnsafe_any___at_Lean_Elab_addAndCompilePartialRec___spec__3(lean_object*, size_t, size_t);
+lean_object* l_Lean_stringToMessageData(lean_object*);
+LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn___lambda__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_addAsAxiom(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_instantiateMVarsAtPreDecls___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* l_Lean_throwError___at_Lean_Meta_setInlineAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 uint8_t lean_usize_dec_eq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
@@ -40,6 +43,8 @@ lean_object* lean_st_ref_get(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentArray_mapM___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentArray_mapMAux___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Elab_ensureNoRecFn___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Expr_isAppOf(lean_object*, lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 LEAN_EXPORT uint8_t l_Array_anyMUnsafe_any___at_Lean_Elab_addAndCompilePartialRec___spec__1(lean_object*, lean_object*, size_t, size_t);
@@ -60,8 +65,10 @@ LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_addAndCompileUnsa
 uint32_t lean_uint32_add(uint32_t, uint32_t);
 LEAN_EXPORT lean_object* l_Lean_Elab_addAndCompileUnsafe(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__12___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_Expr_FindImpl_findUnsafe_x3f(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_instInhabitedPreDefinition___closed__5;
 LEAN_EXPORT lean_object* l_Lean_Elab_applyAttributesOf(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_ensureNoRecFn___lambda__1___closed__3;
 lean_object* l_Lean_ConstantInfo_levelParams(lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_instantiateMVarsAtPreDecls___spec__1(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__12(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -72,6 +79,7 @@ static lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_addAndCompilePartialRe
 LEAN_EXPORT lean_object* l_Lean_Elab_levelMVarToParamPreDecls(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__10___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_forEachExpr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_eraseRecAppSyntaxExpr___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_addAndCompilePartialRec___spec__2___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_instInhabitedPreDefinition___closed__1;
@@ -103,6 +111,7 @@ static lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_compi
 LEAN_EXPORT lean_object* l_Std_PersistentArray_mapM___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getMaxHeight(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_abstractNestedProofs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Expr_isConstOf(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_getResetInfoTrees___at_Lean_Elab_Term_withoutModifyingElabMetaStateWithInfo___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_eraseRecAppSyntaxExpr___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -117,6 +126,7 @@ lean_object* l_Lean_addDecl___at_Lean_Elab_Term_evalExpr___spec__3(lean_object*,
 lean_object* l_Lean_Elab_Term_levelMVarToParam_x27(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_eraseRecAppSyntaxExpr___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_addAndCompileUnsafe___lambda__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_abstractNestedProofs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_addNonRec___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_addAsAxiom___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -124,6 +134,7 @@ LEAN_EXPORT lean_object* l_Array_anyMUnsafe_any___at_Lean_Elab_addAndCompilePart
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentArray_mapMAux___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_List_mapM___at_Lean_Elab_addAndCompileUnsafe___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_addAndCompileUnsafe___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_addTermInfo(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_EXPORT lean_object* l_Lean_Elab_applyAttributesOf___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -141,16 +152,22 @@ LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_addAndCompilePart
 LEAN_EXPORT lean_object* l_Lean_Elab_instantiateMVarsAtPreDecls(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_anyMUnsafe_any___at_Lean_Elab_fixLevelParams___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Elab_ensureNoRecFn(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_addAndCompileUnsafe___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_eraseRecAppSyntaxExpr(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_eraseRecAppSyntaxExpr___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_mkConstWithLevelParams___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_compileDecl___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_getLevelParamsPreDecls(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn___lambda__1___boxed(lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_ensureNoRecFn___lambda__1___closed__4;
+LEAN_EXPORT lean_object* l_Lean_Elab_ensureNoRecFn___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_ensureNoRecFn___lambda__1___closed__1;
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_fixLevelParams___spec__2___lambda__1(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_fixLevelParams(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__11(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_addAndCompileNonRec(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_indentExpr(lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentArray_mapMAux___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_levelMVarToParamPreDeclsAux___spec__1(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
@@ -162,6 +179,7 @@ LEAN_EXPORT lean_object* l_Lean_Elab_withSaveInfoContext___at___private_Lean_Ela
 LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_levelMVarToParamPreDeclsAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_applyAttributesOf___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_eraseRecAppSyntaxExpr___closed__1;
+static lean_object* l_Lean_Elab_ensureNoRecFn___lambda__1___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Elab_addAndCompileUnsafe___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___spec__7(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -6077,6 +6095,212 @@ x_7 = lean_box(x_6);
 return x_7;
 }
 }
+LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn___lambda__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; 
+x_3 = l_Lean_Expr_isConstOf(x_2, x_1);
+return x_3;
+}
+}
+LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; 
+x_3 = lean_alloc_closure((void*)(l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn___lambda__1___boxed), 2, 1);
+lean_closure_set(x_3, 0, x_1);
+x_4 = l_Lean_Expr_FindImpl_findUnsafe_x3f(x_3, x_2);
+if (lean_obj_tag(x_4) == 0)
+{
+uint8_t x_5; 
+x_5 = 0;
+return x_5;
+}
+else
+{
+uint8_t x_6; 
+lean_dec(x_4);
+x_6 = 1;
+return x_6;
+}
+}
+}
+LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn___lambda__1(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn(x_1, x_2);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+static lean_object* _init_l_Lean_Elab_ensureNoRecFn___lambda__1___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("unexpected occurrence of recursive application");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Elab_ensureNoRecFn___lambda__1___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Elab_ensureNoRecFn___lambda__1___closed__1;
+x_2 = l_Lean_stringToMessageData(x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Elab_ensureNoRecFn___lambda__1___closed__3() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Elab_ensureNoRecFn___lambda__1___closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Elab_ensureNoRecFn___lambda__1___closed__3;
+x_2 = l_Lean_stringToMessageData(x_1);
+return x_2;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Elab_ensureNoRecFn___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) {
+_start:
+{
+uint8_t x_8; 
+x_8 = l_Lean_Expr_isAppOf(x_2, x_1);
+if (x_8 == 0)
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_2);
+x_9 = lean_box(0);
+x_10 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_10, 0, x_9);
+lean_ctor_set(x_10, 1, x_7);
+return x_10;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+x_11 = l_Lean_indentExpr(x_2);
+x_12 = l_Lean_Elab_ensureNoRecFn___lambda__1___closed__2;
+x_13 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_13, 0, x_12);
+lean_ctor_set(x_13, 1, x_11);
+x_14 = l_Lean_Elab_ensureNoRecFn___lambda__1___closed__4;
+x_15 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_15, 0, x_13);
+lean_ctor_set(x_15, 1, x_14);
+x_16 = l_Lean_throwError___at_Lean_Meta_setInlineAttribute___spec__1(x_15, x_3, x_4, x_5, x_6, x_7);
+return x_16;
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Elab_ensureNoRecFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+_start:
+{
+uint8_t x_8; 
+lean_inc(x_2);
+lean_inc(x_1);
+x_8 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_containsRecFn(x_1, x_2);
+if (x_8 == 0)
+{
+lean_object* x_9; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_9 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_9, 0, x_2);
+lean_ctor_set(x_9, 1, x_7);
+return x_9;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; 
+x_10 = lean_alloc_closure((void*)(l_Lean_Elab_ensureNoRecFn___lambda__1___boxed), 7, 1);
+lean_closure_set(x_10, 0, x_1);
+lean_inc(x_2);
+x_11 = l_Lean_Meta_forEachExpr(x_2, x_10, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_11) == 0)
+{
+uint8_t x_12; 
+x_12 = !lean_is_exclusive(x_11);
+if (x_12 == 0)
+{
+lean_object* x_13; 
+x_13 = lean_ctor_get(x_11, 0);
+lean_dec(x_13);
+lean_ctor_set(x_11, 0, x_2);
+return x_11;
+}
+else
+{
+lean_object* x_14; lean_object* x_15; 
+x_14 = lean_ctor_get(x_11, 1);
+lean_inc(x_14);
+lean_dec(x_11);
+x_15 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_15, 0, x_2);
+lean_ctor_set(x_15, 1, x_14);
+return x_15;
+}
+}
+else
+{
+uint8_t x_16; 
+lean_dec(x_2);
+x_16 = !lean_is_exclusive(x_11);
+if (x_16 == 0)
+{
+return x_11;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+x_17 = lean_ctor_get(x_11, 0);
+x_18 = lean_ctor_get(x_11, 1);
+lean_inc(x_18);
+lean_inc(x_17);
+lean_dec(x_11);
+x_19 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_19, 0, x_17);
+lean_ctor_set(x_19, 1, x_18);
+return x_19;
+}
+}
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Elab_ensureNoRecFn___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) {
+_start:
+{
+lean_object* x_8; 
+x_8 = l_Lean_Elab_ensureNoRecFn___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_8;
+}
+}
 lean_object* initialize_Init(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Util_SCC(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Meta_AbstractNestedProofs(uint8_t builtin, lean_object*);
@@ -6139,6 +6363,14 @@ l_Array_mapMUnsafe_map___at_Lean_Elab_addAndCompilePartialRec___spec__2___lambda
 lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lean_Elab_addAndCompilePartialRec___spec__2___lambda__1___closed__1);
 l_Array_mapMUnsafe_map___at_Lean_Elab_addAndCompilePartialRec___spec__2___closed__1 = _init_l_Array_mapMUnsafe_map___at_Lean_Elab_addAndCompilePartialRec___spec__2___closed__1();
 lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lean_Elab_addAndCompilePartialRec___spec__2___closed__1);
+l_Lean_Elab_ensureNoRecFn___lambda__1___closed__1 = _init_l_Lean_Elab_ensureNoRecFn___lambda__1___closed__1();
+lean_mark_persistent(l_Lean_Elab_ensureNoRecFn___lambda__1___closed__1);
+l_Lean_Elab_ensureNoRecFn___lambda__1___closed__2 = _init_l_Lean_Elab_ensureNoRecFn___lambda__1___closed__2();
+lean_mark_persistent(l_Lean_Elab_ensureNoRecFn___lambda__1___closed__2);
+l_Lean_Elab_ensureNoRecFn___lambda__1___closed__3 = _init_l_Lean_Elab_ensureNoRecFn___lambda__1___closed__3();
+lean_mark_persistent(l_Lean_Elab_ensureNoRecFn___lambda__1___closed__3);
+l_Lean_Elab_ensureNoRecFn___lambda__1___closed__4 = _init_l_Lean_Elab_ensureNoRecFn___lambda__1___closed__4();
+lean_mark_persistent(l_Lean_Elab_ensureNoRecFn___lambda__1___closed__4);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus

stage0/stdlib/Lean/Elab/PreDefinition/Structural/Basic.c

@@ -16,45 +16,30 @@ extern "C" {
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_recArgHasLooseBVarsAt___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
-LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn(lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l_Lean_Elab_Structural_recArgHasLooseBVarsAt___lambda__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_Meta_setInlineAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__4;
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l_Lean_Elab_Structural_recArgHasLooseBVarsAt(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_RecArgInfo_recArgPos___boxed(lean_object*);
-LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn___lambda__1___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isAppOf(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Elab_Structural_instInhabitedM___spec__1(lean_object*);
 lean_object* l_Lean_Expr_getRevArg_x21(lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_FindImpl_findUnsafe_x3f(lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Elab_Structural_ensureNoRecFn___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Elab_Structural_instInhabitedM___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_forEachExpr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Structural_instInhabitedM___closed__2;
 static lean_object* l_Lean_Elab_Structural_instInhabitedM___closed__1;
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Elab_Structural_ensureNoRecFn(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__3;
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_recArgHasLooseBVarsAt___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Elab_Structural_instInhabitedM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn___boxed(lean_object*, lean_object*);
-uint8_t l_Lean_Expr_isConstOf(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_getAppNumArgsAux(lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__2;
-LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn___lambda__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_State_addMatchers___default;
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_run(lean_object*);
-static lean_object* l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__1;
-LEAN_EXPORT lean_object* l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_addMessageContextFull___at_Lean_Meta_instAddMessageContextMetaM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_hasLooseBVars(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_RecArgInfo_recArgPos(lean_object*);
-lean_object* l_Lean_indentExpr(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_instInhabitedM(lean_object*);
 static lean_object* l_Lean_Elab_Structural_State_addMatchers___default___closed__1;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -361,212 +346,6 @@ x_5 = lean_box(x_4);
 return x_5;
 }
 }
-LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn___lambda__1(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = l_Lean_Expr_isConstOf(x_2, x_1);
-return x_3;
-}
-}
-LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; lean_object* x_4; 
-x_3 = lean_alloc_closure((void*)(l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn___lambda__1___boxed), 2, 1);
-lean_closure_set(x_3, 0, x_1);
-x_4 = l_Lean_Expr_FindImpl_findUnsafe_x3f(x_3, x_2);
-if (lean_obj_tag(x_4) == 0)
-{
-uint8_t x_5; 
-x_5 = 0;
-return x_5;
-}
-else
-{
-uint8_t x_6; 
-lean_dec(x_4);
-x_6 = 1;
-return x_6;
-}
-}
-}
-LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn___lambda__1(x_1, x_2);
-lean_dec(x_2);
-lean_dec(x_1);
-x_4 = lean_box(x_3);
-return x_4;
-}
-}
-LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn(x_1, x_2);
-x_4 = lean_box(x_3);
-return x_4;
-}
-}
-static lean_object* _init_l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("unexpected occurrence of recursive application");
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__2() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__1;
-x_2 = l_Lean_stringToMessageData(x_1);
-return x_2;
-}
-}
-static lean_object* _init_l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__3() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("");
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__4() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__3;
-x_2 = l_Lean_stringToMessageData(x_1);
-return x_2;
-}
-}
-LEAN_EXPORT lean_object* l_Lean_Elab_Structural_ensureNoRecFn___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) {
-_start:
-{
-uint8_t x_8; 
-x_8 = l_Lean_Expr_isAppOf(x_2, x_1);
-if (x_8 == 0)
-{
-lean_object* x_9; lean_object* x_10; 
-lean_dec(x_2);
-x_9 = lean_box(0);
-x_10 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_10, 0, x_9);
-lean_ctor_set(x_10, 1, x_7);
-return x_10;
-}
-else
-{
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_11 = l_Lean_indentExpr(x_2);
-x_12 = l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__2;
-x_13 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_13, 0, x_12);
-lean_ctor_set(x_13, 1, x_11);
-x_14 = l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__4;
-x_15 = lean_alloc_ctor(10, 2, 0);
-lean_ctor_set(x_15, 0, x_13);
-lean_ctor_set(x_15, 1, x_14);
-x_16 = l_Lean_throwError___at_Lean_Meta_setInlineAttribute___spec__1(x_15, x_3, x_4, x_5, x_6, x_7);
-return x_16;
-}
-}
-}
-LEAN_EXPORT lean_object* l_Lean_Elab_Structural_ensureNoRecFn(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
-_start:
-{
-uint8_t x_8; 
-lean_inc(x_2);
-lean_inc(x_1);
-x_8 = l___private_Lean_Elab_PreDefinition_Structural_Basic_0__Lean_Elab_Structural_containsRecFn(x_1, x_2);
-if (x_8 == 0)
-{
-lean_object* x_9; 
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-x_9 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_9, 0, x_2);
-lean_ctor_set(x_9, 1, x_7);
-return x_9;
-}
-else
-{
-lean_object* x_10; lean_object* x_11; 
-x_10 = lean_alloc_closure((void*)(l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___boxed), 7, 1);
-lean_closure_set(x_10, 0, x_1);
-lean_inc(x_2);
-x_11 = l_Lean_Meta_forEachExpr(x_2, x_10, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_11) == 0)
-{
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_11);
-if (x_12 == 0)
-{
-lean_object* x_13; 
-x_13 = lean_ctor_get(x_11, 0);
-lean_dec(x_13);
-lean_ctor_set(x_11, 0, x_2);
-return x_11;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; 
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-lean_dec(x_11);
-x_15 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_15, 0, x_2);
-lean_ctor_set(x_15, 1, x_14);
-return x_15;
-}
-}
-else
-{
-uint8_t x_16; 
-lean_dec(x_2);
-x_16 = !lean_is_exclusive(x_11);
-if (x_16 == 0)
-{
-return x_11;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_17 = lean_ctor_get(x_11, 0);
-x_18 = lean_ctor_get(x_11, 1);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_dec(x_11);
-x_19 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_19, 0, x_17);
-lean_ctor_set(x_19, 1, x_18);
-return x_19;
-}
-}
-}
-}
-}
-LEAN_EXPORT lean_object* l_Lean_Elab_Structural_ensureNoRecFn___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) {
-_start:
-{
-lean_object* x_8; 
-x_8 = l_Lean_Elab_Structural_ensureNoRecFn___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_8;
-}
-}
 lean_object* initialize_Init(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Meta_Basic(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Meta_ForEachExpr(uint8_t builtin, lean_object*);
@@ -592,14 +371,6 @@ l_Lean_Elab_Structural_instInhabitedM___closed__1 = _init_l_Lean_Elab_Structural
 lean_mark_persistent(l_Lean_Elab_Structural_instInhabitedM___closed__1);
 l_Lean_Elab_Structural_instInhabitedM___closed__2 = _init_l_Lean_Elab_Structural_instInhabitedM___closed__2();
 lean_mark_persistent(l_Lean_Elab_Structural_instInhabitedM___closed__2);
-l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__1 = _init_l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__1();
-lean_mark_persistent(l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__1);
-l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__2 = _init_l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__2();
-lean_mark_persistent(l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__2);
-l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__3 = _init_l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__3();
-lean_mark_persistent(l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__3);
-l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__4 = _init_l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__4();
-lean_mark_persistent(l_Lean_Elab_Structural_ensureNoRecFn___lambda__1___closed__4);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus

stage0/stdlib/Lean/Elab/PreDefinition/Structural/IndPred.c

@@ -97,7 +97,6 @@ LEAN_EXPORT lean_object* l_Lean_Elab_Structural_mkIndPredBRecOn___lambda__5(lean
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_mkIndPredBRecOn___lambda__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*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_withLocalDecl___at___private_Lean_Elab_PreDefinition_Structural_IndPred_0__Lean_Elab_Structural_replaceIndPredRecApps_loop___spec__9___rarg___boxed(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_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Structural_ensureNoRecFn(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_PreDefinition_Structural_IndPred_0__Lean_Elab_Structural_replaceIndPredRecApps_loop___lambda__2___closed__1;
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Structural_IndPred_0__Lean_Elab_Structural_replaceIndPredRecApps_loop___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_addTrace___at___private_Lean_Elab_PreDefinition_Structural_IndPred_0__Lean_Elab_Structural_replaceIndPredRecApps_loop___spec__7___closed__4;
@@ -165,6 +164,7 @@ LEAN_EXPORT lean_object* l_Lean_Elab_Structural_mkIndPredBRecOn___lambda__1(lean
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_PreDefinition_Structural_IndPred_0__Lean_Elab_Structural_replaceIndPredRecApps_loop___spec__5(lean_object*, 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_EXPORT lean_object* l_Lean_Elab_Structural_mkIndPredBRecOn___lambda__3___boxed(lean_object**);
 lean_object* l_Lean_Meta_IndPredBelow_findBelowIdx(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_ensureNoRecFn(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_brecOnSuffix;
 lean_object* l_Lean_Expr_getAppFn(lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_IndPred_0__Lean_Elab_Structural_replaceIndPredRecApps_loop___lambda__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*);
@@ -3419,7 +3419,7 @@ lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_137 = l_Lean_Elab_Structural_ensureNoRecFn(x_1, x_5, x_7, x_8, x_9, x_10, x_11);
+x_137 = l_Lean_Elab_ensureNoRecFn(x_1, x_5, x_7, x_8, x_9, x_10, x_11);
 return x_137;
 }
 }

stage0/stdlib/Lean/Elab/PreDefinition/Structural/Main.c

@@ -62,7 +62,6 @@ lean_object* lean_nat_sub(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Structural_structuralRecursion___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_EXPORT lean_object* l_Lean_Elab_Structural_structuralRecursion___lambda__1(lean_object*);
 lean_object* l_Lean_Elab_Structural_preprocess(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_Structural_BRecOn_0__Lean_Elab_Structural_replaceRecApps_loop___spec__13___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkLambdaFVars(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_elimRecursion___closed__3;
@@ -70,13 +69,13 @@ lean_object* l_Nat_repr(lean_object*);
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Structural_structuralRecursion___closed__3;
 LEAN_EXPORT lean_object* l_Lean_setEnv___at___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_elimRecursion___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Elab_Structural_ensureNoRecFn(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_elimRecursion___lambda__2___closed__1;
 LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_elimRecursion___lambda__2___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*);
 extern lean_object* l_Lean_Elab_instInhabitedPreDefinition;
 lean_object* lean_array_to_list(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_elimRecursion___lambda__2___closed__2;
 static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_elimRecursion___closed__7;
+lean_object* l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_Structural_BRecOn_0__Lean_Elab_Structural_replaceRecApps_loop___spec__16___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Structural_structuralRecursion___lambda__1___closed__2;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_getFixedPrefix___spec__1___boxed(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_PreDefinition_Structural_Main_0__Lean_Elab_Structural_elimRecursion___lambda__2___closed__4;
@@ -110,6 +109,7 @@ lean_object* l_Lean_addTrace___at___private_Lean_Elab_PreDefinition_Structural_I
 static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_getFixedPrefix___lambda__2___closed__2;
 lean_object* l_Lean_Elab_Structural_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_indentD(lean_object*);
+lean_object* l_Lean_Elab_ensureNoRecFn(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Structural_addSmartUnfoldingDef(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_elimRecursion(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Main_0__Lean_Elab_Structural_elimRecursion___lambda__6___closed__2;
@@ -1221,7 +1221,7 @@ _start:
 {
 lean_object* x_12; 
 lean_inc(x_1);
-x_12 = l_Lean_Elab_Structural_ensureNoRecFn(x_1, x_2, x_7, x_8, x_9, x_10, x_11);
+x_12 = l_Lean_Elab_ensureNoRecFn(x_1, x_2, x_7, x_8, x_9, x_10, x_11);
 if (lean_obj_tag(x_12) == 0)
 {
 uint8_t x_13; 
@@ -2006,7 +2006,7 @@ lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-x_16 = l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_Structural_BRecOn_0__Lean_Elab_Structural_replaceRecApps_loop___spec__13___rarg(x_10, x_11, x_4, x_5, x_6, x_7, x_8, x_14);
+x_16 = l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_Structural_BRecOn_0__Lean_Elab_Structural_replaceRecApps_loop___spec__16___rarg(x_10, x_11, x_4, x_5, x_6, x_7, x_8, x_14);
 if (lean_obj_tag(x_16) == 0)
 {
 lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 

stage0/stdlib/Lean/Elab/PreDefinition/Structural/Preprocess.c

@@ -21,7 +21,7 @@ LEAN_EXPORT lean_object* l_Lean_Elab_Structural_preprocess___lambda__2(lean_obje
 LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_Preprocess_0__Lean_Elab_Structural_shouldBetaReduce___lambda__1___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_preprocess(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_headBeta(lean_object*);
-uint8_t l_Lean_Expr_isHeadBetaTarget(lean_object*);
+uint8_t l_Lean_Expr_isHeadBetaTarget(lean_object*, uint8_t);
 LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Structural_Preprocess_0__Lean_Elab_Structural_shouldBetaReduce___lambda__1(lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Structural_preprocess___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Elab_Structural_preprocess___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -40,35 +40,36 @@ return x_3;
 LEAN_EXPORT uint8_t l___private_Lean_Elab_PreDefinition_Structural_Preprocess_0__Lean_Elab_Structural_shouldBetaReduce(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_3; 
-x_3 = l_Lean_Expr_isHeadBetaTarget(x_1);
-if (x_3 == 0)
+uint8_t x_3; uint8_t x_4; 
+x_3 = 0;
+x_4 = l_Lean_Expr_isHeadBetaTarget(x_1, x_3);
+if (x_4 == 0)
 {
-uint8_t x_4; 
+uint8_t x_5; 
 lean_dec(x_2);
-x_4 = 0;
-return x_4;
+x_5 = 0;
+return x_5;
 }
 else
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_5 = lean_alloc_closure((void*)(l___private_Lean_Elab_PreDefinition_Structural_Preprocess_0__Lean_Elab_Structural_shouldBetaReduce___lambda__1___boxed), 2, 1);
-lean_closure_set(x_5, 0, x_2);
-x_6 = l_Lean_Expr_getAppFn(x_1);
-x_7 = l_Lean_Expr_FindImpl_findUnsafe_x3f(x_5, x_6);
-if (lean_obj_tag(x_7) == 0)
-{
-uint8_t x_8; 
-x_8 = 0;
-return x_8;
-}
-else
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_6 = lean_alloc_closure((void*)(l___private_Lean_Elab_PreDefinition_Structural_Preprocess_0__Lean_Elab_Structural_shouldBetaReduce___lambda__1___boxed), 2, 1);
+lean_closure_set(x_6, 0, x_2);
+x_7 = l_Lean_Expr_getAppFn(x_1);
+x_8 = l_Lean_Expr_FindImpl_findUnsafe_x3f(x_6, x_7);
+if (lean_obj_tag(x_8) == 0)
 {
 uint8_t x_9; 
-lean_dec(x_7);
-x_9 = 1;
+x_9 = 0;
 return x_9;
 }
+else
+{
+uint8_t x_10; 
+lean_dec(x_8);
+x_10 = 1;
+return x_10;
+}
 }
 }
 }

stage0/stdlib/Lean/Elab/PreDefinition/WF/Main.c

@@ -104,6 +104,7 @@ static lean_object* l_Lean_Elab_wfRecursion___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Elab_wfRecursion(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___private_Lean_Elab_PreDefinition_WF_Main_0__Lean_Elab_addNonRecPreDefs___spec__2___closed__8;
 lean_object* l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_WF_Fix_0__Lean_Elab_WF_replaceRecApps_loop___spec__12___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Expr_withAppAux___at___private_Lean_Elab_PreDefinition_WF_Main_0__Lean_Elab_addNonRecPreDefs_mkSum___spec__1___closed__9;
 lean_object* lean_panic_fn(lean_object*, lean_object*);
 lean_object* lean_mk_array(lean_object*, lean_object*);
@@ -117,7 +118,6 @@ lean_object* l_Lean_Elab_WF_mkFix(lean_object*, lean_object*, lean_object*, lean
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_wfRecursion___spec__2___closed__1;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_wfRecursion___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_WF_Fix_0__Lean_Elab_WF_replaceRecApps_loop___spec__9___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Expr_withAppAux___at___private_Lean_Elab_PreDefinition_WF_Main_0__Lean_Elab_addNonRecPreDefs_mkSum___spec__1___closed__8;
 lean_object* l_Lean_mkApp3(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Expr_withAppAux___at___private_Lean_Elab_PreDefinition_WF_Main_0__Lean_Elab_addNonRecPreDefs_mkSum___spec__1___closed__2;
@@ -909,7 +909,7 @@ lean_inc(x_13);
 lean_inc(x_12);
 lean_inc(x_11);
 lean_inc(x_10);
-x_32 = l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_WF_Fix_0__Lean_Elab_WF_replaceRecApps_loop___spec__9___rarg(x_30, x_31, x_10, x_11, x_12, x_13, x_14, x_15, x_16);
+x_32 = l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_PreDefinition_WF_Fix_0__Lean_Elab_WF_replaceRecApps_loop___spec__12___rarg(x_30, x_31, x_10, x_11, x_12, x_13, x_14, x_15, x_16);
 if (lean_obj_tag(x_32) == 0)
 {
 lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; lean_object* x_37; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; 

stage0/stdlib/Lean/Elab/StructInst.c

@@ -548,7 +548,7 @@ lean_object* l_Lean_mkApp(lean_object*, lean_object*);
 lean_object* l_Lean_getDefaultFnForField_x3f(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_StructInst_Struct_source___boxed(lean_object*);
 static lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandNonAtomicExplicitSources_go___lambda__1___closed__7;
-lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*, uint8_t);
 static lean_object* l_Lean_Elab_Term_StructInst_formatField___closed__2;
 static lean_object* l_List_format___at_Lean_Elab_Term_StructInst_formatStruct___spec__3___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_StructInst_Struct_setFields___lambda__1___boxed(lean_object*, lean_object*);
@@ -19780,68 +19780,68 @@ return x_57;
 }
 else
 {
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
+lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; 
 x_58 = lean_unsigned_to_nat(0u);
 x_59 = l_Lean_Expr_getAppNumArgsAux(x_2, x_58);
 x_60 = lean_mk_empty_array_with_capacity(x_59);
 lean_dec(x_59);
 x_61 = l___private_Lean_Expr_0__Lean_Expr_getAppRevArgsAux(x_2, x_60);
-x_62 = l_Lean_Expr_betaRev(x_33, x_61);
+x_62 = 0;
+x_63 = l_Lean_Expr_betaRev(x_33, x_61, x_62);
 lean_dec(x_61);
-lean_dec(x_33);
-x_2 = x_62;
+x_2 = x_63;
 x_7 = x_34;
 goto _start;
 }
 }
 else
 {
-uint8_t x_64; 
+uint8_t x_65; 
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_64 = !lean_is_exclusive(x_32);
-if (x_64 == 0)
+x_65 = !lean_is_exclusive(x_32);
+if (x_65 == 0)
 {
 return x_32;
 }
 else
 {
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-x_65 = lean_ctor_get(x_32, 0);
-x_66 = lean_ctor_get(x_32, 1);
+lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+x_66 = lean_ctor_get(x_32, 0);
+x_67 = lean_ctor_get(x_32, 1);
+lean_inc(x_67);
 lean_inc(x_66);
-lean_inc(x_65);
 lean_dec(x_32);
-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;
+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;
 }
 }
 }
 else
 {
-lean_object* x_68; lean_object* x_69; 
+lean_object* x_69; lean_object* x_70; 
 lean_dec(x_26);
 lean_dec(x_2);
-x_68 = lean_ctor_get(x_28, 1);
-lean_inc(x_68);
-lean_dec(x_28);
-x_69 = lean_ctor_get(x_29, 0);
+x_69 = lean_ctor_get(x_28, 1);
 lean_inc(x_69);
+lean_dec(x_28);
+x_70 = lean_ctor_get(x_29, 0);
+lean_inc(x_70);
 lean_dec(x_29);
-x_2 = x_69;
-x_7 = x_68;
+x_2 = x_70;
+x_7 = x_69;
 goto _start;
 }
 }
 else
 {
-uint8_t x_71; 
+uint8_t x_72; 
 lean_dec(x_26);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -19849,524 +19849,524 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_71 = !lean_is_exclusive(x_28);
-if (x_71 == 0)
+x_72 = !lean_is_exclusive(x_28);
+if (x_72 == 0)
 {
 return x_28;
 }
 else
 {
-lean_object* x_72; lean_object* x_73; lean_object* x_74; 
-x_72 = lean_ctor_get(x_28, 0);
-x_73 = lean_ctor_get(x_28, 1);
+lean_object* x_73; lean_object* x_74; lean_object* x_75; 
+x_73 = lean_ctor_get(x_28, 0);
+x_74 = lean_ctor_get(x_28, 1);
+lean_inc(x_74);
 lean_inc(x_73);
-lean_inc(x_72);
 lean_dec(x_28);
-x_74 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_74, 0, x_72);
-lean_ctor_set(x_74, 1, x_73);
-return x_74;
+x_75 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_75, 0, x_73);
+lean_ctor_set(x_75, 1, x_74);
+return x_75;
 }
 }
 }
 case 6:
 {
-lean_object* x_75; lean_object* x_76; 
-x_75 = lean_alloc_closure((void*)(l_Lean_Elab_Term_StructInst_DefaultFields_reduce___lambda__1), 8, 1);
-lean_closure_set(x_75, 0, x_1);
-x_76 = l_Lean_Meta_lambdaLetTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferLambdaType___spec__1___rarg(x_2, x_75, x_3, x_4, x_5, x_6, x_7);
-return x_76;
+lean_object* x_76; lean_object* x_77; 
+x_76 = lean_alloc_closure((void*)(l_Lean_Elab_Term_StructInst_DefaultFields_reduce___lambda__1), 8, 1);
+lean_closure_set(x_76, 0, x_1);
+x_77 = l_Lean_Meta_lambdaLetTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferLambdaType___spec__1___rarg(x_2, x_76, x_3, x_4, x_5, x_6, x_7);
+return x_77;
 }
 case 7:
 {
-lean_object* x_77; lean_object* x_78; 
-x_77 = lean_alloc_closure((void*)(l_Lean_Elab_Term_StructInst_DefaultFields_reduce___lambda__2), 8, 1);
-lean_closure_set(x_77, 0, x_1);
-x_78 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_2, x_77, x_3, x_4, x_5, x_6, x_7);
-return x_78;
+lean_object* x_78; lean_object* x_79; 
+x_78 = lean_alloc_closure((void*)(l_Lean_Elab_Term_StructInst_DefaultFields_reduce___lambda__2), 8, 1);
+lean_closure_set(x_78, 0, x_1);
+x_79 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_2, x_78, x_3, x_4, x_5, x_6, x_7);
+return x_79;
 }
 case 8:
 {
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_alloc_closure((void*)(l_Lean_Elab_Term_StructInst_DefaultFields_reduce___lambda__1), 8, 1);
-lean_closure_set(x_79, 0, x_1);
-x_80 = l_Lean_Meta_lambdaLetTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferLambdaType___spec__1___rarg(x_2, x_79, x_3, x_4, x_5, x_6, x_7);
-return x_80;
+lean_object* x_80; lean_object* x_81; 
+x_80 = lean_alloc_closure((void*)(l_Lean_Elab_Term_StructInst_DefaultFields_reduce___lambda__1), 8, 1);
+lean_closure_set(x_80, 0, x_1);
+x_81 = l_Lean_Meta_lambdaLetTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferLambdaType___spec__1___rarg(x_2, x_80, x_3, x_4, x_5, x_6, x_7);
+return x_81;
 }
 case 10:
 {
-lean_object* x_81; lean_object* x_82; uint64_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_2, 0);
-lean_inc(x_81);
-x_82 = lean_ctor_get(x_2, 1);
+lean_object* x_82; lean_object* x_83; uint64_t x_84; lean_object* x_85; 
+x_82 = lean_ctor_get(x_2, 0);
 lean_inc(x_82);
-x_83 = lean_ctor_get_uint64(x_2, sizeof(void*)*2);
-lean_inc(x_82);
-x_84 = l_Lean_Elab_Term_StructInst_DefaultFields_reduce(x_1, x_82, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_84) == 0)
+x_83 = lean_ctor_get(x_2, 1);
+lean_inc(x_83);
+x_84 = lean_ctor_get_uint64(x_2, sizeof(void*)*2);
+lean_inc(x_83);
+x_85 = l_Lean_Elab_Term_StructInst_DefaultFields_reduce(x_1, x_83, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_85) == 0)
 {
-uint8_t x_85; 
-x_85 = !lean_is_exclusive(x_84);
-if (x_85 == 0)
+uint8_t x_86; 
+x_86 = !lean_is_exclusive(x_85);
+if (x_86 == 0)
 {
-lean_object* x_86; lean_object* x_87; uint8_t x_88; 
-x_86 = lean_ctor_get(x_84, 0);
-x_87 = l_Lean_Elab_Term_StructInst_defaultMissing_x3f(x_2);
-x_88 = !lean_is_exclusive(x_2);
-if (x_88 == 0)
+lean_object* x_87; lean_object* x_88; uint8_t x_89; 
+x_87 = lean_ctor_get(x_85, 0);
+x_88 = l_Lean_Elab_Term_StructInst_defaultMissing_x3f(x_2);
+x_89 = !lean_is_exclusive(x_2);
+if (x_89 == 0)
 {
-lean_object* x_89; lean_object* x_90; 
-x_89 = lean_ctor_get(x_2, 1);
-lean_dec(x_89);
-x_90 = lean_ctor_get(x_2, 0);
+lean_object* x_90; lean_object* x_91; 
+x_90 = lean_ctor_get(x_2, 1);
 lean_dec(x_90);
-if (lean_obj_tag(x_87) == 0)
+x_91 = lean_ctor_get(x_2, 0);
+lean_dec(x_91);
+if (lean_obj_tag(x_88) == 0)
 {
-lean_object* x_91; 
-x_91 = lean_expr_update_mdata(x_2, x_86);
-lean_ctor_set(x_84, 0, x_91);
-return x_84;
+lean_object* x_92; 
+x_92 = lean_expr_update_mdata(x_2, x_87);
+lean_ctor_set(x_85, 0, x_92);
+return x_85;
 }
 else
 {
-uint8_t x_92; 
-lean_dec(x_87);
-x_92 = l_Lean_Expr_isMVar(x_86);
-if (x_92 == 0)
+uint8_t x_93; 
+lean_dec(x_88);
+x_93 = l_Lean_Expr_isMVar(x_87);
+if (x_93 == 0)
 {
 lean_free_object(x_2);
+lean_dec(x_83);
 lean_dec(x_82);
-lean_dec(x_81);
-return x_84;
+return x_85;
 }
 else
 {
-lean_object* x_93; 
-x_93 = lean_expr_update_mdata(x_2, x_86);
-lean_ctor_set(x_84, 0, x_93);
-return x_84;
+lean_object* x_94; 
+x_94 = lean_expr_update_mdata(x_2, x_87);
+lean_ctor_set(x_85, 0, x_94);
+return x_85;
 }
 }
 }
 else
 {
 lean_dec(x_2);
-if (lean_obj_tag(x_87) == 0)
+if (lean_obj_tag(x_88) == 0)
 {
-lean_object* x_94; lean_object* x_95; 
-x_94 = lean_alloc_ctor(10, 2, 8);
-lean_ctor_set(x_94, 0, x_81);
-lean_ctor_set(x_94, 1, x_82);
-lean_ctor_set_uint64(x_94, sizeof(void*)*2, x_83);
-x_95 = lean_expr_update_mdata(x_94, x_86);
-lean_ctor_set(x_84, 0, x_95);
-return x_84;
+lean_object* x_95; lean_object* x_96; 
+x_95 = lean_alloc_ctor(10, 2, 8);
+lean_ctor_set(x_95, 0, x_82);
+lean_ctor_set(x_95, 1, x_83);
+lean_ctor_set_uint64(x_95, sizeof(void*)*2, x_84);
+x_96 = lean_expr_update_mdata(x_95, x_87);
+lean_ctor_set(x_85, 0, x_96);
+return x_85;
 }
 else
 {
-uint8_t x_96; 
-lean_dec(x_87);
-x_96 = l_Lean_Expr_isMVar(x_86);
-if (x_96 == 0)
+uint8_t x_97; 
+lean_dec(x_88);
+x_97 = l_Lean_Expr_isMVar(x_87);
+if (x_97 == 0)
 {
+lean_dec(x_83);
 lean_dec(x_82);
-lean_dec(x_81);
-return x_84;
+return x_85;
 }
 else
 {
-lean_object* x_97; lean_object* x_98; 
-x_97 = lean_alloc_ctor(10, 2, 8);
-lean_ctor_set(x_97, 0, x_81);
-lean_ctor_set(x_97, 1, x_82);
-lean_ctor_set_uint64(x_97, sizeof(void*)*2, x_83);
-x_98 = lean_expr_update_mdata(x_97, x_86);
-lean_ctor_set(x_84, 0, x_98);
-return x_84;
+lean_object* x_98; lean_object* x_99; 
+x_98 = lean_alloc_ctor(10, 2, 8);
+lean_ctor_set(x_98, 0, x_82);
+lean_ctor_set(x_98, 1, x_83);
+lean_ctor_set_uint64(x_98, sizeof(void*)*2, x_84);
+x_99 = lean_expr_update_mdata(x_98, x_87);
+lean_ctor_set(x_85, 0, x_99);
+return x_85;
 }
 }
 }
 }
 else
 {
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; 
-x_99 = lean_ctor_get(x_84, 0);
-x_100 = lean_ctor_get(x_84, 1);
+lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; 
+x_100 = lean_ctor_get(x_85, 0);
+x_101 = lean_ctor_get(x_85, 1);
+lean_inc(x_101);
 lean_inc(x_100);
-lean_inc(x_99);
-lean_dec(x_84);
-x_101 = l_Lean_Elab_Term_StructInst_defaultMissing_x3f(x_2);
+lean_dec(x_85);
+x_102 = l_Lean_Elab_Term_StructInst_defaultMissing_x3f(x_2);
 if (lean_is_exclusive(x_2)) {
  lean_ctor_release(x_2, 0);
  lean_ctor_release(x_2, 1);
- x_102 = x_2;
+ x_103 = x_2;
 } else {
  lean_dec_ref(x_2);
- x_102 = lean_box(0);
+ x_103 = lean_box(0);
 }
-if (lean_obj_tag(x_101) == 0)
+if (lean_obj_tag(x_102) == 0)
 {
-lean_object* x_103; lean_object* x_104; lean_object* x_105; 
-if (lean_is_scalar(x_102)) {
- x_103 = lean_alloc_ctor(10, 2, 8);
+lean_object* x_104; lean_object* x_105; lean_object* x_106; 
+if (lean_is_scalar(x_103)) {
+ x_104 = lean_alloc_ctor(10, 2, 8);
 } else {
- x_103 = x_102;
+ x_104 = x_103;
 }
-lean_ctor_set(x_103, 0, x_81);
-lean_ctor_set(x_103, 1, x_82);
-lean_ctor_set_uint64(x_103, sizeof(void*)*2, x_83);
-x_104 = lean_expr_update_mdata(x_103, x_99);
-x_105 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_105, 0, x_104);
-lean_ctor_set(x_105, 1, x_100);
-return x_105;
+lean_ctor_set(x_104, 0, x_82);
+lean_ctor_set(x_104, 1, x_83);
+lean_ctor_set_uint64(x_104, sizeof(void*)*2, x_84);
+x_105 = lean_expr_update_mdata(x_104, x_100);
+x_106 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_106, 0, x_105);
+lean_ctor_set(x_106, 1, x_101);
+return x_106;
 }
 else
 {
-uint8_t x_106; 
-lean_dec(x_101);
-x_106 = l_Lean_Expr_isMVar(x_99);
-if (x_106 == 0)
-{
-lean_object* x_107; 
+uint8_t x_107; 
 lean_dec(x_102);
+x_107 = l_Lean_Expr_isMVar(x_100);
+if (x_107 == 0)
+{
+lean_object* x_108; 
+lean_dec(x_103);
+lean_dec(x_83);
 lean_dec(x_82);
-lean_dec(x_81);
-x_107 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_107, 0, x_99);
-lean_ctor_set(x_107, 1, x_100);
-return x_107;
+x_108 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_108, 0, x_100);
+lean_ctor_set(x_108, 1, x_101);
+return x_108;
 }
 else
 {
-lean_object* x_108; lean_object* x_109; lean_object* x_110; 
-if (lean_is_scalar(x_102)) {
- x_108 = lean_alloc_ctor(10, 2, 8);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; 
+if (lean_is_scalar(x_103)) {
+ x_109 = lean_alloc_ctor(10, 2, 8);
 } else {
- x_108 = x_102;
+ x_109 = x_103;
 }
-lean_ctor_set(x_108, 0, x_81);
-lean_ctor_set(x_108, 1, x_82);
-lean_ctor_set_uint64(x_108, sizeof(void*)*2, x_83);
-x_109 = lean_expr_update_mdata(x_108, x_99);
-x_110 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_110, 0, x_109);
-lean_ctor_set(x_110, 1, x_100);
-return x_110;
+lean_ctor_set(x_109, 0, x_82);
+lean_ctor_set(x_109, 1, x_83);
+lean_ctor_set_uint64(x_109, sizeof(void*)*2, x_84);
+x_110 = lean_expr_update_mdata(x_109, x_100);
+x_111 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_111, 0, x_110);
+lean_ctor_set(x_111, 1, x_101);
+return x_111;
 }
 }
 }
 }
 else
 {
-uint8_t x_111; 
+uint8_t x_112; 
+lean_dec(x_83);
 lean_dec(x_82);
-lean_dec(x_81);
 lean_dec(x_2);
-x_111 = !lean_is_exclusive(x_84);
-if (x_111 == 0)
+x_112 = !lean_is_exclusive(x_85);
+if (x_112 == 0)
 {
-return x_84;
+return x_85;
 }
 else
 {
-lean_object* x_112; lean_object* x_113; lean_object* x_114; 
-x_112 = lean_ctor_get(x_84, 0);
-x_113 = lean_ctor_get(x_84, 1);
+lean_object* x_113; lean_object* x_114; lean_object* x_115; 
+x_113 = lean_ctor_get(x_85, 0);
+x_114 = lean_ctor_get(x_85, 1);
+lean_inc(x_114);
 lean_inc(x_113);
-lean_inc(x_112);
-lean_dec(x_84);
-x_114 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_114, 0, x_112);
-lean_ctor_set(x_114, 1, x_113);
-return x_114;
+lean_dec(x_85);
+x_115 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_115, 0, x_113);
+lean_ctor_set(x_115, 1, x_114);
+return x_115;
 }
 }
 }
 case 11:
 {
-uint8_t x_115; 
-x_115 = !lean_is_exclusive(x_2);
-if (x_115 == 0)
+uint8_t x_116; 
+x_116 = !lean_is_exclusive(x_2);
+if (x_116 == 0)
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_2, 0);
-x_117 = lean_ctor_get(x_2, 1);
-x_118 = lean_ctor_get(x_2, 2);
+lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; 
+x_117 = lean_ctor_get(x_2, 0);
+x_118 = lean_ctor_get(x_2, 1);
+x_119 = lean_ctor_get(x_2, 2);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_118);
-x_119 = l_Lean_Meta_project_x3f(x_118, x_117, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_119) == 0)
-{
-lean_object* x_120; 
-x_120 = lean_ctor_get(x_119, 0);
-lean_inc(x_120);
+lean_inc(x_119);
+x_120 = l_Lean_Meta_project_x3f(x_119, x_118, x_3, x_4, x_5, x_6, x_7);
 if (lean_obj_tag(x_120) == 0)
 {
-lean_object* x_121; lean_object* x_122; 
-x_121 = lean_ctor_get(x_119, 1);
+lean_object* x_121; 
+x_121 = lean_ctor_get(x_120, 0);
 lean_inc(x_121);
-lean_dec(x_119);
-lean_inc(x_118);
-x_122 = l_Lean_Elab_Term_StructInst_DefaultFields_reduce(x_1, x_118, x_3, x_4, x_5, x_6, x_121);
-if (lean_obj_tag(x_122) == 0)
+if (lean_obj_tag(x_121) == 0)
 {
-uint8_t x_123; 
-x_123 = !lean_is_exclusive(x_122);
-if (x_123 == 0)
+lean_object* x_122; lean_object* x_123; 
+x_122 = lean_ctor_get(x_120, 1);
+lean_inc(x_122);
+lean_dec(x_120);
+lean_inc(x_119);
+x_123 = l_Lean_Elab_Term_StructInst_DefaultFields_reduce(x_1, x_119, x_3, x_4, x_5, x_6, x_122);
+if (lean_obj_tag(x_123) == 0)
 {
-lean_object* x_124; lean_object* x_125; 
-x_124 = lean_ctor_get(x_122, 0);
-x_125 = lean_expr_update_proj(x_2, x_124);
-lean_ctor_set(x_122, 0, x_125);
-return x_122;
+uint8_t x_124; 
+x_124 = !lean_is_exclusive(x_123);
+if (x_124 == 0)
+{
+lean_object* x_125; lean_object* x_126; 
+x_125 = lean_ctor_get(x_123, 0);
+x_126 = lean_expr_update_proj(x_2, x_125);
+lean_ctor_set(x_123, 0, x_126);
+return x_123;
 }
 else
 {
-lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; 
-x_126 = lean_ctor_get(x_122, 0);
-x_127 = lean_ctor_get(x_122, 1);
+lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; 
+x_127 = lean_ctor_get(x_123, 0);
+x_128 = lean_ctor_get(x_123, 1);
+lean_inc(x_128);
 lean_inc(x_127);
-lean_inc(x_126);
-lean_dec(x_122);
-x_128 = lean_expr_update_proj(x_2, x_126);
-x_129 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_129, 0, x_128);
-lean_ctor_set(x_129, 1, x_127);
-return x_129;
+lean_dec(x_123);
+x_129 = lean_expr_update_proj(x_2, x_127);
+x_130 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_130, 0, x_129);
+lean_ctor_set(x_130, 1, x_128);
+return x_130;
 }
 }
 else
 {
-uint8_t x_130; 
+uint8_t x_131; 
 lean_free_object(x_2);
-lean_dec(x_118);
-lean_dec(x_117);
-lean_dec(x_116);
-x_130 = !lean_is_exclusive(x_122);
-if (x_130 == 0)
-{
-return x_122;
-}
-else
-{
-lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_131 = lean_ctor_get(x_122, 0);
-x_132 = lean_ctor_get(x_122, 1);
-lean_inc(x_132);
-lean_inc(x_131);
-lean_dec(x_122);
-x_133 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_133, 0, x_131);
-lean_ctor_set(x_133, 1, x_132);
-return x_133;
-}
-}
-}
-else
-{
-lean_object* x_134; lean_object* x_135; 
-lean_free_object(x_2);
-lean_dec(x_118);
-lean_dec(x_117);
-lean_dec(x_116);
-x_134 = lean_ctor_get(x_119, 1);
-lean_inc(x_134);
 lean_dec(x_119);
-x_135 = lean_ctor_get(x_120, 0);
+lean_dec(x_118);
+lean_dec(x_117);
+x_131 = !lean_is_exclusive(x_123);
+if (x_131 == 0)
+{
+return x_123;
+}
+else
+{
+lean_object* x_132; lean_object* x_133; lean_object* x_134; 
+x_132 = lean_ctor_get(x_123, 0);
+x_133 = lean_ctor_get(x_123, 1);
+lean_inc(x_133);
+lean_inc(x_132);
+lean_dec(x_123);
+x_134 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_134, 0, x_132);
+lean_ctor_set(x_134, 1, x_133);
+return x_134;
+}
+}
+}
+else
+{
+lean_object* x_135; lean_object* x_136; 
+lean_free_object(x_2);
+lean_dec(x_119);
+lean_dec(x_118);
+lean_dec(x_117);
+x_135 = lean_ctor_get(x_120, 1);
 lean_inc(x_135);
 lean_dec(x_120);
-x_2 = x_135;
-x_7 = x_134;
+x_136 = lean_ctor_get(x_121, 0);
+lean_inc(x_136);
+lean_dec(x_121);
+x_2 = x_136;
+x_7 = x_135;
 goto _start;
 }
 }
 else
 {
-uint8_t x_137; 
+uint8_t x_138; 
 lean_free_object(x_2);
+lean_dec(x_119);
 lean_dec(x_118);
 lean_dec(x_117);
-lean_dec(x_116);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_137 = !lean_is_exclusive(x_119);
-if (x_137 == 0)
+x_138 = !lean_is_exclusive(x_120);
+if (x_138 == 0)
 {
-return x_119;
+return x_120;
 }
 else
 {
-lean_object* x_138; lean_object* x_139; lean_object* x_140; 
-x_138 = lean_ctor_get(x_119, 0);
-x_139 = lean_ctor_get(x_119, 1);
+lean_object* x_139; lean_object* x_140; lean_object* x_141; 
+x_139 = lean_ctor_get(x_120, 0);
+x_140 = lean_ctor_get(x_120, 1);
+lean_inc(x_140);
 lean_inc(x_139);
-lean_inc(x_138);
-lean_dec(x_119);
-x_140 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_140, 0, x_138);
-lean_ctor_set(x_140, 1, x_139);
-return x_140;
+lean_dec(x_120);
+x_141 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_141, 0, x_139);
+lean_ctor_set(x_141, 1, x_140);
+return x_141;
 }
 }
 }
 else
 {
-lean_object* x_141; lean_object* x_142; lean_object* x_143; uint64_t x_144; lean_object* x_145; 
-x_141 = lean_ctor_get(x_2, 0);
-x_142 = lean_ctor_get(x_2, 1);
-x_143 = lean_ctor_get(x_2, 2);
-x_144 = lean_ctor_get_uint64(x_2, sizeof(void*)*3);
+lean_object* x_142; lean_object* x_143; lean_object* x_144; uint64_t x_145; lean_object* x_146; 
+x_142 = lean_ctor_get(x_2, 0);
+x_143 = lean_ctor_get(x_2, 1);
+x_144 = lean_ctor_get(x_2, 2);
+x_145 = lean_ctor_get_uint64(x_2, sizeof(void*)*3);
+lean_inc(x_144);
 lean_inc(x_143);
 lean_inc(x_142);
-lean_inc(x_141);
 lean_dec(x_2);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-lean_inc(x_143);
-x_145 = l_Lean_Meta_project_x3f(x_143, x_142, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_145) == 0)
-{
-lean_object* x_146; 
-x_146 = lean_ctor_get(x_145, 0);
-lean_inc(x_146);
+lean_inc(x_144);
+x_146 = l_Lean_Meta_project_x3f(x_144, x_143, x_3, x_4, x_5, x_6, x_7);
 if (lean_obj_tag(x_146) == 0)
 {
-lean_object* x_147; lean_object* x_148; 
-x_147 = lean_ctor_get(x_145, 1);
+lean_object* x_147; 
+x_147 = lean_ctor_get(x_146, 0);
 lean_inc(x_147);
-lean_dec(x_145);
-lean_inc(x_143);
-x_148 = l_Lean_Elab_Term_StructInst_DefaultFields_reduce(x_1, x_143, x_3, x_4, x_5, x_6, x_147);
-if (lean_obj_tag(x_148) == 0)
+if (lean_obj_tag(x_147) == 0)
 {
-lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; 
-x_149 = lean_ctor_get(x_148, 0);
-lean_inc(x_149);
-x_150 = lean_ctor_get(x_148, 1);
+lean_object* x_148; lean_object* x_149; 
+x_148 = lean_ctor_get(x_146, 1);
+lean_inc(x_148);
+lean_dec(x_146);
+lean_inc(x_144);
+x_149 = l_Lean_Elab_Term_StructInst_DefaultFields_reduce(x_1, x_144, x_3, x_4, x_5, x_6, x_148);
+if (lean_obj_tag(x_149) == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; 
+x_150 = lean_ctor_get(x_149, 0);
 lean_inc(x_150);
-if (lean_is_exclusive(x_148)) {
- lean_ctor_release(x_148, 0);
- lean_ctor_release(x_148, 1);
- x_151 = x_148;
+x_151 = lean_ctor_get(x_149, 1);
+lean_inc(x_151);
+if (lean_is_exclusive(x_149)) {
+ lean_ctor_release(x_149, 0);
+ lean_ctor_release(x_149, 1);
+ x_152 = x_149;
 } else {
- lean_dec_ref(x_148);
- x_151 = lean_box(0);
+ lean_dec_ref(x_149);
+ x_152 = lean_box(0);
 }
-x_152 = lean_alloc_ctor(11, 3, 8);
-lean_ctor_set(x_152, 0, x_141);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set_uint64(x_152, sizeof(void*)*3, x_144);
-x_153 = lean_expr_update_proj(x_152, x_149);
-if (lean_is_scalar(x_151)) {
- x_154 = lean_alloc_ctor(0, 2, 0);
+x_153 = lean_alloc_ctor(11, 3, 8);
+lean_ctor_set(x_153, 0, x_142);
+lean_ctor_set(x_153, 1, x_143);
+lean_ctor_set(x_153, 2, x_144);
+lean_ctor_set_uint64(x_153, sizeof(void*)*3, x_145);
+x_154 = lean_expr_update_proj(x_153, x_150);
+if (lean_is_scalar(x_152)) {
+ x_155 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_154 = x_151;
+ x_155 = x_152;
 }
-lean_ctor_set(x_154, 0, x_153);
-lean_ctor_set(x_154, 1, x_150);
-return x_154;
+lean_ctor_set(x_155, 0, x_154);
+lean_ctor_set(x_155, 1, x_151);
+return x_155;
 }
 else
 {
-lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; 
+lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; 
+lean_dec(x_144);
 lean_dec(x_143);
 lean_dec(x_142);
-lean_dec(x_141);
-x_155 = lean_ctor_get(x_148, 0);
-lean_inc(x_155);
-x_156 = lean_ctor_get(x_148, 1);
+x_156 = lean_ctor_get(x_149, 0);
 lean_inc(x_156);
-if (lean_is_exclusive(x_148)) {
- lean_ctor_release(x_148, 0);
- lean_ctor_release(x_148, 1);
- x_157 = x_148;
+x_157 = lean_ctor_get(x_149, 1);
+lean_inc(x_157);
+if (lean_is_exclusive(x_149)) {
+ lean_ctor_release(x_149, 0);
+ lean_ctor_release(x_149, 1);
+ x_158 = x_149;
 } else {
- lean_dec_ref(x_148);
- x_157 = lean_box(0);
+ lean_dec_ref(x_149);
+ x_158 = lean_box(0);
 }
-if (lean_is_scalar(x_157)) {
- x_158 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_158)) {
+ x_159 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_158 = x_157;
+ x_159 = x_158;
 }
-lean_ctor_set(x_158, 0, x_155);
-lean_ctor_set(x_158, 1, x_156);
-return x_158;
+lean_ctor_set(x_159, 0, x_156);
+lean_ctor_set(x_159, 1, x_157);
+return x_159;
 }
 }
 else
 {
-lean_object* x_159; lean_object* x_160; 
+lean_object* x_160; lean_object* x_161; 
+lean_dec(x_144);
 lean_dec(x_143);
 lean_dec(x_142);
-lean_dec(x_141);
-x_159 = lean_ctor_get(x_145, 1);
-lean_inc(x_159);
-lean_dec(x_145);
-x_160 = lean_ctor_get(x_146, 0);
+x_160 = lean_ctor_get(x_146, 1);
 lean_inc(x_160);
 lean_dec(x_146);
-x_2 = x_160;
-x_7 = x_159;
+x_161 = lean_ctor_get(x_147, 0);
+lean_inc(x_161);
+lean_dec(x_147);
+x_2 = x_161;
+x_7 = x_160;
 goto _start;
 }
 }
 else
 {
-lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; 
+lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; 
+lean_dec(x_144);
 lean_dec(x_143);
 lean_dec(x_142);
-lean_dec(x_141);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_162 = lean_ctor_get(x_145, 0);
-lean_inc(x_162);
-x_163 = lean_ctor_get(x_145, 1);
+x_163 = lean_ctor_get(x_146, 0);
 lean_inc(x_163);
-if (lean_is_exclusive(x_145)) {
- lean_ctor_release(x_145, 0);
- lean_ctor_release(x_145, 1);
- x_164 = x_145;
+x_164 = lean_ctor_get(x_146, 1);
+lean_inc(x_164);
+if (lean_is_exclusive(x_146)) {
+ lean_ctor_release(x_146, 0);
+ lean_ctor_release(x_146, 1);
+ x_165 = x_146;
 } else {
- lean_dec_ref(x_145);
- x_164 = lean_box(0);
+ lean_dec_ref(x_146);
+ x_165 = lean_box(0);
 }
-if (lean_is_scalar(x_164)) {
- x_165 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_165)) {
+ x_166 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_165 = x_164;
+ x_166 = x_165;
 }
-lean_ctor_set(x_165, 0, x_162);
-lean_ctor_set(x_165, 1, x_163);
-return x_165;
+lean_ctor_set(x_166, 0, x_163);
+lean_ctor_set(x_166, 1, x_164);
+return x_166;
 }
 }
 }
 default: 
 {
-lean_object* x_166; 
+lean_object* x_167; 
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_166 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_166, 0, x_2);
-lean_ctor_set(x_166, 1, x_7);
-return x_166;
+x_167 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_167, 0, x_2);
+lean_ctor_set(x_167, 1, x_7);
+return x_167;
 }
 }
 }

stage0/stdlib/Lean/Elab/Tactic/Split.c

@@ -32,7 +32,7 @@ static lean_object* l___regBuiltin_Lean_Elab_Tactic_evalSplit_declRange___closed
 static lean_object* l___regBuiltin_Lean_Elab_Tactic_evalSplit___closed__5;
 static lean_object* l___regBuiltin_Lean_Elab_Tactic_evalSplit___closed__3;
 static lean_object* l_Lean_Elab_Tactic_evalSplit___lambda__1___closed__1;
-lean_object* l_Lean_commitWhenSome_x3f___at_Lean_Meta_splitTarget_x3f___spec__1___at_Lean_Meta_splitTarget_x3f___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_commitWhenSome_x3f___at_Lean_Meta_splitTarget_x3f___spec__1___at_Lean_Meta_splitTarget_x3f___spec__2(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Tactic_evalSplit___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*);
 static lean_object* l_Lean_Elab_Tactic_evalSplit___closed__2;
 static lean_object* l___regBuiltin_Lean_Elab_Tactic_evalSplit___closed__15;
@@ -317,90 +317,91 @@ return x_2;
 LEAN_EXPORT lean_object* l_Lean_Elab_Tactic_evalSplit___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) {
 _start:
 {
-lean_object* x_8; 
+uint8_t x_8; lean_object* x_9; 
+x_8 = 1;
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
-x_8 = l_Lean_commitWhenSome_x3f___at_Lean_Meta_splitTarget_x3f___spec__1___at_Lean_Meta_splitTarget_x3f___spec__2(x_1, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; 
-x_9 = lean_ctor_get(x_8, 0);
-lean_inc(x_9);
+x_9 = l_Lean_commitWhenSome_x3f___at_Lean_Meta_splitTarget_x3f___spec__1___at_Lean_Meta_splitTarget_x3f___spec__2(x_1, x_8, x_3, x_4, x_5, x_6, x_7);
 if (lean_obj_tag(x_9) == 0)
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_10 = lean_ctor_get(x_8, 1);
+lean_object* x_10; 
+x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
-lean_dec(x_8);
-x_11 = l_Lean_Elab_Tactic_evalSplit___lambda__1___closed__2;
-x_12 = l_Lean_throwError___at_Lean_Meta_Split_applyMatchSplitter___spec__1(x_11, x_3, x_4, x_5, x_6, x_10);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-return x_12;
-}
-else
+if (lean_obj_tag(x_10) == 0)
 {
-uint8_t x_13; 
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_3);
-x_13 = !lean_is_exclusive(x_8);
-if (x_13 == 0)
-{
-lean_object* x_14; lean_object* x_15; 
-x_14 = lean_ctor_get(x_8, 0);
-lean_dec(x_14);
-x_15 = lean_ctor_get(x_9, 0);
-lean_inc(x_15);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_11 = lean_ctor_get(x_9, 1);
+lean_inc(x_11);
 lean_dec(x_9);
-lean_ctor_set(x_8, 0, x_15);
-return x_8;
+x_12 = l_Lean_Elab_Tactic_evalSplit___lambda__1___closed__2;
+x_13 = l_Lean_throwError___at_Lean_Meta_Split_applyMatchSplitter___spec__1(x_12, x_3, x_4, x_5, x_6, x_11);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+return x_13;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_16 = lean_ctor_get(x_8, 1);
+uint8_t x_14; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_14 = !lean_is_exclusive(x_9);
+if (x_14 == 0)
+{
+lean_object* x_15; lean_object* x_16; 
+x_15 = lean_ctor_get(x_9, 0);
+lean_dec(x_15);
+x_16 = lean_ctor_get(x_10, 0);
 lean_inc(x_16);
-lean_dec(x_8);
-x_17 = lean_ctor_get(x_9, 0);
+lean_dec(x_10);
+lean_ctor_set(x_9, 0, x_16);
+return x_9;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+x_17 = lean_ctor_get(x_9, 1);
 lean_inc(x_17);
 lean_dec(x_9);
-x_18 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-return x_18;
+x_18 = lean_ctor_get(x_10, 0);
+lean_inc(x_18);
+lean_dec(x_10);
+x_19 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_19, 0, x_18);
+lean_ctor_set(x_19, 1, x_17);
+return x_19;
 }
 }
 }
 else
 {
-uint8_t x_19; 
+uint8_t x_20; 
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_19 = !lean_is_exclusive(x_8);
-if (x_19 == 0)
+x_20 = !lean_is_exclusive(x_9);
+if (x_20 == 0)
 {
-return x_8;
+return x_9;
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_20 = lean_ctor_get(x_8, 0);
-x_21 = lean_ctor_get(x_8, 1);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_9, 0);
+x_22 = lean_ctor_get(x_9, 1);
+lean_inc(x_22);
 lean_inc(x_21);
-lean_inc(x_20);
-lean_dec(x_8);
-x_22 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_22, 0, x_20);
-lean_ctor_set(x_22, 1, x_21);
-return x_22;
+lean_dec(x_9);
+x_23 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_23, 0, x_21);
+lean_ctor_set(x_23, 1, x_22);
+return x_23;
 }
 }
 }
@@ -933,120 +934,121 @@ lean_inc(x_1);
 x_10 = l_Lean_Elab_Tactic_getMainGoal(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
 if (lean_obj_tag(x_10) == 0)
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; 
 x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
 x_12 = lean_ctor_get(x_10, 1);
 lean_inc(x_12);
 lean_dec(x_10);
+x_13 = 1;
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-x_13 = l_Lean_commitWhenSome_x3f___at_Lean_Meta_splitTarget_x3f___spec__1___at_Lean_Meta_splitTarget_x3f___spec__2(x_11, x_5, x_6, x_7, x_8, x_12);
-if (lean_obj_tag(x_13) == 0)
-{
-lean_object* x_14; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
+x_14 = l_Lean_commitWhenSome_x3f___at_Lean_Meta_splitTarget_x3f___spec__1___at_Lean_Meta_splitTarget_x3f___spec__2(x_11, x_13, x_5, x_6, x_7, x_8, x_12);
 if (lean_obj_tag(x_14) == 0)
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; 
+lean_object* x_15; 
+x_15 = lean_ctor_get(x_14, 0);
+lean_inc(x_15);
+if (lean_obj_tag(x_15) == 0)
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; 
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_15 = lean_ctor_get(x_13, 1);
-lean_inc(x_15);
-lean_dec(x_13);
-x_16 = l_Lean_Elab_Tactic_evalSplit___lambda__1___closed__2;
-x_17 = l_Lean_throwError___at_Lean_Meta_Split_applyMatchSplitter___spec__1(x_16, x_5, x_6, x_7, x_8, x_15);
+x_16 = lean_ctor_get(x_14, 1);
+lean_inc(x_16);
+lean_dec(x_14);
+x_17 = l_Lean_Elab_Tactic_evalSplit___lambda__1___closed__2;
+x_18 = l_Lean_throwError___at_Lean_Meta_Split_applyMatchSplitter___spec__1(x_17, x_5, x_6, x_7, x_8, x_16);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_18 = !lean_is_exclusive(x_17);
-if (x_18 == 0)
+x_19 = !lean_is_exclusive(x_18);
+if (x_19 == 0)
 {
-return x_17;
+return x_18;
 }
 else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = lean_ctor_get(x_17, 0);
-x_20 = lean_ctor_get(x_17, 1);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_18, 0);
+x_21 = lean_ctor_get(x_18, 1);
+lean_inc(x_21);
 lean_inc(x_20);
-lean_inc(x_19);
-lean_dec(x_17);
-x_21 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_21, 0, x_19);
-lean_ctor_set(x_21, 1, x_20);
-return x_21;
+lean_dec(x_18);
+x_22 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_21);
+return x_22;
 }
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_22 = lean_ctor_get(x_13, 1);
-lean_inc(x_22);
-lean_dec(x_13);
-x_23 = lean_ctor_get(x_14, 0);
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_23 = lean_ctor_get(x_14, 1);
 lean_inc(x_23);
 lean_dec(x_14);
-x_24 = l_Lean_Elab_Tactic_replaceMainGoal(x_23, x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_22);
-if (lean_obj_tag(x_24) == 0)
+x_24 = lean_ctor_get(x_15, 0);
+lean_inc(x_24);
+lean_dec(x_15);
+x_25 = l_Lean_Elab_Tactic_replaceMainGoal(x_24, x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_23);
+if (lean_obj_tag(x_25) == 0)
 {
-uint8_t x_25; 
-x_25 = !lean_is_exclusive(x_24);
-if (x_25 == 0)
+uint8_t x_26; 
+x_26 = !lean_is_exclusive(x_25);
+if (x_26 == 0)
 {
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_24, 0);
-lean_dec(x_26);
-x_27 = lean_box(0);
-lean_ctor_set(x_24, 0, x_27);
-return x_24;
+lean_object* x_27; lean_object* x_28; 
+x_27 = lean_ctor_get(x_25, 0);
+lean_dec(x_27);
+x_28 = lean_box(0);
+lean_ctor_set(x_25, 0, x_28);
+return x_25;
 }
 else
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-x_28 = lean_ctor_get(x_24, 1);
-lean_inc(x_28);
-lean_dec(x_24);
-x_29 = lean_box(0);
-x_30 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_30, 0, x_29);
-lean_ctor_set(x_30, 1, x_28);
-return x_30;
+lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+x_29 = lean_ctor_get(x_25, 1);
+lean_inc(x_29);
+lean_dec(x_25);
+x_30 = lean_box(0);
+x_31 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_31, 0, x_30);
+lean_ctor_set(x_31, 1, x_29);
+return x_31;
 }
 }
 else
 {
-uint8_t x_31; 
-x_31 = !lean_is_exclusive(x_24);
-if (x_31 == 0)
+uint8_t x_32; 
+x_32 = !lean_is_exclusive(x_25);
+if (x_32 == 0)
 {
-return x_24;
+return x_25;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_32 = lean_ctor_get(x_24, 0);
-x_33 = lean_ctor_get(x_24, 1);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_33 = lean_ctor_get(x_25, 0);
+x_34 = lean_ctor_get(x_25, 1);
+lean_inc(x_34);
 lean_inc(x_33);
-lean_inc(x_32);
-lean_dec(x_24);
-x_34 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_34, 0, x_32);
-lean_ctor_set(x_34, 1, x_33);
-return x_34;
+lean_dec(x_25);
+x_35 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_35, 0, x_33);
+lean_ctor_set(x_35, 1, x_34);
+return x_35;
 }
 }
 }
 }
 else
 {
-uint8_t x_35; 
+uint8_t x_36; 
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -1055,29 +1057,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_35 = !lean_is_exclusive(x_13);
-if (x_35 == 0)
+x_36 = !lean_is_exclusive(x_14);
+if (x_36 == 0)
 {
-return x_13;
+return x_14;
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_13, 0);
-x_37 = lean_ctor_get(x_13, 1);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_37 = lean_ctor_get(x_14, 0);
+x_38 = lean_ctor_get(x_14, 1);
+lean_inc(x_38);
 lean_inc(x_37);
-lean_inc(x_36);
-lean_dec(x_13);
-x_38 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_38, 0, x_36);
-lean_ctor_set(x_38, 1, x_37);
-return x_38;
+lean_dec(x_14);
+x_39 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_39, 0, x_37);
+lean_ctor_set(x_39, 1, x_38);
+return x_39;
 }
 }
 }
 else
 {
-uint8_t x_39; 
+uint8_t x_40; 
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -1086,23 +1088,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_39 = !lean_is_exclusive(x_10);
-if (x_39 == 0)
+x_40 = !lean_is_exclusive(x_10);
+if (x_40 == 0)
 {
 return x_10;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_40 = lean_ctor_get(x_10, 0);
-x_41 = lean_ctor_get(x_10, 1);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_41 = lean_ctor_get(x_10, 0);
+x_42 = lean_ctor_get(x_10, 1);
+lean_inc(x_42);
 lean_inc(x_41);
-lean_inc(x_40);
 lean_dec(x_10);
-x_42 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_42, 0, x_40);
-lean_ctor_set(x_42, 1, x_41);
-return x_42;
+x_43 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_43, 0, x_41);
+lean_ctor_set(x_43, 1, x_42);
+return x_43;
 }
 }
 }

stage0/stdlib/Lean/Elab/Term.c

@@ -89,6 +89,7 @@ lean_object* l_List_foldl___at_Lean_Elab_addMacroStack___spec__1(lean_object*, l
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_getLetRecsToLift___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_instMonadMacroAdapterTermElabM___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_checkIfShadowingStructureField___at_Lean_Elab_Term_expandDeclId___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Elab_relaxedAutoImplicit;
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_instMonadInfoTreeTermElabM;
 LEAN_EXPORT lean_object* l_Lean_throwError___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___spec__11(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Term___hyg_11996____closed__1;
@@ -156,13 +157,12 @@ LEAN_EXPORT lean_object* l_Std_PersistentArray_mapM___at_Lean_Elab_Term_withoutM
 LEAN_EXPORT lean_object* l___private_Lean_Util_Trace_0__Lean_withNestedTracesFinalizer___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_liftMacroM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___spec__2___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_getConstInfo___at_Lean_Elab_Term_mkConst___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_Lean_Elab_isValidAutoBoundImplicitName(lean_object*);
+uint8_t l_Lean_Elab_isValidAutoBoundImplicitName(lean_object*, uint8_t);
 static lean_object* l_Lean_Elab_Term_synthesizeInstMVarCore___lambda__3___closed__5;
 lean_object* l_Std_HashMapImp_find_x3f___at_Lean_Meta_ToHide_visitVisibleExpr_visit___spec__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_resolveLocalName_loop___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabUsingElabFnsAux___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_commitIfDidNotPostpone___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_Elab_autoBoundImplicitLocal;
 LEAN_EXPORT lean_object* l_Std_RBNode_find___at_Lean_Elab_Term_resolveName___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkAppM(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Elab_Term_levelMVarToParam___closed__1;
@@ -303,6 +303,7 @@ LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Term_withoutModif
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_instToStringMVarErrorKind(lean_object*);
 LEAN_EXPORT lean_object* l_Std_RBNode_find___at_Lean_Elab_Term_getMVarErrorInfo_x3f___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_KeyedDeclsAttribute_getEntries___rarg(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Elab_autoImplicit;
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_registerCustomErrorIfMVar___boxed(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_Term_instMonadMacroAdapterTermElabM___closed__3;
 lean_object* l_Lean_Elab_Level_elabLevel(lean_object*, lean_object*, lean_object*);
@@ -397,6 +398,7 @@ static lean_object* l_Lean_Elab_Term_isLetRecAuxMVar___closed__4;
 extern lean_object* l_Lean_maxRecDepth;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Term_expandDeclId___spec__4___closed__2;
 static lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___lambda__5___closed__2;
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__3;
 lean_object* l_Lean_mkAppN(lean_object*, lean_object*);
 size_t lean_uint64_to_usize(uint64_t);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabImplicitLambda_loop___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -419,6 +421,7 @@ LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Term_expandDecl
 LEAN_EXPORT lean_object* l_List_foldlM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_mkConsts___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_applyAttributesCore___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwKernelException___at_Lean_Elab_Term_evalExpr___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__1;
 uint8_t l_Lean_MetavarContext_isExprAssigned(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at___private_Lean_Elab_Term_0__Lean_Elab_Term_applyAttributesCore___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_resolveGlobalName___at_Lean_Elab_Term_resolveName___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -455,6 +458,7 @@ static lean_object* l_Lean_Elab_Term_instMonadTermElabM___closed__4;
 LEAN_EXPORT lean_object* l_Lean_Elab_logTrace___at_Lean_Elab_Term_traceAtCmdPos___spec__1(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_Term_0__Lean_Elab_Term_tryCoeSort___lambda__1___closed__3;
 LEAN_EXPORT lean_object* l_Lean_Elab_getResetInfoTrees___at_Lean_Elab_Term_withoutModifyingElabMetaStateWithInfo___spec__2(lean_object*);
+static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__2;
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_LVal_isFieldName___boxed(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabLevel(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_mkTermElabAttributeUnsafe(lean_object*);
@@ -726,6 +730,7 @@ static lean_object* l_Lean_Elab_logTrace___at_Lean_Elab_Term_traceAtCmdPos___spe
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_tryCoeThunk_x3f(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_Term_instMonadTermElabM___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Elab_throwAlreadyDeclaredUniverseLevel___at_Lean_Elab_Term_expandDeclId___spec__10___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Elab_Term_resolveName_process___closed__3;
 static lean_object* l_Lean_Elab_Term_instMonadTermElabM___closed__2;
 lean_object* l_Lean_Meta_getMVarsAtDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_modn(size_t, lean_object*);
@@ -888,7 +893,6 @@ LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_mkSomeCont
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_mkFreshBinderName(lean_object*);
 LEAN_EXPORT uint8_t l_Array_anyMUnsafe_any___at_Lean_Elab_Term_logUnassignedUsingErrorInfos___spec__2(lean_object*, lean_object*, size_t, size_t);
 LEAN_EXPORT lean_object* l_Lean_Elab_pushInfoTree___at_Lean_Elab_Term_addDotCompletionInfo___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__2;
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Term_instMetaEvalTermElabM___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lean_Elab_Term_addTermInfo___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_trySynthInstance(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1011,7 +1015,6 @@ LEAN_EXPORT lean_object* l_Std_RBNode_forIn_visit___at_Lean_Elab_Term_logUnassig
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_saveState(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_Context_sectionFVars___default;
 static uint32_t l_Lean_Elab_Term_instInhabitedSavedState___closed__4;
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__1;
 LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_isLambdaWithImplicit___boxed(lean_object*);
 static lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_isHole___closed__1;
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Elab_Term_mkAuxName___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1170,7 +1173,7 @@ LEAN_EXPORT lean_object* l_Lean_Elab_Term_applyResult___rarg(lean_object*, lean_
 lean_object* l_IO_println___at_Lean_instEval___spec__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lean_Elab_Term_addTermInfo___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_throwErrorIfErrors(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076_(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096_(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Elab_Term_evalExpr___spec__13(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_addAutoBoundImplicits(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_whnfD(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1311,7 +1314,6 @@ lean_object* l_Lean_getAttributeImpl(lean_object*, lean_object*);
 lean_object* l_List_appendTR___rarg(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Term_withoutModifyingElabMetaStateWithInfo___spec__12___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_Option_set___at_Lean_Meta_withPPInaccessibleNamesImp___spec__2(lean_object*, lean_object*, uint8_t);
-static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__3;
 LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_mkSyntheticSorryFor(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_mkTermInfo(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_EXPORT lean_object* l_Lean_throwError___at_Lean_Elab_Term_synthesizeInstMVarCore___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -37924,7 +37926,7 @@ static lean_object* _init_l_Lean_Elab_Term_withAutoBoundImplicit___rarg___closed
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Elab_autoBoundImplicitLocal;
+x_1 = l_Lean_Elab_autoImplicit;
 return x_1;
 }
 }
@@ -40991,6 +40993,14 @@ x_2 = l_Lean_stringToMessageData(x_1);
 return x_2;
 }
 }
+static lean_object* _init_l_Lean_Elab_Term_resolveName_process___closed__3() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Elab_relaxedAutoImplicit;
+return x_1;
+}
+}
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_resolveName_process(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) {
 _start:
 {
@@ -41054,76 +41064,81 @@ return x_29;
 }
 else
 {
-uint8_t x_30; 
+lean_object* x_30; lean_object* x_31; uint8_t x_32; uint8_t x_33; 
+x_30 = lean_ctor_get(x_11, 0);
+lean_inc(x_30);
+x_31 = l_Lean_Elab_Term_resolveName_process___closed__3;
+x_32 = l_Lean_Option_get___at_Lean_ppExpr___spec__1(x_30, x_31);
+lean_dec(x_30);
 lean_inc(x_2);
-x_30 = l_Lean_Elab_isValidAutoBoundImplicitName(x_2);
-if (x_30 == 0)
+x_33 = l_Lean_Elab_isValidAutoBoundImplicitName(x_2, x_32);
+if (x_33 == 0)
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
-x_31 = lean_box(0);
-x_32 = l_Lean_mkConst(x_2, x_31);
-x_33 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_33, 0, x_32);
-x_34 = l_Lean_Elab_Term_resolveName_process___closed__2;
-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_Lean_Elab_Term_MVarErrorInfo_logError_addArgName___closed__4;
-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_Lean_throwError___at___private_Lean_Elab_Term_0__Lean_Elab_Term_applyAttributesCore___spec__1(x_37, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; 
+x_34 = lean_box(0);
+x_35 = l_Lean_mkConst(x_2, x_34);
+x_36 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_36, 0, x_35);
+x_37 = l_Lean_Elab_Term_resolveName_process___closed__2;
+x_38 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_38, 0, x_37);
+lean_ctor_set(x_38, 1, x_36);
+x_39 = l_Lean_Elab_Term_MVarErrorInfo_logError_addArgName___closed__4;
+x_40 = lean_alloc_ctor(10, 2, 0);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_39);
+x_41 = l_Lean_throwError___at___private_Lean_Elab_Term_0__Lean_Elab_Term_applyAttributesCore___spec__1(x_40, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
-x_39 = !lean_is_exclusive(x_38);
-if (x_39 == 0)
+x_42 = !lean_is_exclusive(x_41);
+if (x_42 == 0)
 {
-return x_38;
+return x_41;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_40 = lean_ctor_get(x_38, 0);
-x_41 = lean_ctor_get(x_38, 1);
-lean_inc(x_41);
-lean_inc(x_40);
-lean_dec(x_38);
-x_42 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_42, 0, x_40);
-lean_ctor_set(x_42, 1, x_41);
-return x_42;
+lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+x_43 = lean_ctor_get(x_41, 0);
+x_44 = lean_ctor_get(x_41, 1);
+lean_inc(x_44);
+lean_inc(x_43);
+lean_dec(x_41);
+x_45 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_45, 0, x_43);
+lean_ctor_set(x_45, 1, x_44);
+return x_45;
 }
 }
 else
 {
-lean_object* x_43; uint8_t x_44; 
-x_43 = l_Lean_Elab_throwAutoBoundImplicitLocal___at_Lean_Elab_Term_resolveName_process___spec__1(x_2, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
+lean_object* x_46; uint8_t x_47; 
+x_46 = l_Lean_Elab_throwAutoBoundImplicitLocal___at_Lean_Elab_Term_resolveName_process___spec__1(x_2, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
-x_44 = !lean_is_exclusive(x_43);
-if (x_44 == 0)
+x_47 = !lean_is_exclusive(x_46);
+if (x_47 == 0)
 {
-return x_43;
+return x_46;
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-x_45 = lean_ctor_get(x_43, 0);
-x_46 = lean_ctor_get(x_43, 1);
-lean_inc(x_46);
-lean_inc(x_45);
-lean_dec(x_43);
-x_47 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_47, 0, x_45);
-lean_ctor_set(x_47, 1, x_46);
-return x_47;
+lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_48 = lean_ctor_get(x_46, 0);
+x_49 = lean_ctor_get(x_46, 1);
+lean_inc(x_49);
+lean_inc(x_48);
+lean_dec(x_46);
+x_50 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_50, 0, x_48);
+lean_ctor_set(x_50, 1, x_49);
+return x_50;
 }
 }
 }
@@ -51799,7 +51814,7 @@ x_3 = lean_alloc_closure((void*)(l_Lean_Elab_withoutModifyingStateWithInfoAndMes
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__1() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -51809,7 +51824,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_Term___hyg_15076____closed__2() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -51817,17 +51832,17 @@ x_1 = lean_mk_string("debug");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__3() {
+static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Elab_Term_MVarErrorInfo_logError___closed__11;
-x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__2;
+x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__2;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076_(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -51839,7 +51854,7 @@ lean_object* x_4; lean_object* x_5; lean_object* x_6;
 x_4 = lean_ctor_get(x_3, 1);
 lean_inc(x_4);
 lean_dec(x_3);
-x_5 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__1;
+x_5 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__1;
 x_6 = l_Lean_registerTraceClass(x_5, x_4);
 if (lean_obj_tag(x_6) == 0)
 {
@@ -51847,7 +51862,7 @@ lean_object* x_7; lean_object* x_8; lean_object* x_9;
 x_7 = lean_ctor_get(x_6, 1);
 lean_inc(x_7);
 lean_dec(x_6);
-x_8 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__3;
+x_8 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__3;
 x_9 = l_Lean_registerTraceClass(x_8, x_7);
 return x_9;
 }
@@ -52716,6 +52731,8 @@ l_Lean_Elab_Term_resolveName_process___closed__1 = _init_l_Lean_Elab_Term_resolv
 lean_mark_persistent(l_Lean_Elab_Term_resolveName_process___closed__1);
 l_Lean_Elab_Term_resolveName_process___closed__2 = _init_l_Lean_Elab_Term_resolveName_process___closed__2();
 lean_mark_persistent(l_Lean_Elab_Term_resolveName_process___closed__2);
+l_Lean_Elab_Term_resolveName_process___closed__3 = _init_l_Lean_Elab_Term_resolveName_process___closed__3();
+lean_mark_persistent(l_Lean_Elab_Term_resolveName_process___closed__3);
 l_Lean_Elab_Term_resolveName___closed__1 = _init_l_Lean_Elab_Term_resolveName___closed__1();
 lean_mark_persistent(l_Lean_Elab_Term_resolveName___closed__1);
 l_Lean_Elab_Term_resolveName___closed__2 = _init_l_Lean_Elab_Term_resolveName___closed__2();
@@ -52850,13 +52867,13 @@ l_Lean_Elab_Term_expandDeclId___closed__1 = _init_l_Lean_Elab_Term_expandDeclId_
 lean_mark_persistent(l_Lean_Elab_Term_expandDeclId___closed__1);
 l_Lean_Elab_Term_expandDeclId___closed__2 = _init_l_Lean_Elab_Term_expandDeclId___closed__2();
 lean_mark_persistent(l_Lean_Elab_Term_expandDeclId___closed__2);
-l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__1();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__1);
-l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__2 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__2();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__2);
-l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__3 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__3();
-lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076____closed__3);
-res = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15076_(lean_io_mk_world());
+l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__1();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__1);
+l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__2 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__2();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__2);
+l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__3 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__3();
+lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096____closed__3);
+res = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15096_(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/Expr.c

@@ -56,7 +56,7 @@ LEAN_EXPORT lean_object* l_Lean_Expr_isAppOf___boxed(lean_object*, lean_object*)
 LEAN_EXPORT lean_object* l_Lean_mkSort(lean_object*);
 static lean_object* l_Lean_instReprData__1___closed__1;
 LEAN_EXPORT lean_object* l_Lean_instReprData__1___boxed(lean_object*, lean_object*);
-LEAN_EXPORT uint8_t l_Lean_Expr_isHeadBetaTargetFn(lean_object*);
+LEAN_EXPORT uint8_t l_Lean_Expr_isHeadBetaTargetFn(uint8_t, lean_object*);
 uint8_t lean_uint64_dec_eq(uint64_t, uint64_t);
 static lean_object* l_Lean_Expr_bindingDomain_x21___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Expr_letBody_x21(lean_object*);
@@ -119,7 +119,6 @@ uint64_t lean_bool_to_uint64(uint8_t);
 static lean_object* l_Lean_Expr_updateMData_x21___closed__2;
 static lean_object* l_Lean_mkNatLit___closed__9;
 LEAN_EXPORT uint8_t l_Lean_Expr_isArrow(lean_object*);
-LEAN_EXPORT lean_object* l___private_Lean_Expr_0__Lean_Expr_betaRevAux(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_mkOr(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_List_mapTRAux___at_Lean_Expr_instantiateLevelParams___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -146,7 +145,7 @@ LEAN_EXPORT lean_object* l_Lean_Expr_consumeAutoOptParam(lean_object*);
 size_t lean_usize_sub(size_t, size_t);
 LEAN_EXPORT lean_object* l___private_Lean_Expr_0__Lean_Expr_etaExpandedAux(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_hash___boxed(lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Expr_betaRev___boxed(lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Expr_betaRev___boxed(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Literal_type___closed__5;
 LEAN_EXPORT lean_object* l_Lean_Expr_mvarId_x21___boxed(lean_object*);
 static lean_object* l___private_Lean_Expr_0__Lean_reprBinderInfo____x40_Lean_Expr___hyg_372____closed__12;
@@ -291,7 +290,6 @@ LEAN_EXPORT lean_object* l_Lean_mkLet___boxed(lean_object*, lean_object*, lean_o
 LEAN_EXPORT lean_object* l_Lean_BinderInfo_noConfusion___rarg(uint8_t, uint8_t, lean_object*);
 lean_object* lean_expr_lower_loose_bvars(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_setOption___at_Lean_Expr_setPPExplicit___spec__1(lean_object*, lean_object*, uint8_t);
-LEAN_EXPORT lean_object* l_Lean_Expr_beta___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_letFunAnnotation_x3f(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_isMVar___boxed(lean_object*);
 static lean_object* l___private_Lean_Expr_0__Lean_reprExpr____x40_Lean_Expr___hyg_2210____closed__26;
@@ -391,7 +389,7 @@ LEAN_EXPORT lean_object* l___private_Lean_Expr_0__Lean_Expr_withAppRevAux(lean_o
 LEAN_EXPORT lean_object* l___private_Lean_Expr_0__Lean_reprExpr____x40_Lean_Expr___hyg_2210____lambda__4(uint64_t, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Expr_0__Lean_Expr_getParamSubstArray___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_inaccessible_x3f(lean_object*);
-LEAN_EXPORT uint8_t l_Lean_Expr_isHeadBetaTarget(lean_object*);
+LEAN_EXPORT uint8_t l_Lean_Expr_isHeadBetaTarget(lean_object*, uint8_t);
 LEAN_EXPORT uint8_t l_Lean_Expr_isBinding(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_bindingBody_x21___boxed(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_updateProj_x21(lean_object*, lean_object*);
@@ -498,7 +496,7 @@ static lean_object* l___private_Lean_Expr_0__Lean_reprBinderInfo____x40_Lean_Exp
 LEAN_EXPORT uint8_t l_Lean_Expr_Data_nonDepLet(uint64_t);
 static lean_object* l___private_Lean_Expr_0__Lean_reprExpr____x40_Lean_Expr___hyg_2210____closed__39;
 LEAN_EXPORT lean_object* l_Lean_mkEM(lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Expr_isHeadBetaTargetFn___boxed(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Expr_isHeadBetaTargetFn___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_mkFreshFVarId___rarg(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_consumeMData(lean_object*);
 uint64_t lean_uint64_land(uint64_t, uint64_t);
@@ -545,7 +543,6 @@ static lean_object* l___private_Lean_Expr_0__Lean_reprBinderInfo____x40_Lean_Exp
 static lean_object* l___private_Lean_Expr_0__Lean_reprBinderInfo____x40_Lean_Expr___hyg_372____closed__28;
 LEAN_EXPORT lean_object* l_Lean_Expr_setAppPPExplicit(lean_object*);
 static lean_object* l___private_Lean_Expr_0__Lean_reprBinderInfo____x40_Lean_Expr___hyg_372____closed__14;
-LEAN_EXPORT lean_object* l___private_Lean_Expr_0__Lean_Expr_betaRevAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Expr_ctorName___closed__9;
 LEAN_EXPORT lean_object* l_Lean_Expr_instantiateRevRange___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_mkNatLit___closed__7;
@@ -605,7 +602,7 @@ LEAN_EXPORT uint64_t l_Lean_Literal_hash(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_mkLambdaEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l_Lean_Expr_hasMVar(lean_object*);
 static lean_object* l___private_Lean_Expr_0__Lean_reprBinderInfo____x40_Lean_Expr___hyg_372____closed__29;
-LEAN_EXPORT lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*, uint8_t);
 LEAN_EXPORT uint64_t l_Lean_instInhabitedData__1;
 static lean_object* l_Lean_instBEqLiteral___closed__1;
 LEAN_EXPORT lean_object* l_Lean_instHashableBinderInfo;
@@ -670,6 +667,7 @@ LEAN_EXPORT lean_object* l_Lean_Expr_withAppRev(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_quickLt___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_instToStringExpr;
 static lean_object* l_Lean_mkEM___closed__4;
+LEAN_EXPORT lean_object* l_Lean_Expr_betaRev_go___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint64_t lean_uint32_to_uint64(uint32_t);
 LEAN_EXPORT lean_object* l_Lean_instReprData__1___lambda__6(lean_object*, uint64_t, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Expr_0__Lean_reprBinderInfo____x40_Lean_Expr___hyg_372____closed__30;
@@ -783,7 +781,7 @@ LEAN_EXPORT lean_object* l_Lean_Expr_hashEx___boxed(lean_object*);
 static lean_object* l___private_Lean_Expr_0__Lean_reprExpr____x40_Lean_Expr___hyg_2210____closed__14;
 static lean_object* l___private_Lean_Expr_0__Lean_reprBinderInfo____x40_Lean_Expr___hyg_372____closed__20;
 static lean_object* l_Lean_mkDecIsFalse___closed__3;
-LEAN_EXPORT lean_object* l_Lean_Expr_isHeadBetaTarget___boxed(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Expr_isHeadBetaTarget___boxed(lean_object*, lean_object*);
 static lean_object* l_Lean_Expr_updateLet_x21___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Expr_setOption___at_Lean_Expr_setPPExplicit___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_isAtomic___boxed(lean_object*);
@@ -907,6 +905,7 @@ uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l_Lean_Expr_containsFVar(lean_object*, lean_object*);
 static lean_object* l_Lean_mkAnnotation___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Expr_mkData(uint64_t, lean_object*, uint32_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t);
+LEAN_EXPORT lean_object* l_Lean_Expr_betaRev_go(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT uint8_t lean_expr_has_level_param(lean_object*);
 lean_object* l_Repr_addAppParen(lean_object*, lean_object*);
 static lean_object* _init_l_Lean_instInhabitedLiteral___closed__1() {
@@ -12752,197 +12751,262 @@ lean_dec(x_2);
 return x_5;
 }
 }
-LEAN_EXPORT lean_object* l___private_Lean_Expr_0__Lean_Expr_betaRevAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+LEAN_EXPORT lean_object* l_Lean_Expr_betaRev_go(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-switch (lean_obj_tag(x_3)) {
+switch (lean_obj_tag(x_4)) {
 case 6:
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
-x_5 = lean_ctor_get(x_3, 2);
-x_6 = lean_unsigned_to_nat(1u);
-x_7 = lean_nat_add(x_4, x_6);
+lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
+x_6 = lean_ctor_get(x_4, 2);
+lean_inc(x_6);
 lean_dec(x_4);
-x_8 = lean_nat_dec_lt(x_7, x_2);
-if (x_8 == 0)
+x_7 = lean_unsigned_to_nat(1u);
+x_8 = lean_nat_add(x_5, x_7);
+lean_dec(x_5);
+x_9 = lean_nat_dec_lt(x_8, x_3);
+if (x_9 == 0)
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_9 = lean_nat_sub(x_2, x_7);
-lean_dec(x_7);
-x_10 = lean_expr_instantiate_range(x_5, x_9, x_2, x_1);
-x_11 = lean_unsigned_to_nat(0u);
-x_12 = l___private_Lean_Expr_0__Lean_Expr_mkAppRevRangeAux(x_1, x_11, x_10, x_9);
-return x_12;
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_10 = lean_nat_sub(x_3, x_8);
+lean_dec(x_8);
+x_11 = lean_expr_instantiate_range(x_6, x_10, x_3, x_1);
+lean_dec(x_6);
+x_12 = lean_unsigned_to_nat(0u);
+x_13 = l___private_Lean_Expr_0__Lean_Expr_mkAppRevRangeAux(x_1, x_12, x_11, x_10);
+return x_13;
 }
 else
 {
-x_3 = x_5;
-x_4 = x_7;
+x_4 = x_6;
+x_5 = x_8;
 goto _start;
 }
 }
+case 8:
+{
+if (x_2 == 0)
+{
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_15 = lean_nat_sub(x_3, x_5);
+lean_dec(x_5);
+x_16 = lean_expr_instantiate_range(x_4, x_15, x_3, x_1);
+lean_dec(x_4);
+x_17 = lean_unsigned_to_nat(0u);
+x_18 = l___private_Lean_Expr_0__Lean_Expr_mkAppRevRangeAux(x_1, x_17, x_16, x_15);
+return x_18;
+}
+else
+{
+lean_object* x_19; lean_object* x_20; uint8_t x_21; 
+x_19 = lean_ctor_get(x_4, 2);
+lean_inc(x_19);
+x_20 = lean_ctor_get(x_4, 3);
+lean_inc(x_20);
+x_21 = lean_nat_dec_lt(x_5, x_3);
+if (x_21 == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_20);
+lean_dec(x_19);
+x_22 = lean_nat_sub(x_3, x_5);
+lean_dec(x_5);
+x_23 = lean_expr_instantiate_range(x_4, x_22, x_3, x_1);
+lean_dec(x_4);
+x_24 = lean_unsigned_to_nat(0u);
+x_25 = l___private_Lean_Expr_0__Lean_Expr_mkAppRevRangeAux(x_1, x_24, x_23, x_22);
+return x_25;
+}
+else
+{
+lean_object* x_26; 
+lean_dec(x_4);
+x_26 = lean_expr_instantiate1(x_20, x_19);
+lean_dec(x_19);
+lean_dec(x_20);
+x_4 = x_26;
+goto _start;
+}
+}
+}
 case 10:
 {
-lean_object* x_14; 
-x_14 = lean_ctor_get(x_3, 1);
-x_3 = x_14;
+lean_object* x_28; 
+x_28 = lean_ctor_get(x_4, 1);
+lean_inc(x_28);
+lean_dec(x_4);
+x_4 = x_28;
 goto _start;
 }
 default: 
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_16 = lean_nat_sub(x_2, x_4);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_30 = lean_nat_sub(x_3, x_5);
+lean_dec(x_5);
+x_31 = lean_expr_instantiate_range(x_4, x_30, x_3, x_1);
 lean_dec(x_4);
-x_17 = lean_expr_instantiate_range(x_3, x_16, x_2, x_1);
-x_18 = lean_unsigned_to_nat(0u);
-x_19 = l___private_Lean_Expr_0__Lean_Expr_mkAppRevRangeAux(x_1, x_18, x_17, x_16);
-return x_19;
+x_32 = lean_unsigned_to_nat(0u);
+x_33 = l___private_Lean_Expr_0__Lean_Expr_mkAppRevRangeAux(x_1, x_32, x_31, x_30);
+return x_33;
 }
 }
 }
 }
-LEAN_EXPORT lean_object* l___private_Lean_Expr_0__Lean_Expr_betaRevAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+LEAN_EXPORT lean_object* l_Lean_Expr_betaRev_go___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l___private_Lean_Expr_0__Lean_Expr_betaRevAux(x_1, x_2, x_3, x_4);
-lean_dec(x_3);
+uint8_t x_6; lean_object* x_7; 
+x_6 = lean_unbox(x_2);
 lean_dec(x_2);
+x_7 = l_Lean_Expr_betaRev_go(x_1, x_6, x_3, x_4, x_5);
+lean_dec(x_3);
 lean_dec(x_1);
-return x_5;
+return x_7;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Expr_betaRev(lean_object* x_1, lean_object* x_2) {
+LEAN_EXPORT lean_object* l_Lean_Expr_betaRev(lean_object* x_1, lean_object* x_2, uint8_t x_3) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; uint8_t x_5; 
-x_3 = lean_array_get_size(x_2);
-x_4 = lean_unsigned_to_nat(0u);
-x_5 = lean_nat_dec_eq(x_3, x_4);
-if (x_5 == 0)
+lean_object* x_4; lean_object* x_5; uint8_t x_6; 
+x_4 = lean_array_get_size(x_2);
+x_5 = lean_unsigned_to_nat(0u);
+x_6 = lean_nat_dec_eq(x_4, x_5);
+if (x_6 == 0)
 {
-lean_object* x_6; 
-x_6 = l___private_Lean_Expr_0__Lean_Expr_betaRevAux(x_2, x_3, x_1, x_4);
-lean_dec(x_3);
-return x_6;
+lean_object* x_7; 
+x_7 = l_Lean_Expr_betaRev_go(x_2, x_3, x_4, x_1, x_5);
+lean_dec(x_4);
+return x_7;
 }
 else
 {
-lean_dec(x_3);
-lean_inc(x_1);
+lean_dec(x_4);
 return x_1;
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Expr_betaRev___boxed(lean_object* x_1, lean_object* x_2) {
+LEAN_EXPORT lean_object* l_Lean_Expr_betaRev___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_3; 
-x_3 = l_Lean_Expr_betaRev(x_1, x_2);
+uint8_t x_4; lean_object* x_5; 
+x_4 = lean_unbox(x_3);
+lean_dec(x_3);
+x_5 = l_Lean_Expr_betaRev(x_1, x_2, x_4);
 lean_dec(x_2);
-lean_dec(x_1);
-return x_3;
+return x_5;
 }
 }
 LEAN_EXPORT lean_object* l_Lean_Expr_beta(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; lean_object* x_4; 
+lean_object* x_3; uint8_t x_4; lean_object* x_5; 
 x_3 = l_Array_reverse___rarg(x_2);
-x_4 = l_Lean_Expr_betaRev(x_1, x_3);
+x_4 = 0;
+x_5 = l_Lean_Expr_betaRev(x_1, x_3, x_4);
 lean_dec(x_3);
-return x_4;
+return x_5;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Expr_beta___boxed(lean_object* x_1, lean_object* x_2) {
+LEAN_EXPORT uint8_t l_Lean_Expr_isHeadBetaTargetFn(uint8_t x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; 
-x_3 = l_Lean_Expr_beta(x_1, x_2);
-lean_dec(x_1);
-return x_3;
-}
-}
-LEAN_EXPORT uint8_t l_Lean_Expr_isHeadBetaTargetFn(lean_object* x_1) {
-_start:
-{
-switch (lean_obj_tag(x_1)) {
+switch (lean_obj_tag(x_2)) {
 case 6:
 {
-uint8_t x_2; 
-x_2 = 1;
-return x_2;
+uint8_t x_3; 
+x_3 = 1;
+return x_3;
+}
+case 8:
+{
+if (x_1 == 0)
+{
+uint8_t x_4; 
+x_4 = 0;
+return x_4;
+}
+else
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_2, 3);
+x_2 = x_5;
+goto _start;
+}
 }
 case 10:
 {
-lean_object* x_3; 
-x_3 = lean_ctor_get(x_1, 1);
-x_1 = x_3;
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_2, 1);
+x_2 = x_7;
 goto _start;
 }
 default: 
 {
-uint8_t x_5; 
-x_5 = 0;
-return x_5;
+uint8_t x_9; 
+x_9 = 0;
+return x_9;
 }
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Expr_isHeadBetaTargetFn___boxed(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Expr_isHeadBetaTargetFn___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = l_Lean_Expr_isHeadBetaTargetFn(x_1);
+uint8_t x_3; uint8_t x_4; lean_object* x_5; 
+x_3 = lean_unbox(x_1);
 lean_dec(x_1);
-x_3 = lean_box(x_2);
-return x_3;
+x_4 = l_Lean_Expr_isHeadBetaTargetFn(x_3, x_2);
+lean_dec(x_2);
+x_5 = lean_box(x_4);
+return x_5;
 }
 }
 LEAN_EXPORT lean_object* l_Lean_Expr_headBeta(lean_object* x_1) {
 _start:
 {
-lean_object* x_2; uint8_t x_3; 
+lean_object* x_2; uint8_t x_3; uint8_t x_4; 
 x_2 = l_Lean_Expr_getAppFn(x_1);
-x_3 = l_Lean_Expr_isHeadBetaTargetFn(x_2);
-if (x_3 == 0)
+x_3 = 0;
+x_4 = l_Lean_Expr_isHeadBetaTargetFn(x_3, x_2);
+if (x_4 == 0)
 {
 lean_dec(x_2);
 return x_1;
 }
 else
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
-x_4 = lean_unsigned_to_nat(0u);
-x_5 = l_Lean_Expr_getAppNumArgsAux(x_1, x_4);
-x_6 = lean_mk_empty_array_with_capacity(x_5);
-lean_dec(x_5);
-x_7 = l___private_Lean_Expr_0__Lean_Expr_getAppRevArgsAux(x_1, x_6);
-x_8 = l_Lean_Expr_betaRev(x_2, x_7);
-lean_dec(x_7);
-lean_dec(x_2);
-return x_8;
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_5 = lean_unsigned_to_nat(0u);
+x_6 = l_Lean_Expr_getAppNumArgsAux(x_1, x_5);
+x_7 = lean_mk_empty_array_with_capacity(x_6);
+lean_dec(x_6);
+x_8 = l___private_Lean_Expr_0__Lean_Expr_getAppRevArgsAux(x_1, x_7);
+x_9 = l_Lean_Expr_betaRev(x_2, x_8, x_3);
+lean_dec(x_8);
+return x_9;
 }
 }
 }
-LEAN_EXPORT uint8_t l_Lean_Expr_isHeadBetaTarget(lean_object* x_1) {
+LEAN_EXPORT uint8_t l_Lean_Expr_isHeadBetaTarget(lean_object* x_1, uint8_t x_2) {
 _start:
 {
-lean_object* x_2; uint8_t x_3; 
-x_2 = l_Lean_Expr_getAppFn(x_1);
-x_3 = l_Lean_Expr_isHeadBetaTargetFn(x_2);
-lean_dec(x_2);
-return x_3;
+lean_object* x_3; uint8_t x_4; 
+x_3 = l_Lean_Expr_getAppFn(x_1);
+x_4 = l_Lean_Expr_isHeadBetaTargetFn(x_2, x_3);
+lean_dec(x_3);
+return x_4;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Expr_isHeadBetaTarget___boxed(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Expr_isHeadBetaTarget___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_2; lean_object* x_3; 
-x_2 = l_Lean_Expr_isHeadBetaTarget(x_1);
+uint8_t x_3; uint8_t x_4; lean_object* x_5; 
+x_3 = lean_unbox(x_2);
+lean_dec(x_2);
+x_4 = l_Lean_Expr_isHeadBetaTarget(x_1, x_3);
 lean_dec(x_1);
-x_3 = lean_box(x_2);
-return x_3;
+x_5 = lean_box(x_4);
+return x_5;
 }
 }
 LEAN_EXPORT lean_object* l___private_Lean_Expr_0__Lean_Expr_etaExpandedBody(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
@@ -13694,7 +13758,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateApp_x21___closed__1;
-x_3 = lean_unsigned_to_nat(966u);
+x_3 = lean_unsigned_to_nat(979u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Expr_appFn_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13765,7 +13829,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateConst_x21___closed__1;
-x_3 = lean_unsigned_to_nat(975u);
+x_3 = lean_unsigned_to_nat(988u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Expr_constName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13843,7 +13907,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateSort_x21___closed__1;
-x_3 = lean_unsigned_to_nat(984u);
+x_3 = lean_unsigned_to_nat(997u);
 x_4 = lean_unsigned_to_nat(16u);
 x_5 = l_Lean_Expr_updateSort_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13926,7 +13990,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateMData_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1001u);
+x_3 = lean_unsigned_to_nat(1014u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Expr_updateMData_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13996,7 +14060,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateProj_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1006u);
+x_3 = lean_unsigned_to_nat(1019u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Expr_updateProj_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -14079,7 +14143,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateForall_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1015u);
+x_3 = lean_unsigned_to_nat(1028u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l_Lean_Expr_updateForall_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -14155,7 +14219,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateForallE_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1020u);
+x_3 = lean_unsigned_to_nat(1033u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l_Lean_Expr_updateForall_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -14242,7 +14306,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateLambda_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1029u);
+x_3 = lean_unsigned_to_nat(1042u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Expr_updateLambda_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -14318,7 +14382,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateLambdaE_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1034u);
+x_3 = lean_unsigned_to_nat(1047u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Expr_updateLambda_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -14395,7 +14459,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__2;
 x_2 = l_Lean_Expr_updateLet_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1043u);
+x_3 = lean_unsigned_to_nat(1056u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Lean_Expr_letName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Meta/Basic.c

@@ -46,6 +46,7 @@ LEAN_EXPORT lean_object* l_Lean_Meta_withLocalDecl___at_Lean_Meta_withLocalDecls
 static lean_object* l_Lean_throwMaxRecDepthAt___at_Lean_Meta_withIncRecDepth___spec__1___rarg___closed__1;
 static lean_object* l_Lean_Meta_instInhabitedParamInfo___closed__1;
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Meta_etaExpand___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint64_t l_Lean_Meta_TransparencyMode_hash(uint8_t);
 lean_object* l_Lean_stringToMessageData(lean_object*);
 LEAN_EXPORT uint64_t l_Lean_Meta_InfoCacheKey_instHashableInfoCacheKey(lean_object*);
@@ -102,6 +103,7 @@ LEAN_EXPORT lean_object* l_Lean_Meta_mkConstWithFreshMVarLevels(lean_object*, le
 uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_mkFreshExprMVarAt___boxed(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_addTrace___at_Lean_Meta_processPostponed_loop___spec__1___closed__1;
+LEAN_EXPORT lean_object* l_Lean_Meta_etaExpand___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_mkFunUnit___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Meta_withMCtx___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1___closed__4;
@@ -638,6 +640,7 @@ LEAN_EXPORT lean_object* l_Lean_Meta_instMonadMCtxMetaM___lambda__2___boxed(lean
 LEAN_EXPORT lean_object* l_Lean_Meta_withDefault___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MetavarContext_exprDependsOn(lean_object*, lean_object*, lean_object*);
 lean_object* lean_local_ctx_mk_local_decl(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
+LEAN_EXPORT lean_object* l_Lean_Meta_etaExpand(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern uint8_t l_Lean_instInhabitedBinderInfo;
 LEAN_EXPORT lean_object* l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_withIncRecDepth(lean_object*);
@@ -697,7 +700,7 @@ static lean_object* l_Lean_Meta_processPostponed_loop___closed__3;
 uint8_t l_Lean_Expr_hasMVar(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_mapErrorImp(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_sortFVarIds(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*, uint8_t);
 LEAN_EXPORT lean_object* l_Lean_Meta_processPostponed_loop___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_toArray___rarg(lean_object*);
 static lean_object* l_Lean_Meta_instInhabitedMetaM___rarg___closed__2;
@@ -781,7 +784,7 @@ LEAN_EXPORT lean_object* l_Lean_Meta_throwIsDefEqStuck___boxed(lean_object*, lea
 static lean_object* l_Lean_Meta_processPostponed_loop___closed__4;
 LEAN_EXPORT lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_approxDefEqImp(lean_object*);
 lean_object* l_Lean_mkForall(lean_object*, uint8_t, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Meta_Basic___hyg_13207_(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Meta_Basic___hyg_13247_(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_instMonadMCtxMetaM___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_addMessageContextFull___at_Lean_Meta_instAddMessageContextMetaM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_resettingSynthInstanceCacheWhen(lean_object*);
@@ -9809,274 +9812,274 @@ return x_47;
 }
 else
 {
-lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_object* x_48; uint8_t x_49; lean_object* x_50; lean_object* x_51; 
 x_48 = l_Array_reverse___rarg(x_3);
-x_49 = l_Lean_Expr_betaRev(x_34, x_48);
+x_49 = 0;
+x_50 = l_Lean_Expr_betaRev(x_34, x_48, x_49);
 lean_dec(x_48);
-lean_dec(x_34);
-x_50 = l_Lean_MetavarContext_instantiateExprMVars___at_Lean_Meta_instantiateMVars___spec__1(x_49, x_5, x_6, x_7, x_8, x_9, x_35);
-return x_50;
+x_51 = l_Lean_MetavarContext_instantiateExprMVars___at_Lean_Meta_instantiateMVars___spec__1(x_50, x_5, x_6, x_7, x_8, x_9, x_35);
+return x_51;
 }
 }
 }
 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; 
-x_51 = lean_ctor_get(x_19, 0);
-lean_inc(x_51);
-lean_dec(x_19);
-x_52 = lean_ctor_get(x_51, 1);
+lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; 
+x_52 = lean_ctor_get(x_19, 0);
 lean_inc(x_52);
-x_53 = lean_ctor_get(x_51, 2);
+lean_dec(x_19);
+x_53 = lean_ctor_get(x_52, 1);
 lean_inc(x_53);
-lean_dec(x_51);
-x_54 = lean_array_get_size(x_3);
-x_55 = lean_array_get_size(x_52);
-x_56 = lean_nat_dec_lt(x_54, x_55);
-if (x_56 == 0)
+x_54 = lean_ctor_get(x_52, 2);
+lean_inc(x_54);
+lean_dec(x_52);
+x_55 = lean_array_get_size(x_3);
+x_56 = lean_array_get_size(x_53);
+x_57 = lean_nat_dec_lt(x_55, x_56);
+if (x_57 == 0)
 {
-lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
+lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; 
 lean_inc(x_7);
-x_57 = l_Lean_MetavarContext_instantiateExprMVars___at_Lean_Meta_instantiateMVars___spec__1(x_53, x_5, x_6, x_7, x_8, x_9, x_17);
-x_58 = lean_ctor_get(x_57, 0);
-lean_inc(x_58);
-x_59 = lean_ctor_get(x_57, 1);
+x_58 = l_Lean_MetavarContext_instantiateExprMVars___at_Lean_Meta_instantiateMVars___spec__1(x_54, x_5, x_6, x_7, x_8, x_9, x_17);
+x_59 = lean_ctor_get(x_58, 0);
 lean_inc(x_59);
-lean_dec(x_57);
-x_60 = l_Lean_Expr_hasExprMVar(x_58);
-if (x_60 == 0)
+x_60 = lean_ctor_get(x_58, 1);
+lean_inc(x_60);
+lean_dec(x_58);
+x_61 = l_Lean_Expr_hasExprMVar(x_59);
+if (x_61 == 0)
 {
-size_t x_61; size_t x_62; lean_object* x_63; uint8_t x_64; 
+size_t x_62; size_t x_63; lean_object* x_64; uint8_t x_65; 
 lean_dec(x_2);
-x_61 = lean_usize_of_nat(x_54);
-lean_dec(x_54);
-x_62 = 0;
-x_63 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_61, x_62, x_3, x_5, x_6, x_7, x_8, x_9, x_59);
-x_64 = !lean_is_exclusive(x_63);
-if (x_64 == 0)
-{
-lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
-x_65 = lean_ctor_get(x_63, 0);
-x_66 = lean_expr_abstract(x_58, x_52);
-lean_dec(x_52);
-lean_dec(x_58);
-x_67 = lean_unsigned_to_nat(0u);
-x_68 = lean_expr_instantiate_rev_range(x_66, x_67, x_55, x_65);
-lean_dec(x_66);
-x_69 = lean_array_get_size(x_65);
-x_70 = l___private_Lean_Expr_0__Lean_mkAppRangeAux(x_69, x_65, x_55, x_68);
-lean_dec(x_65);
-lean_dec(x_69);
-lean_ctor_set(x_63, 0, x_70);
-return x_63;
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
-x_71 = lean_ctor_get(x_63, 0);
-x_72 = lean_ctor_get(x_63, 1);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_dec(x_63);
-x_73 = lean_expr_abstract(x_58, x_52);
-lean_dec(x_52);
-lean_dec(x_58);
-x_74 = lean_unsigned_to_nat(0u);
-x_75 = lean_expr_instantiate_rev_range(x_73, x_74, x_55, x_71);
-lean_dec(x_73);
-x_76 = lean_array_get_size(x_71);
-x_77 = l___private_Lean_Expr_0__Lean_mkAppRangeAux(x_76, x_71, x_55, x_75);
-lean_dec(x_71);
-lean_dec(x_76);
-x_78 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_78, 0, x_77);
-lean_ctor_set(x_78, 1, x_72);
-return x_78;
-}
-}
-else
-{
-size_t x_79; size_t x_80; lean_object* x_81; uint8_t x_82; 
-lean_dec(x_58);
+x_62 = lean_usize_of_nat(x_55);
 lean_dec(x_55);
-lean_dec(x_52);
-x_79 = lean_usize_of_nat(x_54);
-lean_dec(x_54);
-x_80 = 0;
-x_81 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_79, x_80, x_3, x_5, x_6, x_7, x_8, x_9, x_59);
-x_82 = !lean_is_exclusive(x_81);
-if (x_82 == 0)
+x_63 = 0;
+x_64 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_62, x_63, x_3, x_5, x_6, x_7, x_8, x_9, x_60);
+x_65 = !lean_is_exclusive(x_64);
+if (x_65 == 0)
 {
-lean_object* x_83; lean_object* x_84; 
-x_83 = lean_ctor_get(x_81, 0);
-x_84 = l_Lean_mkAppN(x_2, x_83);
-lean_ctor_set(x_81, 0, x_84);
-return x_81;
-}
-else
-{
-lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; 
-x_85 = lean_ctor_get(x_81, 0);
-x_86 = lean_ctor_get(x_81, 1);
-lean_inc(x_86);
-lean_inc(x_85);
-lean_dec(x_81);
-x_87 = l_Lean_mkAppN(x_2, x_85);
-x_88 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_88, 0, x_87);
-lean_ctor_set(x_88, 1, x_86);
-return x_88;
-}
-}
-}
-else
-{
-size_t x_89; size_t x_90; lean_object* x_91; uint8_t x_92; 
-lean_dec(x_55);
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+x_66 = lean_ctor_get(x_64, 0);
+x_67 = lean_expr_abstract(x_59, x_53);
 lean_dec(x_53);
-lean_dec(x_52);
-x_89 = lean_usize_of_nat(x_54);
-lean_dec(x_54);
-x_90 = 0;
-x_91 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_89, x_90, x_3, x_5, x_6, x_7, x_8, x_9, x_17);
-x_92 = !lean_is_exclusive(x_91);
-if (x_92 == 0)
-{
-lean_object* x_93; lean_object* x_94; 
-x_93 = lean_ctor_get(x_91, 0);
-x_94 = l_Lean_mkAppN(x_2, x_93);
-lean_ctor_set(x_91, 0, x_94);
-return x_91;
+lean_dec(x_59);
+x_68 = lean_unsigned_to_nat(0u);
+x_69 = lean_expr_instantiate_rev_range(x_67, x_68, x_56, x_66);
+lean_dec(x_67);
+x_70 = lean_array_get_size(x_66);
+x_71 = l___private_Lean_Expr_0__Lean_mkAppRangeAux(x_70, x_66, x_56, x_69);
+lean_dec(x_66);
+lean_dec(x_70);
+lean_ctor_set(x_64, 0, x_71);
+return x_64;
 }
 else
 {
-lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; 
-x_95 = lean_ctor_get(x_91, 0);
-x_96 = lean_ctor_get(x_91, 1);
+lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
+x_72 = lean_ctor_get(x_64, 0);
+x_73 = lean_ctor_get(x_64, 1);
+lean_inc(x_73);
+lean_inc(x_72);
+lean_dec(x_64);
+x_74 = lean_expr_abstract(x_59, x_53);
+lean_dec(x_53);
+lean_dec(x_59);
+x_75 = lean_unsigned_to_nat(0u);
+x_76 = lean_expr_instantiate_rev_range(x_74, x_75, x_56, x_72);
+lean_dec(x_74);
+x_77 = lean_array_get_size(x_72);
+x_78 = l___private_Lean_Expr_0__Lean_mkAppRangeAux(x_77, x_72, x_56, x_76);
+lean_dec(x_72);
+lean_dec(x_77);
+x_79 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_79, 0, x_78);
+lean_ctor_set(x_79, 1, x_73);
+return x_79;
+}
+}
+else
+{
+size_t x_80; size_t x_81; lean_object* x_82; uint8_t x_83; 
+lean_dec(x_59);
+lean_dec(x_56);
+lean_dec(x_53);
+x_80 = lean_usize_of_nat(x_55);
+lean_dec(x_55);
+x_81 = 0;
+x_82 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_80, x_81, x_3, x_5, x_6, x_7, x_8, x_9, x_60);
+x_83 = !lean_is_exclusive(x_82);
+if (x_83 == 0)
+{
+lean_object* x_84; lean_object* x_85; 
+x_84 = lean_ctor_get(x_82, 0);
+x_85 = l_Lean_mkAppN(x_2, x_84);
+lean_ctor_set(x_82, 0, x_85);
+return x_82;
+}
+else
+{
+lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; 
+x_86 = lean_ctor_get(x_82, 0);
+x_87 = lean_ctor_get(x_82, 1);
+lean_inc(x_87);
+lean_inc(x_86);
+lean_dec(x_82);
+x_88 = l_Lean_mkAppN(x_2, x_86);
+x_89 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_89, 0, x_88);
+lean_ctor_set(x_89, 1, x_87);
+return x_89;
+}
+}
+}
+else
+{
+size_t x_90; size_t x_91; lean_object* x_92; uint8_t x_93; 
+lean_dec(x_56);
+lean_dec(x_54);
+lean_dec(x_53);
+x_90 = lean_usize_of_nat(x_55);
+lean_dec(x_55);
+x_91 = 0;
+x_92 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_90, x_91, x_3, x_5, x_6, x_7, x_8, x_9, x_17);
+x_93 = !lean_is_exclusive(x_92);
+if (x_93 == 0)
+{
+lean_object* x_94; lean_object* x_95; 
+x_94 = lean_ctor_get(x_92, 0);
+x_95 = l_Lean_mkAppN(x_2, x_94);
+lean_ctor_set(x_92, 0, x_95);
+return x_92;
+}
+else
+{
+lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; 
+x_96 = lean_ctor_get(x_92, 0);
+x_97 = lean_ctor_get(x_92, 1);
+lean_inc(x_97);
 lean_inc(x_96);
-lean_inc(x_95);
-lean_dec(x_91);
-x_97 = l_Lean_mkAppN(x_2, x_95);
-x_98 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_98, 0, x_97);
-lean_ctor_set(x_98, 1, x_96);
-return x_98;
+lean_dec(x_92);
+x_98 = l_Lean_mkAppN(x_2, x_96);
+x_99 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_99, 0, x_98);
+lean_ctor_set(x_99, 1, x_97);
+return x_99;
 }
 }
 }
 }
 case 5:
 {
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; 
-x_99 = lean_ctor_get(x_2, 0);
-lean_inc(x_99);
-x_100 = lean_ctor_get(x_2, 1);
+lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; 
+x_100 = lean_ctor_get(x_2, 0);
 lean_inc(x_100);
+x_101 = lean_ctor_get(x_2, 1);
+lean_inc(x_101);
 lean_dec(x_2);
-x_101 = lean_array_set(x_3, x_4, x_100);
-x_102 = lean_unsigned_to_nat(1u);
-x_103 = lean_nat_sub(x_4, x_102);
+x_102 = lean_array_set(x_3, x_4, x_101);
+x_103 = lean_unsigned_to_nat(1u);
+x_104 = lean_nat_sub(x_4, x_103);
 lean_dec(x_4);
-x_2 = x_99;
-x_3 = x_101;
-x_4 = x_103;
+x_2 = x_100;
+x_3 = x_102;
+x_4 = x_104;
 goto _start;
 }
 default: 
 {
-uint8_t x_105; lean_object* x_106; 
+uint8_t x_106; lean_object* x_107; 
 lean_dec(x_4);
 lean_dec(x_1);
-x_105 = l_Lean_Expr_isMVar(x_2);
+x_106 = l_Lean_Expr_isMVar(x_2);
 lean_inc(x_7);
-x_106 = l_Lean_MetavarContext_instantiateExprMVars___at_Lean_Meta_instantiateMVars___spec__1(x_2, x_5, x_6, x_7, x_8, x_9, x_10);
-if (x_105 == 0)
+x_107 = l_Lean_MetavarContext_instantiateExprMVars___at_Lean_Meta_instantiateMVars___spec__1(x_2, x_5, x_6, x_7, x_8, x_9, x_10);
+if (x_106 == 0)
 {
-lean_object* x_107; lean_object* x_108; lean_object* x_109; size_t x_110; size_t x_111; lean_object* x_112; uint8_t x_113; 
-x_107 = lean_ctor_get(x_106, 0);
-lean_inc(x_107);
-x_108 = lean_ctor_get(x_106, 1);
+lean_object* x_108; lean_object* x_109; lean_object* x_110; size_t x_111; size_t x_112; lean_object* x_113; uint8_t x_114; 
+x_108 = lean_ctor_get(x_107, 0);
 lean_inc(x_108);
-lean_dec(x_106);
-x_109 = lean_array_get_size(x_3);
-x_110 = lean_usize_of_nat(x_109);
-lean_dec(x_109);
-x_111 = 0;
-x_112 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_110, x_111, x_3, x_5, x_6, x_7, x_8, x_9, x_108);
-x_113 = !lean_is_exclusive(x_112);
-if (x_113 == 0)
+x_109 = lean_ctor_get(x_107, 1);
+lean_inc(x_109);
+lean_dec(x_107);
+x_110 = lean_array_get_size(x_3);
+x_111 = lean_usize_of_nat(x_110);
+lean_dec(x_110);
+x_112 = 0;
+x_113 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_111, x_112, x_3, x_5, x_6, x_7, x_8, x_9, x_109);
+x_114 = !lean_is_exclusive(x_113);
+if (x_114 == 0)
 {
-lean_object* x_114; lean_object* x_115; 
-x_114 = lean_ctor_get(x_112, 0);
-x_115 = l_Lean_mkAppN(x_107, x_114);
-lean_ctor_set(x_112, 0, x_115);
-return x_112;
+lean_object* x_115; lean_object* x_116; 
+x_115 = lean_ctor_get(x_113, 0);
+x_116 = l_Lean_mkAppN(x_108, x_115);
+lean_ctor_set(x_113, 0, x_116);
+return x_113;
 }
 else
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_112, 0);
-x_117 = lean_ctor_get(x_112, 1);
+lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; 
+x_117 = lean_ctor_get(x_113, 0);
+x_118 = lean_ctor_get(x_113, 1);
+lean_inc(x_118);
 lean_inc(x_117);
-lean_inc(x_116);
-lean_dec(x_112);
-x_118 = l_Lean_mkAppN(x_107, x_116);
-x_119 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_119, 0, x_118);
-lean_ctor_set(x_119, 1, x_117);
-return x_119;
+lean_dec(x_113);
+x_119 = l_Lean_mkAppN(x_108, x_117);
+x_120 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_120, 0, x_119);
+lean_ctor_set(x_120, 1, x_118);
+return x_120;
 }
 }
 else
 {
-lean_object* x_120; lean_object* x_121; uint8_t x_122; 
-x_120 = lean_ctor_get(x_106, 0);
-lean_inc(x_120);
-x_121 = lean_ctor_get(x_106, 1);
+lean_object* x_121; lean_object* x_122; uint8_t x_123; 
+x_121 = lean_ctor_get(x_107, 0);
 lean_inc(x_121);
-lean_dec(x_106);
-x_122 = l_Lean_Expr_isLambda(x_120);
-if (x_122 == 0)
+x_122 = lean_ctor_get(x_107, 1);
+lean_inc(x_122);
+lean_dec(x_107);
+x_123 = l_Lean_Expr_isLambda(x_121);
+if (x_123 == 0)
 {
-lean_object* x_123; size_t x_124; size_t x_125; lean_object* x_126; uint8_t x_127; 
-x_123 = lean_array_get_size(x_3);
-x_124 = lean_usize_of_nat(x_123);
-lean_dec(x_123);
-x_125 = 0;
-x_126 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_124, x_125, x_3, x_5, x_6, x_7, x_8, x_9, x_121);
-x_127 = !lean_is_exclusive(x_126);
-if (x_127 == 0)
+lean_object* x_124; size_t x_125; size_t x_126; lean_object* x_127; uint8_t x_128; 
+x_124 = lean_array_get_size(x_3);
+x_125 = lean_usize_of_nat(x_124);
+lean_dec(x_124);
+x_126 = 0;
+x_127 = l_Array_mapMUnsafe_map___at_Lean_Meta_instantiateMVars___spec__4(x_125, x_126, x_3, x_5, x_6, x_7, x_8, x_9, x_122);
+x_128 = !lean_is_exclusive(x_127);
+if (x_128 == 0)
 {
-lean_object* x_128; lean_object* x_129; 
-x_128 = lean_ctor_get(x_126, 0);
-x_129 = l_Lean_mkAppN(x_120, x_128);
-lean_ctor_set(x_126, 0, x_129);
-return x_126;
+lean_object* x_129; lean_object* x_130; 
+x_129 = lean_ctor_get(x_127, 0);
+x_130 = l_Lean_mkAppN(x_121, x_129);
+lean_ctor_set(x_127, 0, x_130);
+return x_127;
 }
 else
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_126, 0);
-x_131 = lean_ctor_get(x_126, 1);
+lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; 
+x_131 = lean_ctor_get(x_127, 0);
+x_132 = lean_ctor_get(x_127, 1);
+lean_inc(x_132);
 lean_inc(x_131);
-lean_inc(x_130);
-lean_dec(x_126);
-x_132 = l_Lean_mkAppN(x_120, x_130);
-x_133 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_133, 0, x_132);
-lean_ctor_set(x_133, 1, x_131);
-return x_133;
+lean_dec(x_127);
+x_133 = l_Lean_mkAppN(x_121, x_131);
+x_134 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_134, 0, x_133);
+lean_ctor_set(x_134, 1, x_132);
+return x_134;
 }
 }
 else
 {
-lean_object* x_134; lean_object* x_135; lean_object* x_136; 
-x_134 = l_Array_reverse___rarg(x_3);
-x_135 = l_Lean_Expr_betaRev(x_120, x_134);
-lean_dec(x_134);
-lean_dec(x_120);
-x_136 = l_Lean_MetavarContext_instantiateExprMVars___at_Lean_Meta_instantiateMVars___spec__1(x_135, x_5, x_6, x_7, x_8, x_9, x_121);
-return x_136;
+lean_object* x_135; uint8_t x_136; lean_object* x_137; lean_object* x_138; 
+x_135 = l_Array_reverse___rarg(x_3);
+x_136 = 0;
+x_137 = l_Lean_Expr_betaRev(x_121, x_135, x_136);
+lean_dec(x_135);
+x_138 = l_Lean_MetavarContext_instantiateExprMVars___at_Lean_Meta_instantiateMVars___spec__1(x_137, x_5, x_6, x_7, x_8, x_9, x_122);
+return x_138;
 }
 }
 }
@@ -40582,7 +40585,427 @@ return x_72;
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Meta_Basic___hyg_13207_(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Meta_etaExpand___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) {
+_start:
+{
+lean_object* x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
+lean_inc(x_2);
+x_9 = l_Lean_mkAppN(x_1, x_2);
+x_10 = 0;
+x_11 = 1;
+x_12 = l_Lean_Meta_mkLambdaFVars(x_2, x_9, x_10, x_11, x_4, x_5, x_6, x_7, x_8);
+return x_12;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Meta_etaExpand(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+uint8_t x_7; 
+x_7 = !lean_is_exclusive(x_2);
+if (x_7 == 0)
+{
+lean_object* x_8; uint8_t x_9; 
+x_8 = lean_ctor_get(x_2, 0);
+x_9 = !lean_is_exclusive(x_8);
+if (x_9 == 0)
+{
+uint8_t x_10; lean_object* x_11; 
+x_10 = 1;
+lean_ctor_set_uint8(x_8, 5, x_10);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_2);
+lean_inc(x_1);
+x_11 = lean_infer_type(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_12 = lean_ctor_get(x_11, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_11, 1);
+lean_inc(x_13);
+lean_dec(x_11);
+x_14 = lean_alloc_closure((void*)(l_Lean_Meta_etaExpand___lambda__1___boxed), 8, 1);
+lean_closure_set(x_14, 0, x_1);
+x_15 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_12, x_14, x_2, x_3, x_4, x_5, x_13);
+if (lean_obj_tag(x_15) == 0)
+{
+uint8_t x_16; 
+x_16 = !lean_is_exclusive(x_15);
+if (x_16 == 0)
+{
+return x_15;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+x_17 = lean_ctor_get(x_15, 0);
+x_18 = lean_ctor_get(x_15, 1);
+lean_inc(x_18);
+lean_inc(x_17);
+lean_dec(x_15);
+x_19 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_19, 0, x_17);
+lean_ctor_set(x_19, 1, x_18);
+return x_19;
+}
+}
+else
+{
+uint8_t x_20; 
+x_20 = !lean_is_exclusive(x_15);
+if (x_20 == 0)
+{
+return x_15;
+}
+else
+{
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_15, 0);
+x_22 = lean_ctor_get(x_15, 1);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_dec(x_15);
+x_23 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_23, 0, x_21);
+lean_ctor_set(x_23, 1, x_22);
+return x_23;
+}
+}
+}
+else
+{
+uint8_t x_24; 
+lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_24 = !lean_is_exclusive(x_11);
+if (x_24 == 0)
+{
+return x_11;
+}
+else
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_25 = lean_ctor_get(x_11, 0);
+x_26 = lean_ctor_get(x_11, 1);
+lean_inc(x_26);
+lean_inc(x_25);
+lean_dec(x_11);
+x_27 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_27, 0, x_25);
+lean_ctor_set(x_27, 1, x_26);
+return x_27;
+}
+}
+}
+else
+{
+uint8_t x_28; uint8_t x_29; uint8_t x_30; uint8_t x_31; uint8_t x_32; uint8_t x_33; uint8_t x_34; uint8_t x_35; uint8_t x_36; uint8_t x_37; uint8_t x_38; uint8_t x_39; uint8_t x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; 
+x_28 = lean_ctor_get_uint8(x_8, 0);
+x_29 = lean_ctor_get_uint8(x_8, 1);
+x_30 = lean_ctor_get_uint8(x_8, 2);
+x_31 = lean_ctor_get_uint8(x_8, 3);
+x_32 = lean_ctor_get_uint8(x_8, 4);
+x_33 = lean_ctor_get_uint8(x_8, 6);
+x_34 = lean_ctor_get_uint8(x_8, 7);
+x_35 = lean_ctor_get_uint8(x_8, 8);
+x_36 = lean_ctor_get_uint8(x_8, 9);
+x_37 = lean_ctor_get_uint8(x_8, 10);
+x_38 = lean_ctor_get_uint8(x_8, 11);
+x_39 = lean_ctor_get_uint8(x_8, 12);
+x_40 = lean_ctor_get_uint8(x_8, 13);
+lean_dec(x_8);
+x_41 = 1;
+x_42 = lean_alloc_ctor(0, 0, 14);
+lean_ctor_set_uint8(x_42, 0, x_28);
+lean_ctor_set_uint8(x_42, 1, x_29);
+lean_ctor_set_uint8(x_42, 2, x_30);
+lean_ctor_set_uint8(x_42, 3, x_31);
+lean_ctor_set_uint8(x_42, 4, x_32);
+lean_ctor_set_uint8(x_42, 5, x_41);
+lean_ctor_set_uint8(x_42, 6, x_33);
+lean_ctor_set_uint8(x_42, 7, x_34);
+lean_ctor_set_uint8(x_42, 8, x_35);
+lean_ctor_set_uint8(x_42, 9, x_36);
+lean_ctor_set_uint8(x_42, 10, x_37);
+lean_ctor_set_uint8(x_42, 11, x_38);
+lean_ctor_set_uint8(x_42, 12, x_39);
+lean_ctor_set_uint8(x_42, 13, x_40);
+lean_ctor_set(x_2, 0, x_42);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_2);
+lean_inc(x_1);
+x_43 = lean_infer_type(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_43) == 0)
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+x_44 = lean_ctor_get(x_43, 0);
+lean_inc(x_44);
+x_45 = lean_ctor_get(x_43, 1);
+lean_inc(x_45);
+lean_dec(x_43);
+x_46 = lean_alloc_closure((void*)(l_Lean_Meta_etaExpand___lambda__1___boxed), 8, 1);
+lean_closure_set(x_46, 0, x_1);
+x_47 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_44, x_46, x_2, x_3, x_4, x_5, x_45);
+if (lean_obj_tag(x_47) == 0)
+{
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+x_48 = lean_ctor_get(x_47, 0);
+lean_inc(x_48);
+x_49 = lean_ctor_get(x_47, 1);
+lean_inc(x_49);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ x_50 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_50 = lean_box(0);
+}
+if (lean_is_scalar(x_50)) {
+ x_51 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_51 = x_50;
+}
+lean_ctor_set(x_51, 0, x_48);
+lean_ctor_set(x_51, 1, x_49);
+return x_51;
+}
+else
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+x_52 = lean_ctor_get(x_47, 0);
+lean_inc(x_52);
+x_53 = lean_ctor_get(x_47, 1);
+lean_inc(x_53);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ x_54 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_54 = lean_box(0);
+}
+if (lean_is_scalar(x_54)) {
+ x_55 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_55 = x_54;
+}
+lean_ctor_set(x_55, 0, x_52);
+lean_ctor_set(x_55, 1, x_53);
+return x_55;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+lean_dec(x_2);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_56 = lean_ctor_get(x_43, 0);
+lean_inc(x_56);
+x_57 = lean_ctor_get(x_43, 1);
+lean_inc(x_57);
+if (lean_is_exclusive(x_43)) {
+ lean_ctor_release(x_43, 0);
+ lean_ctor_release(x_43, 1);
+ x_58 = x_43;
+} else {
+ lean_dec_ref(x_43);
+ x_58 = lean_box(0);
+}
+if (lean_is_scalar(x_58)) {
+ x_59 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_59 = x_58;
+}
+lean_ctor_set(x_59, 0, x_56);
+lean_ctor_set(x_59, 1, x_57);
+return x_59;
+}
+}
+}
+else
+{
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; uint8_t x_66; uint8_t x_67; uint8_t x_68; uint8_t x_69; uint8_t x_70; uint8_t x_71; uint8_t x_72; uint8_t x_73; uint8_t x_74; uint8_t x_75; uint8_t x_76; uint8_t x_77; uint8_t x_78; lean_object* x_79; uint8_t x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+x_60 = lean_ctor_get(x_2, 0);
+x_61 = lean_ctor_get(x_2, 1);
+x_62 = lean_ctor_get(x_2, 2);
+x_63 = lean_ctor_get(x_2, 3);
+x_64 = lean_ctor_get(x_2, 4);
+x_65 = lean_ctor_get(x_2, 5);
+lean_inc(x_65);
+lean_inc(x_64);
+lean_inc(x_63);
+lean_inc(x_62);
+lean_inc(x_61);
+lean_inc(x_60);
+lean_dec(x_2);
+x_66 = lean_ctor_get_uint8(x_60, 0);
+x_67 = lean_ctor_get_uint8(x_60, 1);
+x_68 = lean_ctor_get_uint8(x_60, 2);
+x_69 = lean_ctor_get_uint8(x_60, 3);
+x_70 = lean_ctor_get_uint8(x_60, 4);
+x_71 = lean_ctor_get_uint8(x_60, 6);
+x_72 = lean_ctor_get_uint8(x_60, 7);
+x_73 = lean_ctor_get_uint8(x_60, 8);
+x_74 = lean_ctor_get_uint8(x_60, 9);
+x_75 = lean_ctor_get_uint8(x_60, 10);
+x_76 = lean_ctor_get_uint8(x_60, 11);
+x_77 = lean_ctor_get_uint8(x_60, 12);
+x_78 = lean_ctor_get_uint8(x_60, 13);
+if (lean_is_exclusive(x_60)) {
+ x_79 = x_60;
+} else {
+ lean_dec_ref(x_60);
+ x_79 = lean_box(0);
+}
+x_80 = 1;
+if (lean_is_scalar(x_79)) {
+ x_81 = lean_alloc_ctor(0, 0, 14);
+} else {
+ x_81 = x_79;
+}
+lean_ctor_set_uint8(x_81, 0, x_66);
+lean_ctor_set_uint8(x_81, 1, x_67);
+lean_ctor_set_uint8(x_81, 2, x_68);
+lean_ctor_set_uint8(x_81, 3, x_69);
+lean_ctor_set_uint8(x_81, 4, x_70);
+lean_ctor_set_uint8(x_81, 5, x_80);
+lean_ctor_set_uint8(x_81, 6, x_71);
+lean_ctor_set_uint8(x_81, 7, x_72);
+lean_ctor_set_uint8(x_81, 8, x_73);
+lean_ctor_set_uint8(x_81, 9, x_74);
+lean_ctor_set_uint8(x_81, 10, x_75);
+lean_ctor_set_uint8(x_81, 11, x_76);
+lean_ctor_set_uint8(x_81, 12, x_77);
+lean_ctor_set_uint8(x_81, 13, x_78);
+x_82 = lean_alloc_ctor(0, 6, 0);
+lean_ctor_set(x_82, 0, x_81);
+lean_ctor_set(x_82, 1, x_61);
+lean_ctor_set(x_82, 2, x_62);
+lean_ctor_set(x_82, 3, x_63);
+lean_ctor_set(x_82, 4, x_64);
+lean_ctor_set(x_82, 5, x_65);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_82);
+lean_inc(x_1);
+x_83 = lean_infer_type(x_1, x_82, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_83) == 0)
+{
+lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; 
+x_84 = lean_ctor_get(x_83, 0);
+lean_inc(x_84);
+x_85 = lean_ctor_get(x_83, 1);
+lean_inc(x_85);
+lean_dec(x_83);
+x_86 = lean_alloc_closure((void*)(l_Lean_Meta_etaExpand___lambda__1___boxed), 8, 1);
+lean_closure_set(x_86, 0, x_1);
+x_87 = l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(x_84, x_86, x_82, x_3, x_4, x_5, x_85);
+if (lean_obj_tag(x_87) == 0)
+{
+lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
+x_88 = lean_ctor_get(x_87, 0);
+lean_inc(x_88);
+x_89 = lean_ctor_get(x_87, 1);
+lean_inc(x_89);
+if (lean_is_exclusive(x_87)) {
+ lean_ctor_release(x_87, 0);
+ lean_ctor_release(x_87, 1);
+ x_90 = x_87;
+} else {
+ lean_dec_ref(x_87);
+ x_90 = lean_box(0);
+}
+if (lean_is_scalar(x_90)) {
+ x_91 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_91 = x_90;
+}
+lean_ctor_set(x_91, 0, x_88);
+lean_ctor_set(x_91, 1, x_89);
+return x_91;
+}
+else
+{
+lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+x_92 = lean_ctor_get(x_87, 0);
+lean_inc(x_92);
+x_93 = lean_ctor_get(x_87, 1);
+lean_inc(x_93);
+if (lean_is_exclusive(x_87)) {
+ lean_ctor_release(x_87, 0);
+ lean_ctor_release(x_87, 1);
+ x_94 = x_87;
+} else {
+ lean_dec_ref(x_87);
+ x_94 = lean_box(0);
+}
+if (lean_is_scalar(x_94)) {
+ x_95 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_95 = x_94;
+}
+lean_ctor_set(x_95, 0, x_92);
+lean_ctor_set(x_95, 1, x_93);
+return x_95;
+}
+}
+else
+{
+lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; 
+lean_dec(x_82);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_96 = lean_ctor_get(x_83, 0);
+lean_inc(x_96);
+x_97 = lean_ctor_get(x_83, 1);
+lean_inc(x_97);
+if (lean_is_exclusive(x_83)) {
+ lean_ctor_release(x_83, 0);
+ lean_ctor_release(x_83, 1);
+ x_98 = x_83;
+} else {
+ lean_dec_ref(x_83);
+ x_98 = lean_box(0);
+}
+if (lean_is_scalar(x_98)) {
+ x_99 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_99 = x_98;
+}
+lean_ctor_set(x_99, 0, x_96);
+lean_ctor_set(x_99, 1, x_97);
+return x_99;
+}
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Meta_etaExpand___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) {
+_start:
+{
+lean_object* x_9; 
+x_9 = l_Lean_Meta_etaExpand___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+return x_9;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Meta_Basic___hyg_13247_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -41059,7 +41482,7 @@ l_Lean_Meta_isExprDefEq___closed__1 = _init_l_Lean_Meta_isExprDefEq___closed__1(
 lean_mark_persistent(l_Lean_Meta_isExprDefEq___closed__1);
 l_Lean_Meta_isExprDefEq___closed__2 = _init_l_Lean_Meta_isExprDefEq___closed__2();
 lean_mark_persistent(l_Lean_Meta_isExprDefEq___closed__2);
-res = l_Lean_initFn____x40_Lean_Meta_Basic___hyg_13207_(lean_io_mk_world());
+res = l_Lean_initFn____x40_Lean_Meta_Basic___hyg_13247_(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/Meta/Closure.c

@@ -3930,7 +3930,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__2;
-x_3 = lean_unsigned_to_nat(1001u);
+x_3 = lean_unsigned_to_nat(1014u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -3959,7 +3959,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__5;
-x_3 = lean_unsigned_to_nat(1006u);
+x_3 = lean_unsigned_to_nat(1019u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__6;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -3988,7 +3988,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__8;
-x_3 = lean_unsigned_to_nat(966u);
+x_3 = lean_unsigned_to_nat(979u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__9;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -4017,7 +4017,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__11;
-x_3 = lean_unsigned_to_nat(1034u);
+x_3 = lean_unsigned_to_nat(1047u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__12;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -4046,7 +4046,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__14;
-x_3 = lean_unsigned_to_nat(1020u);
+x_3 = lean_unsigned_to_nat(1033u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__15;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -4075,7 +4075,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__17;
-x_3 = lean_unsigned_to_nat(1043u);
+x_3 = lean_unsigned_to_nat(1056u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__18;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Meta/Coe.c

@@ -1022,30 +1022,29 @@ lean_inc(x_1);
 x_29 = l_Lean_Meta_transform_visit___at_Lean_Meta_expandCoe___spec__2(x_1, x_2, x_3, x_4, x_28, x_7, x_8, x_9, x_10, x_11, x_12);
 if (lean_obj_tag(x_29) == 0)
 {
-lean_object* x_30; lean_object* x_31; uint8_t x_32; uint8_t x_33; lean_object* x_34; 
+lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; 
 x_30 = lean_ctor_get(x_29, 0);
 lean_inc(x_30);
 x_31 = lean_ctor_get(x_29, 1);
 lean_inc(x_31);
 lean_dec(x_29);
 x_32 = 0;
-x_33 = 1;
 lean_inc(x_8);
-x_34 = l_Lean_Meta_mkLambdaFVars(x_5, x_30, x_32, x_33, x_8, x_9, x_10, x_11, x_31);
-if (lean_obj_tag(x_34) == 0)
+x_33 = l_Lean_Meta_mkLambdaFVars(x_5, x_30, x_32, x_32, x_8, x_9, x_10, x_11, x_31);
+if (lean_obj_tag(x_33) == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_35 = lean_ctor_get(x_34, 0);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_34 = lean_ctor_get(x_33, 0);
+lean_inc(x_34);
+x_35 = lean_ctor_get(x_33, 1);
 lean_inc(x_35);
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_dec(x_34);
-x_37 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_expandCoe___spec__3(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_36);
-return x_37;
+lean_dec(x_33);
+x_36 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_expandCoe___spec__3(x_1, x_2, x_3, x_4, x_34, x_7, x_8, x_9, x_10, x_11, x_35);
+return x_36;
 }
 else
 {
-uint8_t x_38; 
+uint8_t x_37; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -1055,29 +1054,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_38 = !lean_is_exclusive(x_34);
-if (x_38 == 0)
+x_37 = !lean_is_exclusive(x_33);
+if (x_37 == 0)
 {
-return x_34;
+return x_33;
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_39 = lean_ctor_get(x_34, 0);
-x_40 = lean_ctor_get(x_34, 1);
-lean_inc(x_40);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_38 = lean_ctor_get(x_33, 0);
+x_39 = lean_ctor_get(x_33, 1);
 lean_inc(x_39);
-lean_dec(x_34);
-x_41 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_41, 0, x_39);
-lean_ctor_set(x_41, 1, x_40);
-return x_41;
+lean_inc(x_38);
+lean_dec(x_33);
+x_40 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_39);
+return x_40;
 }
 }
 }
 else
 {
-uint8_t x_42; 
+uint8_t x_41; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -1088,23 +1087,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_42 = !lean_is_exclusive(x_29);
-if (x_42 == 0)
+x_41 = !lean_is_exclusive(x_29);
+if (x_41 == 0)
 {
 return x_29;
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_29, 0);
-x_44 = lean_ctor_get(x_29, 1);
-lean_inc(x_44);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_42 = lean_ctor_get(x_29, 0);
+x_43 = lean_ctor_get(x_29, 1);
 lean_inc(x_43);
+lean_inc(x_42);
 lean_dec(x_29);
-x_45 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_45, 0, x_43);
-lean_ctor_set(x_45, 1, x_44);
-return x_45;
+x_44 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_44, 0, x_42);
+lean_ctor_set(x_44, 1, x_43);
+return x_44;
 }
 }
 }
@@ -1278,30 +1277,29 @@ lean_inc(x_1);
 x_29 = l_Lean_Meta_transform_visit___at_Lean_Meta_expandCoe___spec__2(x_1, x_2, x_3, x_4, x_28, x_7, x_8, x_9, x_10, x_11, x_12);
 if (lean_obj_tag(x_29) == 0)
 {
-lean_object* x_30; lean_object* x_31; uint8_t x_32; uint8_t x_33; lean_object* x_34; 
+lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; 
 x_30 = lean_ctor_get(x_29, 0);
 lean_inc(x_30);
 x_31 = lean_ctor_get(x_29, 1);
 lean_inc(x_31);
 lean_dec(x_29);
 x_32 = 0;
-x_33 = 1;
 lean_inc(x_8);
-x_34 = l_Lean_Meta_mkForallFVars(x_5, x_30, x_32, x_33, x_8, x_9, x_10, x_11, x_31);
-if (lean_obj_tag(x_34) == 0)
+x_33 = l_Lean_Meta_mkForallFVars(x_5, x_30, x_32, x_32, x_8, x_9, x_10, x_11, x_31);
+if (lean_obj_tag(x_33) == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_35 = lean_ctor_get(x_34, 0);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_34 = lean_ctor_get(x_33, 0);
+lean_inc(x_34);
+x_35 = lean_ctor_get(x_33, 1);
 lean_inc(x_35);
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_dec(x_34);
-x_37 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_expandCoe___spec__3(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_36);
-return x_37;
+lean_dec(x_33);
+x_36 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_expandCoe___spec__3(x_1, x_2, x_3, x_4, x_34, x_7, x_8, x_9, x_10, x_11, x_35);
+return x_36;
 }
 else
 {
-uint8_t x_38; 
+uint8_t x_37; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -1311,29 +1309,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_38 = !lean_is_exclusive(x_34);
-if (x_38 == 0)
+x_37 = !lean_is_exclusive(x_33);
+if (x_37 == 0)
 {
-return x_34;
+return x_33;
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_39 = lean_ctor_get(x_34, 0);
-x_40 = lean_ctor_get(x_34, 1);
-lean_inc(x_40);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_38 = lean_ctor_get(x_33, 0);
+x_39 = lean_ctor_get(x_33, 1);
 lean_inc(x_39);
-lean_dec(x_34);
-x_41 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_41, 0, x_39);
-lean_ctor_set(x_41, 1, x_40);
-return x_41;
+lean_inc(x_38);
+lean_dec(x_33);
+x_40 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_39);
+return x_40;
 }
 }
 }
 else
 {
-uint8_t x_42; 
+uint8_t x_41; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -1344,23 +1342,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_42 = !lean_is_exclusive(x_29);
-if (x_42 == 0)
+x_41 = !lean_is_exclusive(x_29);
+if (x_41 == 0)
 {
 return x_29;
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_29, 0);
-x_44 = lean_ctor_get(x_29, 1);
-lean_inc(x_44);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_42 = lean_ctor_get(x_29, 0);
+x_43 = lean_ctor_get(x_29, 1);
 lean_inc(x_43);
+lean_inc(x_42);
 lean_dec(x_29);
-x_45 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_45, 0, x_43);
-lean_ctor_set(x_45, 1, x_44);
-return x_45;
+x_44 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_44, 0, x_42);
+lean_ctor_set(x_44, 1, x_43);
+return x_44;
 }
 }
 }
@@ -1591,30 +1589,29 @@ lean_inc(x_1);
 x_36 = l_Lean_Meta_transform_visit___at_Lean_Meta_expandCoe___spec__2(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_12);
 if (lean_obj_tag(x_36) == 0)
 {
-lean_object* x_37; lean_object* x_38; uint8_t x_39; uint8_t x_40; lean_object* x_41; 
+lean_object* x_37; lean_object* x_38; uint8_t x_39; lean_object* x_40; 
 x_37 = lean_ctor_get(x_36, 0);
 lean_inc(x_37);
 x_38 = lean_ctor_get(x_36, 1);
 lean_inc(x_38);
 lean_dec(x_36);
 x_39 = 0;
-x_40 = 1;
 lean_inc(x_8);
-x_41 = l_Lean_Meta_mkLambdaFVars(x_5, x_37, x_39, x_40, x_8, x_9, x_10, x_11, x_38);
-if (lean_obj_tag(x_41) == 0)
+x_40 = l_Lean_Meta_mkLambdaFVars(x_5, x_37, x_39, x_39, x_8, x_9, x_10, x_11, x_38);
+if (lean_obj_tag(x_40) == 0)
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_42 = lean_ctor_get(x_41, 0);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_41 = lean_ctor_get(x_40, 0);
+lean_inc(x_41);
+x_42 = lean_ctor_get(x_40, 1);
 lean_inc(x_42);
-x_43 = lean_ctor_get(x_41, 1);
-lean_inc(x_43);
-lean_dec(x_41);
-x_44 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_expandCoe___spec__3(x_1, x_2, x_3, x_4, x_42, x_7, x_8, x_9, x_10, x_11, x_43);
-return x_44;
+lean_dec(x_40);
+x_43 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_expandCoe___spec__3(x_1, x_2, x_3, x_4, x_41, x_7, x_8, x_9, x_10, x_11, x_42);
+return x_43;
 }
 else
 {
-uint8_t x_45; 
+uint8_t x_44; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -1624,29 +1621,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_45 = !lean_is_exclusive(x_41);
-if (x_45 == 0)
+x_44 = !lean_is_exclusive(x_40);
+if (x_44 == 0)
 {
-return x_41;
+return x_40;
 }
 else
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-x_46 = lean_ctor_get(x_41, 0);
-x_47 = lean_ctor_get(x_41, 1);
-lean_inc(x_47);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+x_45 = lean_ctor_get(x_40, 0);
+x_46 = lean_ctor_get(x_40, 1);
 lean_inc(x_46);
-lean_dec(x_41);
-x_48 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_48, 0, x_46);
-lean_ctor_set(x_48, 1, x_47);
-return x_48;
+lean_inc(x_45);
+lean_dec(x_40);
+x_47 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_47, 0, x_45);
+lean_ctor_set(x_47, 1, x_46);
+return x_47;
 }
 }
 }
 else
 {
-uint8_t x_49; 
+uint8_t x_48; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -1657,23 +1654,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_49 = !lean_is_exclusive(x_36);
-if (x_49 == 0)
+x_48 = !lean_is_exclusive(x_36);
+if (x_48 == 0)
 {
 return x_36;
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_50 = lean_ctor_get(x_36, 0);
-x_51 = lean_ctor_get(x_36, 1);
-lean_inc(x_51);
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+x_49 = lean_ctor_get(x_36, 0);
+x_50 = lean_ctor_get(x_36, 1);
 lean_inc(x_50);
+lean_inc(x_49);
 lean_dec(x_36);
-x_52 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_52, 0, x_50);
-lean_ctor_set(x_52, 1, x_51);
-return x_52;
+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;
 }
 }
 }

stage0/stdlib/Lean/Meta/ExprDefEq.c

@@ -15573,7 +15573,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__2;
-x_3 = lean_unsigned_to_nat(1001u);
+x_3 = lean_unsigned_to_nat(1014u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -15602,7 +15602,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__5;
-x_3 = lean_unsigned_to_nat(1006u);
+x_3 = lean_unsigned_to_nat(1019u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__6;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -15631,7 +15631,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__8;
-x_3 = lean_unsigned_to_nat(1034u);
+x_3 = lean_unsigned_to_nat(1047u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__9;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -15660,7 +15660,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__11;
-x_3 = lean_unsigned_to_nat(1020u);
+x_3 = lean_unsigned_to_nat(1033u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__12;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -15689,7 +15689,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__14;
-x_3 = lean_unsigned_to_nat(1043u);
+x_3 = lean_unsigned_to_nat(1056u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__15;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Meta/IndPredBelow.c

@@ -3122,30 +3122,29 @@ lean_inc(x_1);
 x_30 = l_Lean_Meta_transform_visit___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__2(x_1, x_2, x_3, x_4, x_29, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
 if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_31; lean_object* x_32; uint8_t x_33; uint8_t x_34; lean_object* x_35; 
+lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; 
 x_31 = lean_ctor_get(x_30, 0);
 lean_inc(x_31);
 x_32 = lean_ctor_get(x_30, 1);
 lean_inc(x_32);
 lean_dec(x_30);
 x_33 = 0;
-x_34 = 1;
 lean_inc(x_9);
-x_35 = l_Lean_Meta_mkLambdaFVars(x_5, x_31, x_33, x_34, x_9, x_10, x_11, x_12, x_32);
-if (lean_obj_tag(x_35) == 0)
+x_34 = l_Lean_Meta_mkLambdaFVars(x_5, x_31, x_33, x_33, x_9, x_10, x_11, x_12, x_32);
+if (lean_obj_tag(x_34) == 0)
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_35, 0);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_35 = lean_ctor_get(x_34, 0);
+lean_inc(x_35);
+x_36 = lean_ctor_get(x_34, 1);
 lean_inc(x_36);
-x_37 = lean_ctor_get(x_35, 1);
-lean_inc(x_37);
-lean_dec(x_35);
-x_38 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__3(x_1, x_2, x_3, x_4, x_36, x_7, x_8, x_9, x_10, x_11, x_12, x_37);
-return x_38;
+lean_dec(x_34);
+x_37 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__3(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_12, x_36);
+return x_37;
 }
 else
 {
-uint8_t x_39; 
+uint8_t x_38; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -3156,29 +3155,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_39 = !lean_is_exclusive(x_35);
-if (x_39 == 0)
+x_38 = !lean_is_exclusive(x_34);
+if (x_38 == 0)
 {
-return x_35;
+return x_34;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_40 = lean_ctor_get(x_35, 0);
-x_41 = lean_ctor_get(x_35, 1);
-lean_inc(x_41);
+lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_39 = lean_ctor_get(x_34, 0);
+x_40 = lean_ctor_get(x_34, 1);
 lean_inc(x_40);
-lean_dec(x_35);
-x_42 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_42, 0, x_40);
-lean_ctor_set(x_42, 1, x_41);
-return x_42;
+lean_inc(x_39);
+lean_dec(x_34);
+x_41 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_41, 0, x_39);
+lean_ctor_set(x_41, 1, x_40);
+return x_41;
 }
 }
 }
 else
 {
-uint8_t x_43; 
+uint8_t x_42; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -3190,23 +3189,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_43 = !lean_is_exclusive(x_30);
-if (x_43 == 0)
+x_42 = !lean_is_exclusive(x_30);
+if (x_42 == 0)
 {
 return x_30;
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_44 = lean_ctor_get(x_30, 0);
-x_45 = lean_ctor_get(x_30, 1);
-lean_inc(x_45);
+lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+x_43 = lean_ctor_get(x_30, 0);
+x_44 = lean_ctor_get(x_30, 1);
 lean_inc(x_44);
+lean_inc(x_43);
 lean_dec(x_30);
-x_46 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_46, 0, x_44);
-lean_ctor_set(x_46, 1, x_45);
-return x_46;
+x_45 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_45, 0, x_43);
+lean_ctor_set(x_45, 1, x_44);
+return x_45;
 }
 }
 }
@@ -3384,30 +3383,29 @@ lean_inc(x_1);
 x_30 = l_Lean_Meta_transform_visit___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__2(x_1, x_2, x_3, x_4, x_29, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
 if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_31; lean_object* x_32; uint8_t x_33; uint8_t x_34; lean_object* x_35; 
+lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; 
 x_31 = lean_ctor_get(x_30, 0);
 lean_inc(x_31);
 x_32 = lean_ctor_get(x_30, 1);
 lean_inc(x_32);
 lean_dec(x_30);
 x_33 = 0;
-x_34 = 1;
 lean_inc(x_9);
-x_35 = l_Lean_Meta_mkForallFVars(x_5, x_31, x_33, x_34, x_9, x_10, x_11, x_12, x_32);
-if (lean_obj_tag(x_35) == 0)
+x_34 = l_Lean_Meta_mkForallFVars(x_5, x_31, x_33, x_33, x_9, x_10, x_11, x_12, x_32);
+if (lean_obj_tag(x_34) == 0)
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_35, 0);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_35 = lean_ctor_get(x_34, 0);
+lean_inc(x_35);
+x_36 = lean_ctor_get(x_34, 1);
 lean_inc(x_36);
-x_37 = lean_ctor_get(x_35, 1);
-lean_inc(x_37);
-lean_dec(x_35);
-x_38 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__3(x_1, x_2, x_3, x_4, x_36, x_7, x_8, x_9, x_10, x_11, x_12, x_37);
-return x_38;
+lean_dec(x_34);
+x_37 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__3(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_12, x_36);
+return x_37;
 }
 else
 {
-uint8_t x_39; 
+uint8_t x_38; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -3418,29 +3416,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_39 = !lean_is_exclusive(x_35);
-if (x_39 == 0)
+x_38 = !lean_is_exclusive(x_34);
+if (x_38 == 0)
 {
-return x_35;
+return x_34;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_40 = lean_ctor_get(x_35, 0);
-x_41 = lean_ctor_get(x_35, 1);
-lean_inc(x_41);
+lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_39 = lean_ctor_get(x_34, 0);
+x_40 = lean_ctor_get(x_34, 1);
 lean_inc(x_40);
-lean_dec(x_35);
-x_42 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_42, 0, x_40);
-lean_ctor_set(x_42, 1, x_41);
-return x_42;
+lean_inc(x_39);
+lean_dec(x_34);
+x_41 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_41, 0, x_39);
+lean_ctor_set(x_41, 1, x_40);
+return x_41;
 }
 }
 }
 else
 {
-uint8_t x_43; 
+uint8_t x_42; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -3452,23 +3450,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_43 = !lean_is_exclusive(x_30);
-if (x_43 == 0)
+x_42 = !lean_is_exclusive(x_30);
+if (x_42 == 0)
 {
 return x_30;
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_44 = lean_ctor_get(x_30, 0);
-x_45 = lean_ctor_get(x_30, 1);
-lean_inc(x_45);
+lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+x_43 = lean_ctor_get(x_30, 0);
+x_44 = lean_ctor_get(x_30, 1);
 lean_inc(x_44);
+lean_inc(x_43);
 lean_dec(x_30);
-x_46 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_46, 0, x_44);
-lean_ctor_set(x_46, 1, x_45);
-return x_46;
+x_45 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_45, 0, x_43);
+lean_ctor_set(x_45, 1, x_44);
+return x_45;
 }
 }
 }
@@ -3705,30 +3703,29 @@ lean_inc(x_1);
 x_37 = l_Lean_Meta_transform_visit___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__2(x_1, x_2, x_3, x_4, x_36, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
 if (lean_obj_tag(x_37) == 0)
 {
-lean_object* x_38; lean_object* x_39; uint8_t x_40; uint8_t x_41; lean_object* x_42; 
+lean_object* x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; 
 x_38 = lean_ctor_get(x_37, 0);
 lean_inc(x_38);
 x_39 = lean_ctor_get(x_37, 1);
 lean_inc(x_39);
 lean_dec(x_37);
 x_40 = 0;
-x_41 = 1;
 lean_inc(x_9);
-x_42 = l_Lean_Meta_mkLambdaFVars(x_5, x_38, x_40, x_41, x_9, x_10, x_11, x_12, x_39);
-if (lean_obj_tag(x_42) == 0)
+x_41 = l_Lean_Meta_mkLambdaFVars(x_5, x_38, x_40, x_40, x_9, x_10, x_11, x_12, x_39);
+if (lean_obj_tag(x_41) == 0)
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_42, 0);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_42 = lean_ctor_get(x_41, 0);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_41, 1);
 lean_inc(x_43);
-x_44 = lean_ctor_get(x_42, 1);
-lean_inc(x_44);
-lean_dec(x_42);
-x_45 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__3(x_1, x_2, x_3, x_4, x_43, x_7, x_8, x_9, x_10, x_11, x_12, x_44);
-return x_45;
+lean_dec(x_41);
+x_44 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_IndPredBelow_mkCtorType_checkCount___spec__3(x_1, x_2, x_3, x_4, x_42, x_7, x_8, x_9, x_10, x_11, x_12, x_43);
+return x_44;
 }
 else
 {
-uint8_t x_46; 
+uint8_t x_45; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -3739,29 +3736,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_46 = !lean_is_exclusive(x_42);
-if (x_46 == 0)
+x_45 = !lean_is_exclusive(x_41);
+if (x_45 == 0)
 {
-return x_42;
+return x_41;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_47 = lean_ctor_get(x_42, 0);
-x_48 = lean_ctor_get(x_42, 1);
-lean_inc(x_48);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+x_46 = lean_ctor_get(x_41, 0);
+x_47 = lean_ctor_get(x_41, 1);
 lean_inc(x_47);
-lean_dec(x_42);
-x_49 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_49, 0, x_47);
-lean_ctor_set(x_49, 1, x_48);
-return x_49;
+lean_inc(x_46);
+lean_dec(x_41);
+x_48 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_48, 0, x_46);
+lean_ctor_set(x_48, 1, x_47);
+return x_48;
 }
 }
 }
 else
 {
-uint8_t x_50; 
+uint8_t x_49; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -3773,23 +3770,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_50 = !lean_is_exclusive(x_37);
-if (x_50 == 0)
+x_49 = !lean_is_exclusive(x_37);
+if (x_49 == 0)
 {
 return x_37;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-x_51 = lean_ctor_get(x_37, 0);
-x_52 = lean_ctor_get(x_37, 1);
-lean_inc(x_52);
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+x_50 = lean_ctor_get(x_37, 0);
+x_51 = lean_ctor_get(x_37, 1);
 lean_inc(x_51);
+lean_inc(x_50);
 lean_dec(x_37);
-x_53 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_53, 0, x_51);
-lean_ctor_set(x_53, 1, x_52);
-return x_53;
+x_52 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_52, 0, x_50);
+lean_ctor_set(x_52, 1, x_51);
+return x_52;
 }
 }
 }

stage0/stdlib/Lean/Meta/InferType.c

@@ -185,7 +185,7 @@ uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 uint8_t lean_usize_dec_le(size_t, size_t);
 LEAN_EXPORT lean_object* l___private_Lean_Meta_InferType_0__Lean_Meta_inferLambdaType___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_hasMVar(lean_object*);
-lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Meta_throwUnknownFVar___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkAppRev(lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_throwIncorrectNumberOfLevels___rarg___closed__2;
@@ -950,43 +950,43 @@ return x_20;
 }
 else
 {
-lean_object* x_25; 
-x_25 = l_Lean_Expr_betaRev(x_15, x_22);
+uint8_t x_25; lean_object* x_26; 
+x_25 = 0;
+x_26 = l_Lean_Expr_betaRev(x_15, x_22, x_25);
 lean_dec(x_22);
-lean_dec(x_15);
-lean_ctor_set(x_20, 0, x_25);
+lean_ctor_set(x_20, 0, x_26);
 return x_20;
 }
 }
 else
 {
-lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_26 = lean_ctor_get(x_20, 0);
-x_27 = lean_ctor_get(x_20, 1);
+lean_object* x_27; lean_object* x_28; uint8_t x_29; 
+x_27 = lean_ctor_get(x_20, 0);
+x_28 = lean_ctor_get(x_20, 1);
+lean_inc(x_28);
 lean_inc(x_27);
-lean_inc(x_26);
 lean_dec(x_20);
-x_28 = l_Lean_Expr_isBVar(x_7);
+x_29 = l_Lean_Expr_isBVar(x_7);
 lean_dec(x_7);
-if (x_28 == 0)
+if (x_29 == 0)
 {
-lean_object* x_29; lean_object* x_30; 
-x_29 = l_Lean_mkAppRev(x_15, x_26);
-x_30 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_30, 0, x_29);
-lean_ctor_set(x_30, 1, x_27);
-return x_30;
+lean_object* x_30; lean_object* x_31; 
+x_30 = l_Lean_mkAppRev(x_15, x_27);
+x_31 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_31, 0, x_30);
+lean_ctor_set(x_31, 1, x_28);
+return x_31;
 }
 else
 {
-lean_object* x_31; lean_object* x_32; 
-x_31 = l_Lean_Expr_betaRev(x_15, x_26);
-lean_dec(x_26);
-lean_dec(x_15);
-x_32 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_32, 0, x_31);
-lean_ctor_set(x_32, 1, x_27);
-return x_32;
+uint8_t x_32; lean_object* x_33; lean_object* x_34; 
+x_32 = 0;
+x_33 = l_Lean_Expr_betaRev(x_15, x_27, x_32);
+lean_dec(x_27);
+x_34 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_34, 0, x_33);
+lean_ctor_set(x_34, 1, x_28);
+return x_34;
 }
 }
 }

stage0/stdlib/Lean/Meta/Match/MatchEqs.c

@@ -3136,30 +3136,29 @@ lean_inc(x_1);
 x_29 = l_Lean_Meta_transform_visit___at_Lean_Meta_Match_unfoldNamedPattern___spec__2(x_1, x_2, x_3, x_4, x_28, x_7, x_8, x_9, x_10, x_11, x_12);
 if (lean_obj_tag(x_29) == 0)
 {
-lean_object* x_30; lean_object* x_31; uint8_t x_32; uint8_t x_33; lean_object* x_34; 
+lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; 
 x_30 = lean_ctor_get(x_29, 0);
 lean_inc(x_30);
 x_31 = lean_ctor_get(x_29, 1);
 lean_inc(x_31);
 lean_dec(x_29);
 x_32 = 0;
-x_33 = 1;
 lean_inc(x_8);
-x_34 = l_Lean_Meta_mkLambdaFVars(x_5, x_30, x_32, x_33, x_8, x_9, x_10, x_11, x_31);
-if (lean_obj_tag(x_34) == 0)
+x_33 = l_Lean_Meta_mkLambdaFVars(x_5, x_30, x_32, x_32, x_8, x_9, x_10, x_11, x_31);
+if (lean_obj_tag(x_33) == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_35 = lean_ctor_get(x_34, 0);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_34 = lean_ctor_get(x_33, 0);
+lean_inc(x_34);
+x_35 = lean_ctor_get(x_33, 1);
 lean_inc(x_35);
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_dec(x_34);
-x_37 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_Match_unfoldNamedPattern___spec__3(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_36);
-return x_37;
+lean_dec(x_33);
+x_36 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_Match_unfoldNamedPattern___spec__3(x_1, x_2, x_3, x_4, x_34, x_7, x_8, x_9, x_10, x_11, x_35);
+return x_36;
 }
 else
 {
-uint8_t x_38; 
+uint8_t x_37; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -3169,29 +3168,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_38 = !lean_is_exclusive(x_34);
-if (x_38 == 0)
+x_37 = !lean_is_exclusive(x_33);
+if (x_37 == 0)
 {
-return x_34;
+return x_33;
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_39 = lean_ctor_get(x_34, 0);
-x_40 = lean_ctor_get(x_34, 1);
-lean_inc(x_40);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_38 = lean_ctor_get(x_33, 0);
+x_39 = lean_ctor_get(x_33, 1);
 lean_inc(x_39);
-lean_dec(x_34);
-x_41 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_41, 0, x_39);
-lean_ctor_set(x_41, 1, x_40);
-return x_41;
+lean_inc(x_38);
+lean_dec(x_33);
+x_40 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_39);
+return x_40;
 }
 }
 }
 else
 {
-uint8_t x_42; 
+uint8_t x_41; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -3202,23 +3201,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_42 = !lean_is_exclusive(x_29);
-if (x_42 == 0)
+x_41 = !lean_is_exclusive(x_29);
+if (x_41 == 0)
 {
 return x_29;
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_29, 0);
-x_44 = lean_ctor_get(x_29, 1);
-lean_inc(x_44);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_42 = lean_ctor_get(x_29, 0);
+x_43 = lean_ctor_get(x_29, 1);
 lean_inc(x_43);
+lean_inc(x_42);
 lean_dec(x_29);
-x_45 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_45, 0, x_43);
-lean_ctor_set(x_45, 1, x_44);
-return x_45;
+x_44 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_44, 0, x_42);
+lean_ctor_set(x_44, 1, x_43);
+return x_44;
 }
 }
 }
@@ -3392,30 +3391,29 @@ lean_inc(x_1);
 x_29 = l_Lean_Meta_transform_visit___at_Lean_Meta_Match_unfoldNamedPattern___spec__2(x_1, x_2, x_3, x_4, x_28, x_7, x_8, x_9, x_10, x_11, x_12);
 if (lean_obj_tag(x_29) == 0)
 {
-lean_object* x_30; lean_object* x_31; uint8_t x_32; uint8_t x_33; lean_object* x_34; 
+lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; 
 x_30 = lean_ctor_get(x_29, 0);
 lean_inc(x_30);
 x_31 = lean_ctor_get(x_29, 1);
 lean_inc(x_31);
 lean_dec(x_29);
 x_32 = 0;
-x_33 = 1;
 lean_inc(x_8);
-x_34 = l_Lean_Meta_mkForallFVars(x_5, x_30, x_32, x_33, x_8, x_9, x_10, x_11, x_31);
-if (lean_obj_tag(x_34) == 0)
+x_33 = l_Lean_Meta_mkForallFVars(x_5, x_30, x_32, x_32, x_8, x_9, x_10, x_11, x_31);
+if (lean_obj_tag(x_33) == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_35 = lean_ctor_get(x_34, 0);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_34 = lean_ctor_get(x_33, 0);
+lean_inc(x_34);
+x_35 = lean_ctor_get(x_33, 1);
 lean_inc(x_35);
-x_36 = lean_ctor_get(x_34, 1);
-lean_inc(x_36);
-lean_dec(x_34);
-x_37 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_Match_unfoldNamedPattern___spec__3(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_36);
-return x_37;
+lean_dec(x_33);
+x_36 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_Match_unfoldNamedPattern___spec__3(x_1, x_2, x_3, x_4, x_34, x_7, x_8, x_9, x_10, x_11, x_35);
+return x_36;
 }
 else
 {
-uint8_t x_38; 
+uint8_t x_37; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -3425,29 +3423,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_38 = !lean_is_exclusive(x_34);
-if (x_38 == 0)
+x_37 = !lean_is_exclusive(x_33);
+if (x_37 == 0)
 {
-return x_34;
+return x_33;
 }
 else
 {
-lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_39 = lean_ctor_get(x_34, 0);
-x_40 = lean_ctor_get(x_34, 1);
-lean_inc(x_40);
+lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_38 = lean_ctor_get(x_33, 0);
+x_39 = lean_ctor_get(x_33, 1);
 lean_inc(x_39);
-lean_dec(x_34);
-x_41 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_41, 0, x_39);
-lean_ctor_set(x_41, 1, x_40);
-return x_41;
+lean_inc(x_38);
+lean_dec(x_33);
+x_40 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_39);
+return x_40;
 }
 }
 }
 else
 {
-uint8_t x_42; 
+uint8_t x_41; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -3458,23 +3456,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_42 = !lean_is_exclusive(x_29);
-if (x_42 == 0)
+x_41 = !lean_is_exclusive(x_29);
+if (x_41 == 0)
 {
 return x_29;
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_29, 0);
-x_44 = lean_ctor_get(x_29, 1);
-lean_inc(x_44);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_42 = lean_ctor_get(x_29, 0);
+x_43 = lean_ctor_get(x_29, 1);
 lean_inc(x_43);
+lean_inc(x_42);
 lean_dec(x_29);
-x_45 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_45, 0, x_43);
-lean_ctor_set(x_45, 1, x_44);
-return x_45;
+x_44 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_44, 0, x_42);
+lean_ctor_set(x_44, 1, x_43);
+return x_44;
 }
 }
 }
@@ -3705,30 +3703,29 @@ lean_inc(x_1);
 x_36 = l_Lean_Meta_transform_visit___at_Lean_Meta_Match_unfoldNamedPattern___spec__2(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_12);
 if (lean_obj_tag(x_36) == 0)
 {
-lean_object* x_37; lean_object* x_38; uint8_t x_39; uint8_t x_40; lean_object* x_41; 
+lean_object* x_37; lean_object* x_38; uint8_t x_39; lean_object* x_40; 
 x_37 = lean_ctor_get(x_36, 0);
 lean_inc(x_37);
 x_38 = lean_ctor_get(x_36, 1);
 lean_inc(x_38);
 lean_dec(x_36);
 x_39 = 0;
-x_40 = 1;
 lean_inc(x_8);
-x_41 = l_Lean_Meta_mkLambdaFVars(x_5, x_37, x_39, x_40, x_8, x_9, x_10, x_11, x_38);
-if (lean_obj_tag(x_41) == 0)
+x_40 = l_Lean_Meta_mkLambdaFVars(x_5, x_37, x_39, x_39, x_8, x_9, x_10, x_11, x_38);
+if (lean_obj_tag(x_40) == 0)
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_42 = lean_ctor_get(x_41, 0);
+lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_41 = lean_ctor_get(x_40, 0);
+lean_inc(x_41);
+x_42 = lean_ctor_get(x_40, 1);
 lean_inc(x_42);
-x_43 = lean_ctor_get(x_41, 1);
-lean_inc(x_43);
-lean_dec(x_41);
-x_44 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_Match_unfoldNamedPattern___spec__3(x_1, x_2, x_3, x_4, x_42, x_7, x_8, x_9, x_10, x_11, x_43);
-return x_44;
+lean_dec(x_40);
+x_43 = l_Lean_Meta_transform_visit_visitPost___at_Lean_Meta_Match_unfoldNamedPattern___spec__3(x_1, x_2, x_3, x_4, x_41, x_7, x_8, x_9, x_10, x_11, x_42);
+return x_43;
 }
 else
 {
-uint8_t x_45; 
+uint8_t x_44; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -3738,29 +3735,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_45 = !lean_is_exclusive(x_41);
-if (x_45 == 0)
+x_44 = !lean_is_exclusive(x_40);
+if (x_44 == 0)
 {
-return x_41;
+return x_40;
 }
 else
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-x_46 = lean_ctor_get(x_41, 0);
-x_47 = lean_ctor_get(x_41, 1);
-lean_inc(x_47);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+x_45 = lean_ctor_get(x_40, 0);
+x_46 = lean_ctor_get(x_40, 1);
 lean_inc(x_46);
-lean_dec(x_41);
-x_48 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_48, 0, x_46);
-lean_ctor_set(x_48, 1, x_47);
-return x_48;
+lean_inc(x_45);
+lean_dec(x_40);
+x_47 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_47, 0, x_45);
+lean_ctor_set(x_47, 1, x_46);
+return x_47;
 }
 }
 }
 else
 {
-uint8_t x_49; 
+uint8_t x_48; 
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -3771,23 +3768,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_49 = !lean_is_exclusive(x_36);
-if (x_49 == 0)
+x_48 = !lean_is_exclusive(x_36);
+if (x_48 == 0)
 {
 return x_36;
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_50 = lean_ctor_get(x_36, 0);
-x_51 = lean_ctor_get(x_36, 1);
-lean_inc(x_51);
+lean_object* x_49; lean_object* x_50; lean_object* x_51; 
+x_49 = lean_ctor_get(x_36, 0);
+x_50 = lean_ctor_get(x_36, 1);
 lean_inc(x_50);
+lean_inc(x_49);
 lean_dec(x_36);
-x_52 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_52, 0, x_50);
-lean_ctor_set(x_52, 1, x_51);
-return x_52;
+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;
 }
 }
 }
@@ -19999,30 +19996,29 @@ lean_inc(x_1);
 x_30 = l_Lean_Meta_transform_visit___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__7(x_1, x_2, x_3, x_4, x_29, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
 if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_31; lean_object* x_32; uint8_t x_33; uint8_t x_34; lean_object* x_35; 
+lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; 
 x_31 = lean_ctor_get(x_30, 0);
 lean_inc(x_31);
 x_32 = lean_ctor_get(x_30, 1);
 lean_inc(x_32);
 lean_dec(x_30);
 x_33 = 0;
-x_34 = 1;
 lean_inc(x_9);
-x_35 = l_Lean_Meta_mkLambdaFVars(x_5, x_31, x_33, x_34, x_9, x_10, x_11, x_12, x_32);
-if (lean_obj_tag(x_35) == 0)
+x_34 = l_Lean_Meta_mkLambdaFVars(x_5, x_31, x_33, x_33, x_9, x_10, x_11, x_12, x_32);
+if (lean_obj_tag(x_34) == 0)
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_35, 0);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_35 = lean_ctor_get(x_34, 0);
+lean_inc(x_35);
+x_36 = lean_ctor_get(x_34, 1);
 lean_inc(x_36);
-x_37 = lean_ctor_get(x_35, 1);
-lean_inc(x_37);
-lean_dec(x_35);
-x_38 = l_Lean_Meta_transform_visit_visitPost___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__8(x_1, x_2, x_3, x_4, x_36, x_7, x_8, x_9, x_10, x_11, x_12, x_37);
-return x_38;
+lean_dec(x_34);
+x_37 = l_Lean_Meta_transform_visit_visitPost___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__8(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_12, x_36);
+return x_37;
 }
 else
 {
-uint8_t x_39; 
+uint8_t x_38; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -20033,29 +20029,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_39 = !lean_is_exclusive(x_35);
-if (x_39 == 0)
+x_38 = !lean_is_exclusive(x_34);
+if (x_38 == 0)
 {
-return x_35;
+return x_34;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_40 = lean_ctor_get(x_35, 0);
-x_41 = lean_ctor_get(x_35, 1);
-lean_inc(x_41);
+lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_39 = lean_ctor_get(x_34, 0);
+x_40 = lean_ctor_get(x_34, 1);
 lean_inc(x_40);
-lean_dec(x_35);
-x_42 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_42, 0, x_40);
-lean_ctor_set(x_42, 1, x_41);
-return x_42;
+lean_inc(x_39);
+lean_dec(x_34);
+x_41 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_41, 0, x_39);
+lean_ctor_set(x_41, 1, x_40);
+return x_41;
 }
 }
 }
 else
 {
-uint8_t x_43; 
+uint8_t x_42; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -20067,23 +20063,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_43 = !lean_is_exclusive(x_30);
-if (x_43 == 0)
+x_42 = !lean_is_exclusive(x_30);
+if (x_42 == 0)
 {
 return x_30;
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_44 = lean_ctor_get(x_30, 0);
-x_45 = lean_ctor_get(x_30, 1);
-lean_inc(x_45);
+lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+x_43 = lean_ctor_get(x_30, 0);
+x_44 = lean_ctor_get(x_30, 1);
 lean_inc(x_44);
+lean_inc(x_43);
 lean_dec(x_30);
-x_46 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_46, 0, x_44);
-lean_ctor_set(x_46, 1, x_45);
-return x_46;
+x_45 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_45, 0, x_43);
+lean_ctor_set(x_45, 1, x_44);
+return x_45;
 }
 }
 }
@@ -20261,30 +20257,29 @@ lean_inc(x_1);
 x_30 = l_Lean_Meta_transform_visit___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__7(x_1, x_2, x_3, x_4, x_29, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
 if (lean_obj_tag(x_30) == 0)
 {
-lean_object* x_31; lean_object* x_32; uint8_t x_33; uint8_t x_34; lean_object* x_35; 
+lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; 
 x_31 = lean_ctor_get(x_30, 0);
 lean_inc(x_31);
 x_32 = lean_ctor_get(x_30, 1);
 lean_inc(x_32);
 lean_dec(x_30);
 x_33 = 0;
-x_34 = 1;
 lean_inc(x_9);
-x_35 = l_Lean_Meta_mkForallFVars(x_5, x_31, x_33, x_34, x_9, x_10, x_11, x_12, x_32);
-if (lean_obj_tag(x_35) == 0)
+x_34 = l_Lean_Meta_mkForallFVars(x_5, x_31, x_33, x_33, x_9, x_10, x_11, x_12, x_32);
+if (lean_obj_tag(x_34) == 0)
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_36 = lean_ctor_get(x_35, 0);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_35 = lean_ctor_get(x_34, 0);
+lean_inc(x_35);
+x_36 = lean_ctor_get(x_34, 1);
 lean_inc(x_36);
-x_37 = lean_ctor_get(x_35, 1);
-lean_inc(x_37);
-lean_dec(x_35);
-x_38 = l_Lean_Meta_transform_visit_visitPost___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__8(x_1, x_2, x_3, x_4, x_36, x_7, x_8, x_9, x_10, x_11, x_12, x_37);
-return x_38;
+lean_dec(x_34);
+x_37 = l_Lean_Meta_transform_visit_visitPost___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__8(x_1, x_2, x_3, x_4, x_35, x_7, x_8, x_9, x_10, x_11, x_12, x_36);
+return x_37;
 }
 else
 {
-uint8_t x_39; 
+uint8_t x_38; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -20295,29 +20290,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_39 = !lean_is_exclusive(x_35);
-if (x_39 == 0)
+x_38 = !lean_is_exclusive(x_34);
+if (x_38 == 0)
 {
-return x_35;
+return x_34;
 }
 else
 {
-lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_40 = lean_ctor_get(x_35, 0);
-x_41 = lean_ctor_get(x_35, 1);
-lean_inc(x_41);
+lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_39 = lean_ctor_get(x_34, 0);
+x_40 = lean_ctor_get(x_34, 1);
 lean_inc(x_40);
-lean_dec(x_35);
-x_42 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_42, 0, x_40);
-lean_ctor_set(x_42, 1, x_41);
-return x_42;
+lean_inc(x_39);
+lean_dec(x_34);
+x_41 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_41, 0, x_39);
+lean_ctor_set(x_41, 1, x_40);
+return x_41;
 }
 }
 }
 else
 {
-uint8_t x_43; 
+uint8_t x_42; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -20329,23 +20324,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_43 = !lean_is_exclusive(x_30);
-if (x_43 == 0)
+x_42 = !lean_is_exclusive(x_30);
+if (x_42 == 0)
 {
 return x_30;
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; 
-x_44 = lean_ctor_get(x_30, 0);
-x_45 = lean_ctor_get(x_30, 1);
-lean_inc(x_45);
+lean_object* x_43; lean_object* x_44; lean_object* x_45; 
+x_43 = lean_ctor_get(x_30, 0);
+x_44 = lean_ctor_get(x_30, 1);
 lean_inc(x_44);
+lean_inc(x_43);
 lean_dec(x_30);
-x_46 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_46, 0, x_44);
-lean_ctor_set(x_46, 1, x_45);
-return x_46;
+x_45 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_45, 0, x_43);
+lean_ctor_set(x_45, 1, x_44);
+return x_45;
 }
 }
 }
@@ -20582,30 +20577,29 @@ lean_inc(x_1);
 x_37 = l_Lean_Meta_transform_visit___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__7(x_1, x_2, x_3, x_4, x_36, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
 if (lean_obj_tag(x_37) == 0)
 {
-lean_object* x_38; lean_object* x_39; uint8_t x_40; uint8_t x_41; lean_object* x_42; 
+lean_object* x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; 
 x_38 = lean_ctor_get(x_37, 0);
 lean_inc(x_38);
 x_39 = lean_ctor_get(x_37, 1);
 lean_inc(x_39);
 lean_dec(x_37);
 x_40 = 0;
-x_41 = 1;
 lean_inc(x_9);
-x_42 = l_Lean_Meta_mkLambdaFVars(x_5, x_38, x_40, x_41, x_9, x_10, x_11, x_12, x_39);
-if (lean_obj_tag(x_42) == 0)
+x_41 = l_Lean_Meta_mkLambdaFVars(x_5, x_38, x_40, x_40, x_9, x_10, x_11, x_12, x_39);
+if (lean_obj_tag(x_41) == 0)
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_42, 0);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_42 = lean_ctor_get(x_41, 0);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_41, 1);
 lean_inc(x_43);
-x_44 = lean_ctor_get(x_42, 1);
-lean_inc(x_44);
-lean_dec(x_42);
-x_45 = l_Lean_Meta_transform_visit_visitPost___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__8(x_1, x_2, x_3, x_4, x_43, x_7, x_8, x_9, x_10, x_11, x_12, x_44);
-return x_45;
+lean_dec(x_41);
+x_44 = l_Lean_Meta_transform_visit_visitPost___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__8(x_1, x_2, x_3, x_4, x_42, x_7, x_8, x_9, x_10, x_11, x_12, x_43);
+return x_44;
 }
 else
 {
-uint8_t x_46; 
+uint8_t x_45; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -20616,29 +20610,29 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_46 = !lean_is_exclusive(x_42);
-if (x_46 == 0)
+x_45 = !lean_is_exclusive(x_41);
+if (x_45 == 0)
 {
-return x_42;
+return x_41;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_47 = lean_ctor_get(x_42, 0);
-x_48 = lean_ctor_get(x_42, 1);
-lean_inc(x_48);
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+x_46 = lean_ctor_get(x_41, 0);
+x_47 = lean_ctor_get(x_41, 1);
 lean_inc(x_47);
-lean_dec(x_42);
-x_49 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_49, 0, x_47);
-lean_ctor_set(x_49, 1, x_48);
-return x_49;
+lean_inc(x_46);
+lean_dec(x_41);
+x_48 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_48, 0, x_46);
+lean_ctor_set(x_48, 1, x_47);
+return x_48;
 }
 }
 }
 else
 {
-uint8_t x_50; 
+uint8_t x_49; 
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
@@ -20650,23 +20644,23 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_50 = !lean_is_exclusive(x_37);
-if (x_50 == 0)
+x_49 = !lean_is_exclusive(x_37);
+if (x_49 == 0)
 {
 return x_37;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-x_51 = lean_ctor_get(x_37, 0);
-x_52 = lean_ctor_get(x_37, 1);
-lean_inc(x_52);
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+x_50 = lean_ctor_get(x_37, 0);
+x_51 = lean_ctor_get(x_37, 1);
 lean_inc(x_51);
+lean_inc(x_50);
 lean_dec(x_37);
-x_53 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_53, 0, x_51);
-lean_ctor_set(x_53, 1, x_52);
-return x_53;
+x_52 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_52, 0, x_50);
+lean_ctor_set(x_52, 1, x_51);
+return x_52;
 }
 }
 }

stage0/stdlib/Lean/Meta/SynthInstance.c

@@ -408,7 +408,7 @@ lean_object* l_Lean_mkApp(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Meta_synthInstance_x3f___spec__8___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_SynthInstance_newSubgoal___closed__2;
 uint8_t l_Lean_Expr_hasMVar(lean_object*);
-lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*, uint8_t);
 LEAN_EXPORT lean_object* l_Std_PersistentHashMap_insertAtCollisionNodeAux___at_Lean_Meta_synthInstance_x3f___spec__7(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Meta_SynthInstance_0__Lean_Meta_synthPendingImp___lambda__2___closed__3;
 lean_object* l_Std_PersistentArray_toArray___rarg(lean_object*);
@@ -11467,123 +11467,124 @@ return x_9;
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_SynthInstance_consume___spec__1___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
 _start:
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; 
 x_12 = l_Lean_Meta_SynthInstance_newSubgoal___lambda__3___closed__1;
 x_13 = lean_array_push(x_12, x_4);
-x_14 = l_Lean_Expr_betaRev(x_1, x_13);
+x_14 = 0;
+x_15 = l_Lean_Expr_betaRev(x_1, x_13, x_14);
 lean_dec(x_13);
-lean_inc(x_14);
-x_15 = lean_infer_type(x_14, x_7, x_8, x_9, x_10, x_11);
-if (lean_obj_tag(x_15) == 0)
-{
-uint8_t x_16; 
-x_16 = !lean_is_exclusive(x_15);
-if (x_16 == 0)
+lean_inc(x_15);
+x_16 = lean_infer_type(x_15, x_7, x_8, x_9, x_10, x_11);
+if (lean_obj_tag(x_16) == 0)
 {
 uint8_t x_17; 
-x_17 = !lean_is_exclusive(x_2);
+x_17 = !lean_is_exclusive(x_16);
 if (x_17 == 0)
 {
-lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_18 = lean_ctor_get(x_15, 0);
-x_19 = lean_ctor_get(x_2, 2);
-lean_dec(x_19);
-lean_ctor_set(x_2, 2, x_14);
-x_20 = lean_ctor_get(x_3, 2);
-lean_inc(x_20);
-x_21 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_21, 0, x_2);
-lean_ctor_set(x_21, 1, x_18);
-lean_ctor_set(x_21, 2, x_20);
-lean_ctor_set(x_15, 0, x_21);
-return x_15;
+uint8_t x_18; 
+x_18 = !lean_is_exclusive(x_2);
+if (x_18 == 0)
+{
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_19 = lean_ctor_get(x_16, 0);
+x_20 = lean_ctor_get(x_2, 2);
+lean_dec(x_20);
+lean_ctor_set(x_2, 2, x_15);
+x_21 = lean_ctor_get(x_3, 2);
+lean_inc(x_21);
+x_22 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_22, 0, x_2);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set(x_22, 2, x_21);
+lean_ctor_set(x_16, 0, x_22);
+return x_16;
 }
 else
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_22 = lean_ctor_get(x_15, 0);
-x_23 = lean_ctor_get(x_2, 0);
-x_24 = lean_ctor_get(x_2, 1);
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+x_23 = lean_ctor_get(x_16, 0);
+x_24 = lean_ctor_get(x_2, 0);
+x_25 = lean_ctor_get(x_2, 1);
+lean_inc(x_25);
 lean_inc(x_24);
-lean_inc(x_23);
 lean_dec(x_2);
-x_25 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_25, 0, x_23);
-lean_ctor_set(x_25, 1, x_24);
-lean_ctor_set(x_25, 2, x_14);
-x_26 = lean_ctor_get(x_3, 2);
-lean_inc(x_26);
-x_27 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_27, 0, x_25);
-lean_ctor_set(x_27, 1, x_22);
-lean_ctor_set(x_27, 2, x_26);
-lean_ctor_set(x_15, 0, x_27);
-return x_15;
+x_26 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_26, 0, x_24);
+lean_ctor_set(x_26, 1, x_25);
+lean_ctor_set(x_26, 2, x_15);
+x_27 = lean_ctor_get(x_3, 2);
+lean_inc(x_27);
+x_28 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_28, 0, x_26);
+lean_ctor_set(x_28, 1, x_23);
+lean_ctor_set(x_28, 2, x_27);
+lean_ctor_set(x_16, 0, x_28);
+return x_16;
 }
 }
 else
 {
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
-x_28 = lean_ctor_get(x_15, 0);
-x_29 = lean_ctor_get(x_15, 1);
-lean_inc(x_29);
-lean_inc(x_28);
-lean_dec(x_15);
-x_30 = lean_ctor_get(x_2, 0);
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_29 = lean_ctor_get(x_16, 0);
+x_30 = lean_ctor_get(x_16, 1);
 lean_inc(x_30);
-x_31 = lean_ctor_get(x_2, 1);
+lean_inc(x_29);
+lean_dec(x_16);
+x_31 = lean_ctor_get(x_2, 0);
 lean_inc(x_31);
+x_32 = lean_ctor_get(x_2, 1);
+lean_inc(x_32);
 if (lean_is_exclusive(x_2)) {
  lean_ctor_release(x_2, 0);
  lean_ctor_release(x_2, 1);
  lean_ctor_release(x_2, 2);
- x_32 = x_2;
+ x_33 = x_2;
 } else {
  lean_dec_ref(x_2);
- x_32 = lean_box(0);
+ x_33 = lean_box(0);
 }
-if (lean_is_scalar(x_32)) {
- x_33 = lean_alloc_ctor(0, 3, 0);
+if (lean_is_scalar(x_33)) {
+ x_34 = lean_alloc_ctor(0, 3, 0);
 } else {
- x_33 = x_32;
+ x_34 = x_33;
 }
-lean_ctor_set(x_33, 0, x_30);
-lean_ctor_set(x_33, 1, x_31);
-lean_ctor_set(x_33, 2, x_14);
-x_34 = lean_ctor_get(x_3, 2);
-lean_inc(x_34);
-x_35 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_35, 0, x_33);
-lean_ctor_set(x_35, 1, x_28);
-lean_ctor_set(x_35, 2, x_34);
-x_36 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_36, 0, x_35);
+lean_ctor_set(x_34, 0, x_31);
+lean_ctor_set(x_34, 1, x_32);
+lean_ctor_set(x_34, 2, x_15);
+x_35 = lean_ctor_get(x_3, 2);
+lean_inc(x_35);
+x_36 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_36, 0, x_34);
 lean_ctor_set(x_36, 1, x_29);
-return x_36;
+lean_ctor_set(x_36, 2, x_35);
+x_37 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_37, 0, x_36);
+lean_ctor_set(x_37, 1, x_30);
+return x_37;
 }
 }
 else
 {
-uint8_t x_37; 
-lean_dec(x_14);
-lean_dec(x_2);
-x_37 = !lean_is_exclusive(x_15);
-if (x_37 == 0)
-{
-return x_15;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-x_38 = lean_ctor_get(x_15, 0);
-x_39 = lean_ctor_get(x_15, 1);
-lean_inc(x_39);
-lean_inc(x_38);
+uint8_t x_38; 
 lean_dec(x_15);
-x_40 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_40, 0, x_38);
-lean_ctor_set(x_40, 1, x_39);
-return x_40;
+lean_dec(x_2);
+x_38 = !lean_is_exclusive(x_16);
+if (x_38 == 0)
+{
+return x_16;
+}
+else
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_39 = lean_ctor_get(x_16, 0);
+x_40 = lean_ctor_get(x_16, 1);
+lean_inc(x_40);
+lean_inc(x_39);
+lean_dec(x_16);
+x_41 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_41, 0, x_39);
+lean_ctor_set(x_41, 1, x_40);
+return x_41;
 }
 }
 }
@@ -13389,7 +13390,6 @@ x_12 = l_Array_mapMUnsafe_map___at_Lean_Meta_SynthInstance_consume___spec__1___l
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_3);
-lean_dec(x_1);
 return x_12;
 }
 }

stage0/stdlib/Lean/Meta/Tactic/Contradiction.c

@@ -17,6 +17,7 @@ LEAN_EXPORT lean_object* l_Lean_addTrace___at_Lean_Meta_ElimEmptyInductive_elim_
 static lean_object* l_Lean_Meta_contradiction___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Meta_ElimEmptyInductive_elim___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_add(size_t, size_t);
+static lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__4;
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
@@ -55,6 +56,7 @@ static lean_object* l_Lean_Meta_ElimEmptyInductive_elim___closed__2;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__3___closed__8;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_ElimEmptyInductive_elim___spec__1(lean_object*, 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_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___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*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_appArg_x21(lean_object*);
 static lean_object* l_Lean_Meta_contradictionCore___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Meta_ElimEmptyInductive_elim___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_commitWhen___at_Lean_Meta_ElimEmptyInductive_elim___spec__7___at_Lean_Meta_ElimEmptyInductive_elim___spec__8___lambda__1___closed__1;
@@ -75,6 +77,7 @@ static lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_proc
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_ElimEmptyInductive_elim___spec__4___closed__2;
 uint8_t lean_expr_has_loose_bvar(lean_object*, lean_object*);
 lean_object* l_Lean_mkAppN(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_FindImpl_findUnsafe_x3f(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_ElimEmptyInductive_elim___spec__4(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_StateRefT_x27_lift___rarg___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(lean_object*, lean_object*, lean_object*);
@@ -115,6 +118,7 @@ LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCo
 static lean_object* l_Lean_Meta_ElimEmptyInductive_elim___lambda__3___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Meta_ElimEmptyInductive_elim___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_commitWhen___at_Lean_Meta_ElimEmptyInductive_elim___spec__7___at_Lean_Meta_ElimEmptyInductive_elim___spec__8___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Contradiction_Config_searchFuel___default;
 LEAN_EXPORT lean_object* l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at_Lean_Meta_ElimEmptyInductive_elim___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
@@ -127,6 +131,7 @@ LEAN_EXPORT lean_object* l_Std_PersistentArray_forInAux___at_Lean_Meta_contradic
 lean_object* l_Lean_Meta_findLocalDeclWithType_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_commitWhen___at_Lean_Meta_ElimEmptyInductive_elim___spec__7___at_Lean_Meta_ElimEmptyInductive_elim___spec__8___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_ElimEmptyInductive_elim___spec__4___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Expr_isAppOfArity(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__2(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_contradiction(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -134,7 +139,9 @@ lean_object* l_Lean_LocalDecl_toExpr(lean_object*);
 uint8_t l_Lean_Expr_isConstOf(lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_contradictionCore___lambda__2___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Meta_contradictionCore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Meta_contradictionCore___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___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___closed__2;
+LEAN_EXPORT lean_object* l_Lean_Meta_contradictionCore___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_instMonadMetaM;
 LEAN_EXPORT lean_object* l_Lean_Meta_withMVarContext___at_Lean_Meta_ElimEmptyInductive_elim___spec__3(lean_object*);
 lean_object* lean_whnf(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -142,13 +149,17 @@ lean_object* l_Lean_mkFVar(lean_object*);
 lean_object* l_Lean_Meta_SavedState_restore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__3___closed__3;
 size_t lean_usize_of_nat(lean_object*);
+LEAN_EXPORT uint8_t l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_ElimEmptyInductive_instMonadBacktrackSavedStateM___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_ReaderT_bind___at_Lean_Meta_ElimEmptyInductive_elim___spec__2(lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l_Lean_Meta_Contradiction_Config_useDecide___default;
 lean_object* l_Lean_Meta_withMVarContext___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_synthPendingImp___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___boxed(lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__5(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_LocalDecl_fvarId(lean_object*);
+static lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__1;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withMVarContextImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__2;
 lean_object* l_Lean_Meta_matchEq_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LocalDecl_type(lean_object*);
@@ -166,10 +177,8 @@ lean_object* l_Lean_Meta_hasAssignableMVar(lean_object*, lean_object*, lean_obje
 lean_object* l_Lean_Expr_getAppNumArgsAux(lean_object*, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__3___closed__7;
 lean_object* l_Lean_Meta_matchConstructorApp_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__2;
 lean_object* l_Lean_Meta_checkNotAssigned(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getLocalDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__1;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__3___closed__5;
 static lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___closed__1;
 static lean_object* l_Lean_Meta_ElimEmptyInductive_elim___lambda__2___closed__2;
@@ -207,7 +216,8 @@ lean_object* l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_Instances_0__
 lean_object* l_Lean_Meta_mkFalseElim(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_panic_fn(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkNoConfusion(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Contradiction___hyg_3251_(lean_object*);
+uint8_t l_Lean_Expr_hasLooseBVars(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Contradiction___hyg_3415_(lean_object*);
 lean_object* l_Lean_Meta_instantiateMVars(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_array(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at_Lean_Meta_ElimEmptyInductive_elim___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -225,6 +235,7 @@ static lean_object* l_Lean_commitWhen___at_Lean_Meta_ElimEmptyInductive_elim___s
 static lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___spec__2___lambda__1___closed__1;
 lean_object* l_Lean_Expr_getAppFn(lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__3___closed__6;
+static lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__3;
 LEAN_EXPORT lean_object* l_Std_PersistentArray_forInAux___at_Lean_Meta_contradictionCore___spec__2___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_addTrace___at_Lean_Meta_ElimEmptyInductive_elim___spec__5___closed__7;
 uint8_t l_Lean_Expr_hasFVar(lean_object*);
@@ -236,6 +247,7 @@ LEAN_EXPORT lean_object* l_Std_PersistentArray_forIn___at_Lean_Meta_contradictio
 lean_object* l_instMonadControlT__1___rarg(lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Meta_contradictionCore___spec__4___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instInhabitedMetaM___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___closed__1;
 lean_object* l_Lean_Exception_toMessageData(lean_object*);
 LEAN_EXPORT lean_object* l_ReaderT_bind___at_Lean_Meta_ElimEmptyInductive_elim___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_contradictionCore___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -265,6 +277,418 @@ x_1 = 0;
 return x_1;
 }
 }
+static lean_object* _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("False");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__1;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__3() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("elim");
+return x_1;
+}
+}
+static lean_object* _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__2;
+x_2 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__3;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
+}
+}
+LEAN_EXPORT uint8_t l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; uint8_t x_4; 
+x_2 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__4;
+x_3 = lean_unsigned_to_nat(2u);
+x_4 = l_Lean_Expr_isAppOfArity(x_1, x_2, x_3);
+if (x_4 == 0)
+{
+uint8_t x_5; 
+x_5 = 0;
+return x_5;
+}
+else
+{
+lean_object* x_6; uint8_t x_7; 
+x_6 = l_Lean_Expr_appArg_x21(x_1);
+x_7 = l_Lean_Expr_hasLooseBVars(x_6);
+lean_dec(x_6);
+if (x_7 == 0)
+{
+uint8_t x_8; 
+x_8 = 1;
+return x_8;
+}
+else
+{
+uint8_t x_9; 
+x_9 = 0;
+return x_9;
+}
+}
+}
+}
+static lean_object* _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___boxed), 1, 0);
+return x_1;
+}
+}
+LEAN_EXPORT lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; 
+lean_inc(x_1);
+x_7 = l_Lean_Meta_getMVarType(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_7) == 0)
+{
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_7);
+if (x_8 == 0)
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_9 = lean_ctor_get(x_7, 0);
+x_10 = lean_ctor_get(x_7, 1);
+x_11 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___closed__1;
+x_12 = l_Lean_Expr_FindImpl_findUnsafe_x3f(x_11, x_9);
+if (lean_obj_tag(x_12) == 0)
+{
+uint8_t x_13; lean_object* x_14; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_13 = 0;
+x_14 = lean_box(x_13);
+lean_ctor_set(x_7, 0, x_14);
+return x_7;
+}
+else
+{
+lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_free_object(x_7);
+x_15 = lean_ctor_get(x_12, 0);
+lean_inc(x_15);
+lean_dec(x_12);
+x_16 = l_Lean_Expr_appArg_x21(x_15);
+lean_dec(x_15);
+lean_inc(x_1);
+x_17 = l_Lean_Meta_getMVarType(x_1, x_2, x_3, x_4, x_5, x_10);
+if (lean_obj_tag(x_17) == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_17, 0);
+lean_inc(x_18);
+x_19 = lean_ctor_get(x_17, 1);
+lean_inc(x_19);
+lean_dec(x_17);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_2);
+x_20 = l_Lean_Meta_mkFalseElim(x_18, x_16, x_2, x_3, x_4, x_5, x_19);
+if (lean_obj_tag(x_20) == 0)
+{
+lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+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_Lean_Meta_assignExprMVar(x_1, x_21, x_2, x_3, x_4, x_5, x_22);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_24 = !lean_is_exclusive(x_23);
+if (x_24 == 0)
+{
+lean_object* x_25; uint8_t x_26; lean_object* x_27; 
+x_25 = lean_ctor_get(x_23, 0);
+lean_dec(x_25);
+x_26 = 1;
+x_27 = lean_box(x_26);
+lean_ctor_set(x_23, 0, x_27);
+return x_23;
+}
+else
+{
+lean_object* x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; 
+x_28 = lean_ctor_get(x_23, 1);
+lean_inc(x_28);
+lean_dec(x_23);
+x_29 = 1;
+x_30 = lean_box(x_29);
+x_31 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_31, 0, x_30);
+lean_ctor_set(x_31, 1, x_28);
+return x_31;
+}
+}
+else
+{
+uint8_t x_32; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_32 = !lean_is_exclusive(x_20);
+if (x_32 == 0)
+{
+return x_20;
+}
+else
+{
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_33 = lean_ctor_get(x_20, 0);
+x_34 = lean_ctor_get(x_20, 1);
+lean_inc(x_34);
+lean_inc(x_33);
+lean_dec(x_20);
+x_35 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_35, 0, x_33);
+lean_ctor_set(x_35, 1, x_34);
+return x_35;
+}
+}
+}
+else
+{
+uint8_t x_36; 
+lean_dec(x_16);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_36 = !lean_is_exclusive(x_17);
+if (x_36 == 0)
+{
+return x_17;
+}
+else
+{
+lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_37 = lean_ctor_get(x_17, 0);
+x_38 = lean_ctor_get(x_17, 1);
+lean_inc(x_38);
+lean_inc(x_37);
+lean_dec(x_17);
+x_39 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_39, 0, x_37);
+lean_ctor_set(x_39, 1, x_38);
+return x_39;
+}
+}
+}
+}
+else
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
+x_40 = lean_ctor_get(x_7, 0);
+x_41 = lean_ctor_get(x_7, 1);
+lean_inc(x_41);
+lean_inc(x_40);
+lean_dec(x_7);
+x_42 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___closed__1;
+x_43 = l_Lean_Expr_FindImpl_findUnsafe_x3f(x_42, x_40);
+if (lean_obj_tag(x_43) == 0)
+{
+uint8_t x_44; lean_object* x_45; lean_object* x_46; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_44 = 0;
+x_45 = lean_box(x_44);
+x_46 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_46, 0, x_45);
+lean_ctor_set(x_46, 1, x_41);
+return x_46;
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+x_47 = lean_ctor_get(x_43, 0);
+lean_inc(x_47);
+lean_dec(x_43);
+x_48 = l_Lean_Expr_appArg_x21(x_47);
+lean_dec(x_47);
+lean_inc(x_1);
+x_49 = l_Lean_Meta_getMVarType(x_1, x_2, x_3, x_4, x_5, x_41);
+if (lean_obj_tag(x_49) == 0)
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; 
+x_50 = lean_ctor_get(x_49, 0);
+lean_inc(x_50);
+x_51 = lean_ctor_get(x_49, 1);
+lean_inc(x_51);
+lean_dec(x_49);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_2);
+x_52 = l_Lean_Meta_mkFalseElim(x_50, x_48, x_2, x_3, x_4, x_5, x_51);
+if (lean_obj_tag(x_52) == 0)
+{
+lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; lean_object* x_60; 
+x_53 = lean_ctor_get(x_52, 0);
+lean_inc(x_53);
+x_54 = lean_ctor_get(x_52, 1);
+lean_inc(x_54);
+lean_dec(x_52);
+x_55 = l_Lean_Meta_assignExprMVar(x_1, x_53, x_2, x_3, x_4, x_5, x_54);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_56 = lean_ctor_get(x_55, 1);
+lean_inc(x_56);
+if (lean_is_exclusive(x_55)) {
+ lean_ctor_release(x_55, 0);
+ lean_ctor_release(x_55, 1);
+ x_57 = x_55;
+} else {
+ lean_dec_ref(x_55);
+ x_57 = lean_box(0);
+}
+x_58 = 1;
+x_59 = lean_box(x_58);
+if (lean_is_scalar(x_57)) {
+ x_60 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_60 = x_57;
+}
+lean_ctor_set(x_60, 0, x_59);
+lean_ctor_set(x_60, 1, x_56);
+return x_60;
+}
+else
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_61 = lean_ctor_get(x_52, 0);
+lean_inc(x_61);
+x_62 = lean_ctor_get(x_52, 1);
+lean_inc(x_62);
+if (lean_is_exclusive(x_52)) {
+ lean_ctor_release(x_52, 0);
+ lean_ctor_release(x_52, 1);
+ x_63 = x_52;
+} else {
+ lean_dec_ref(x_52);
+ x_63 = lean_box(0);
+}
+if (lean_is_scalar(x_63)) {
+ x_64 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_64 = x_63;
+}
+lean_ctor_set(x_64, 0, x_61);
+lean_ctor_set(x_64, 1, x_62);
+return x_64;
+}
+}
+else
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+lean_dec(x_48);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_65 = lean_ctor_get(x_49, 0);
+lean_inc(x_65);
+x_66 = lean_ctor_get(x_49, 1);
+lean_inc(x_66);
+if (lean_is_exclusive(x_49)) {
+ lean_ctor_release(x_49, 0);
+ lean_ctor_release(x_49, 1);
+ x_67 = x_49;
+} else {
+ lean_dec_ref(x_49);
+ x_67 = lean_box(0);
+}
+if (lean_is_scalar(x_67)) {
+ x_68 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_68 = x_67;
+}
+lean_ctor_set(x_68, 0, x_65);
+lean_ctor_set(x_68, 1, x_66);
+return x_68;
+}
+}
+}
+}
+else
+{
+uint8_t x_69; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_69 = !lean_is_exclusive(x_7);
+if (x_69 == 0)
+{
+return x_7;
+}
+else
+{
+lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_70 = lean_ctor_get(x_7, 0);
+x_71 = lean_ctor_get(x_7, 1);
+lean_inc(x_71);
+lean_inc(x_70);
+lean_dec(x_7);
+x_72 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_72, 0, x_70);
+lean_ctor_set(x_72, 1, x_71);
+return x_72;
+}
+}
+}
+}
+LEAN_EXPORT lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___boxed(lean_object* x_1) {
+_start:
+{
+uint8_t x_2; lean_object* x_3; 
+x_2 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1(x_1);
+lean_dec(x_1);
+x_3 = lean_box(x_2);
+return x_3;
+}
+}
 LEAN_EXPORT lean_object* l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isElimEmptyInductiveCandidate(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
@@ -3105,24 +3529,6 @@ x_10 = l_Lean_Meta_withMVarContext___at___private_Lean_Meta_SynthInstance_0__Lea
 return x_10;
 }
 }
-static lean_object* _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("False");
-return x_1;
-}
-}
-static lean_object* _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__2() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__1;
-x_3 = lean_name_mk_string(x_1, x_2);
-return x_3;
-}
-}
 LEAN_EXPORT uint8_t l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq(lean_object* x_1) {
 _start:
 {
@@ -3158,7 +3564,7 @@ goto _start;
 else
 {
 lean_object* x_10; uint8_t x_11; 
-x_10 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__2;
+x_10 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__2;
 x_11 = l_Lean_Expr_isConstOf(x_1, x_10);
 return x_11;
 }
@@ -3996,7 +4402,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___closed__4;
 x_2 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___closed__5;
-x_3 = lean_unsigned_to_nat(86u);
+x_3 = lean_unsigned_to_nat(99u);
 x_4 = lean_unsigned_to_nat(2u);
 x_5 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -7375,111 +7781,139 @@ return x_1;
 LEAN_EXPORT lean_object* l_Lean_Meta_contradictionCore___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
 _start:
 {
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_10 = lean_ctor_get(x_5, 1);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_10, 1);
+lean_inc(x_11);
+lean_dec(x_10);
+x_12 = l_Lean_Meta_ElimEmptyInductive_elim___lambda__2___closed__1;
+lean_inc(x_8);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+x_13 = l_Std_PersistentArray_forIn___at_Lean_Meta_contradictionCore___spec__1(x_1, x_2, x_3, x_12, x_11, x_12, x_5, x_6, x_7, x_8, x_9);
+if (lean_obj_tag(x_13) == 0)
+{
+lean_object* x_14; lean_object* x_15; 
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+x_15 = lean_ctor_get(x_14, 0);
+lean_inc(x_15);
+lean_dec(x_14);
+if (lean_obj_tag(x_15) == 0)
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+x_16 = lean_ctor_get(x_13, 1);
+lean_inc(x_16);
+lean_dec(x_13);
+x_17 = l_Lean_Meta_contradictionCore___lambda__2___closed__1;
+x_18 = lean_box(0);
+x_19 = lean_apply_6(x_17, x_18, x_5, x_6, x_7, x_8, x_16);
+return x_19;
+}
+else
+{
+uint8_t x_20; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_20 = !lean_is_exclusive(x_13);
+if (x_20 == 0)
+{
+lean_object* x_21; lean_object* x_22; 
+x_21 = lean_ctor_get(x_13, 0);
+lean_dec(x_21);
+x_22 = lean_ctor_get(x_15, 0);
+lean_inc(x_22);
+lean_dec(x_15);
+lean_ctor_set(x_13, 0, x_22);
+return x_13;
+}
+else
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_23 = lean_ctor_get(x_13, 1);
+lean_inc(x_23);
+lean_dec(x_13);
+x_24 = lean_ctor_get(x_15, 0);
+lean_inc(x_24);
+lean_dec(x_15);
+x_25 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_25, 0, x_24);
+lean_ctor_set(x_25, 1, x_23);
+return x_25;
+}
+}
+}
+else
+{
+uint8_t x_26; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_26 = !lean_is_exclusive(x_13);
+if (x_26 == 0)
+{
+return x_13;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_27 = lean_ctor_get(x_13, 0);
+x_28 = lean_ctor_get(x_13, 1);
+lean_inc(x_28);
+lean_inc(x_27);
+lean_dec(x_13);
+x_29 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_29, 0, x_27);
+lean_ctor_set(x_29, 1, x_28);
+return x_29;
+}
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Meta_contradictionCore___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
 lean_object* x_10; 
 lean_inc(x_6);
 lean_inc(x_1);
 x_10 = l_Lean_Meta_checkNotAssigned(x_1, x_2, x_5, x_6, x_7, x_8, x_9);
 if (lean_obj_tag(x_10) == 0)
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_object* x_11; lean_object* x_12; 
 x_11 = lean_ctor_get(x_10, 1);
 lean_inc(x_11);
 lean_dec(x_10);
-x_12 = lean_ctor_get(x_5, 1);
-lean_inc(x_12);
-x_13 = lean_ctor_get(x_12, 1);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = l_Lean_Meta_ElimEmptyInductive_elim___lambda__2___closed__1;
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
-x_15 = l_Std_PersistentArray_forIn___at_Lean_Meta_contradictionCore___spec__1(x_1, x_3, x_4, x_14, x_13, x_14, x_5, x_6, x_7, x_8, x_11);
-if (lean_obj_tag(x_15) == 0)
+lean_inc(x_1);
+x_12 = l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim(x_1, x_5, x_6, x_7, x_8, x_11);
+if (lean_obj_tag(x_12) == 0)
 {
-lean_object* x_16; lean_object* x_17; 
-x_16 = lean_ctor_get(x_15, 0);
-lean_inc(x_16);
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-lean_dec(x_16);
-if (lean_obj_tag(x_17) == 0)
+lean_object* x_13; uint8_t x_14; 
+x_13 = lean_ctor_get(x_12, 0);
+lean_inc(x_13);
+x_14 = lean_unbox(x_13);
+lean_dec(x_13);
+if (x_14 == 0)
 {
-lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_18 = lean_ctor_get(x_15, 1);
-lean_inc(x_18);
-lean_dec(x_15);
-x_19 = l_Lean_Meta_contradictionCore___lambda__2___closed__1;
-x_20 = lean_box(0);
-x_21 = lean_apply_6(x_19, x_20, x_5, x_6, x_7, x_8, x_18);
-return x_21;
+lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+x_15 = lean_ctor_get(x_12, 1);
+lean_inc(x_15);
+lean_dec(x_12);
+x_16 = lean_box(0);
+x_17 = l_Lean_Meta_contradictionCore___lambda__2(x_1, x_3, x_4, x_16, x_5, x_6, x_7, x_8, x_15);
+return x_17;
 }
 else
 {
-uint8_t x_22; 
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-x_22 = !lean_is_exclusive(x_15);
-if (x_22 == 0)
-{
-lean_object* x_23; lean_object* x_24; 
-x_23 = lean_ctor_get(x_15, 0);
-lean_dec(x_23);
-x_24 = lean_ctor_get(x_17, 0);
-lean_inc(x_24);
-lean_dec(x_17);
-lean_ctor_set(x_15, 0, x_24);
-return x_15;
-}
-else
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_25 = lean_ctor_get(x_15, 1);
-lean_inc(x_25);
-lean_dec(x_15);
-x_26 = lean_ctor_get(x_17, 0);
-lean_inc(x_26);
-lean_dec(x_17);
-x_27 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_27, 0, x_26);
-lean_ctor_set(x_27, 1, x_25);
-return x_27;
-}
-}
-}
-else
-{
-uint8_t x_28; 
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-x_28 = !lean_is_exclusive(x_15);
-if (x_28 == 0)
-{
-return x_15;
-}
-else
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = lean_ctor_get(x_15, 0);
-x_30 = lean_ctor_get(x_15, 1);
-lean_inc(x_30);
-lean_inc(x_29);
-lean_dec(x_15);
-x_31 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_31, 0, x_29);
-lean_ctor_set(x_31, 1, x_30);
-return x_31;
-}
-}
-}
-else
-{
-uint8_t x_32; 
+uint8_t x_18; 
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -7487,23 +7921,89 @@ lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_32 = !lean_is_exclusive(x_10);
-if (x_32 == 0)
+x_18 = !lean_is_exclusive(x_12);
+if (x_18 == 0)
+{
+lean_object* x_19; uint8_t x_20; lean_object* x_21; 
+x_19 = lean_ctor_get(x_12, 0);
+lean_dec(x_19);
+x_20 = 1;
+x_21 = lean_box(x_20);
+lean_ctor_set(x_12, 0, x_21);
+return x_12;
+}
+else
+{
+lean_object* x_22; uint8_t x_23; lean_object* x_24; lean_object* x_25; 
+x_22 = lean_ctor_get(x_12, 1);
+lean_inc(x_22);
+lean_dec(x_12);
+x_23 = 1;
+x_24 = lean_box(x_23);
+x_25 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_25, 0, x_24);
+lean_ctor_set(x_25, 1, x_22);
+return x_25;
+}
+}
+}
+else
+{
+uint8_t x_26; 
+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_1);
+x_26 = !lean_is_exclusive(x_12);
+if (x_26 == 0)
+{
+return x_12;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_27 = lean_ctor_get(x_12, 0);
+x_28 = lean_ctor_get(x_12, 1);
+lean_inc(x_28);
+lean_inc(x_27);
+lean_dec(x_12);
+x_29 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_29, 0, x_27);
+lean_ctor_set(x_29, 1, x_28);
+return x_29;
+}
+}
+}
+else
+{
+uint8_t x_30; 
+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_1);
+x_30 = !lean_is_exclusive(x_10);
+if (x_30 == 0)
 {
 return x_10;
 }
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_33 = lean_ctor_get(x_10, 0);
-x_34 = lean_ctor_get(x_10, 1);
-lean_inc(x_34);
-lean_inc(x_33);
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_31 = lean_ctor_get(x_10, 0);
+x_32 = lean_ctor_get(x_10, 1);
+lean_inc(x_32);
+lean_inc(x_31);
 lean_dec(x_10);
-x_35 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_35, 0, x_33);
-lean_ctor_set(x_35, 1, x_34);
-return x_35;
+x_33 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_32);
+return x_33;
 }
 }
 }
@@ -7539,7 +8039,7 @@ lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11;
 x_8 = l_Lean_Meta_contradictionCore___closed__2;
 x_9 = l_Lean_Meta_contradictionCore___closed__1;
 lean_inc(x_1);
-x_10 = lean_alloc_closure((void*)(l_Lean_Meta_contradictionCore___lambda__2), 9, 4);
+x_10 = lean_alloc_closure((void*)(l_Lean_Meta_contradictionCore___lambda__3), 9, 4);
 lean_closure_set(x_10, 0, x_1);
 lean_closure_set(x_10, 1, x_8);
 lean_closure_set(x_10, 2, x_2);
@@ -7660,6 +8160,15 @@ lean_dec(x_1);
 return x_7;
 }
 }
+LEAN_EXPORT lean_object* l_Lean_Meta_contradictionCore___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l_Lean_Meta_contradictionCore___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+lean_dec(x_4);
+return x_10;
+}
+}
 static lean_object* _init_l_Lean_Meta_contradiction___closed__1() {
 _start:
 {
@@ -7773,7 +8282,7 @@ return x_25;
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Contradiction___hyg_3251_(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Contradiction___hyg_3415_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -7811,6 +8320,16 @@ l_Lean_Meta_Contradiction_Config_useDecide___default = _init_l_Lean_Meta_Contrad
 l_Lean_Meta_Contradiction_Config_searchFuel___default = _init_l_Lean_Meta_Contradiction_Config_searchFuel___default();
 lean_mark_persistent(l_Lean_Meta_Contradiction_Config_searchFuel___default);
 l_Lean_Meta_Contradiction_Config_genDiseq___default = _init_l_Lean_Meta_Contradiction_Config_genDiseq___default();
+l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__1 = _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__1();
+lean_mark_persistent(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__1);
+l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__2 = _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__2();
+lean_mark_persistent(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__2);
+l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__3 = _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__3();
+lean_mark_persistent(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__3);
+l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__4 = _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__4();
+lean_mark_persistent(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___lambda__1___closed__4);
+l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___closed__1 = _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___closed__1();
+lean_mark_persistent(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_nestedFalseElim___closed__1);
 l_Lean_Meta_ElimEmptyInductive_instMonadBacktrackSavedStateM___closed__1 = _init_l_Lean_Meta_ElimEmptyInductive_instMonadBacktrackSavedStateM___closed__1();
 lean_mark_persistent(l_Lean_Meta_ElimEmptyInductive_instMonadBacktrackSavedStateM___closed__1);
 l_Lean_Meta_ElimEmptyInductive_instMonadBacktrackSavedStateM___closed__2 = _init_l_Lean_Meta_ElimEmptyInductive_instMonadBacktrackSavedStateM___closed__2();
@@ -7891,10 +8410,6 @@ l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_elimEmptyInductive___lam
 lean_mark_persistent(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_elimEmptyInductive___lambda__1___closed__2);
 l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_elimEmptyInductive___lambda__1___closed__3 = _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_elimEmptyInductive___lambda__1___closed__3();
 lean_mark_persistent(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_elimEmptyInductive___lambda__1___closed__3);
-l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__1 = _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__1();
-lean_mark_persistent(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__1);
-l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__2 = _init_l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__2();
-lean_mark_persistent(l___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_isGenDiseq___closed__2);
 l_panic___at___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___spec__1___closed__1 = _init_l_panic___at___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___spec__1___closed__1();
 lean_mark_persistent(l_panic___at___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___spec__1___closed__1);
 l_Array_forInUnsafe_loop___at___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___spec__2___lambda__1___closed__1 = _init_l_Array_forInUnsafe_loop___at___private_Lean_Meta_Tactic_Contradiction_0__Lean_Meta_processGenDiseq___spec__2___lambda__1___closed__1();
@@ -7941,7 +8456,7 @@ l_Lean_Meta_contradiction___closed__1 = _init_l_Lean_Meta_contradiction___closed
 lean_mark_persistent(l_Lean_Meta_contradiction___closed__1);
 l_Lean_Meta_contradiction___closed__2 = _init_l_Lean_Meta_contradiction___closed__2();
 lean_mark_persistent(l_Lean_Meta_contradiction___closed__2);
-res = l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Contradiction___hyg_3251_(lean_io_mk_world());
+res = l_Lean_Meta_initFn____x40_Lean_Meta_Tactic_Contradiction___hyg_3415_(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/Meta/Tactic/Delta.c

@@ -39,7 +39,7 @@ lean_object* l_Lean_Meta_checkNotAssigned(lean_object*, lean_object*, lean_objec
 lean_object* l_Lean_Meta_getLocalDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_deltaTarget___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_delta_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*, uint8_t);
 LEAN_EXPORT lean_object* l_Lean_Meta_deltaExpand(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_change(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_deltaExpand___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -143,7 +143,7 @@ return x_9;
 }
 else
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; 
 x_29 = lean_instantiate_value_lparams(x_16, x_8);
 lean_dec(x_8);
 lean_dec(x_16);
@@ -151,10 +151,10 @@ x_30 = l_Lean_Expr_getAppNumArgsAux(x_1, x_24);
 x_31 = lean_mk_empty_array_with_capacity(x_30);
 lean_dec(x_30);
 x_32 = l___private_Lean_Expr_0__Lean_Expr_getAppRevArgsAux(x_1, x_31);
-x_33 = l_Lean_Expr_betaRev(x_29, x_32);
+x_33 = 1;
+x_34 = l_Lean_Expr_betaRev(x_29, x_32, x_33);
 lean_dec(x_32);
-lean_dec(x_29);
-lean_ctor_set(x_13, 0, x_33);
+lean_ctor_set(x_13, 0, x_34);
 lean_ctor_set(x_9, 0, x_13);
 return x_9;
 }
@@ -163,75 +163,75 @@ return x_9;
 }
 else
 {
-lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; 
-x_34 = lean_ctor_get(x_13, 0);
-lean_inc(x_34);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; 
+x_35 = lean_ctor_get(x_13, 0);
+lean_inc(x_35);
 lean_dec(x_13);
-x_35 = l_Lean_ConstantInfo_name(x_34);
-x_36 = lean_apply_1(x_2, x_35);
-x_37 = lean_unbox(x_36);
-lean_dec(x_36);
-if (x_37 == 0)
+x_36 = l_Lean_ConstantInfo_name(x_35);
+x_37 = lean_apply_1(x_2, x_36);
+x_38 = lean_unbox(x_37);
+lean_dec(x_37);
+if (x_38 == 0)
 {
-lean_object* x_38; 
-lean_dec(x_34);
+lean_object* x_39; 
+lean_dec(x_35);
 lean_dec(x_8);
 lean_dec(x_1);
-x_38 = lean_box(0);
-lean_ctor_set(x_9, 0, x_38);
+x_39 = lean_box(0);
+lean_ctor_set(x_9, 0, x_39);
 return x_9;
 }
 else
 {
-uint8_t x_39; 
-x_39 = l_Lean_ConstantInfo_hasValue(x_34);
-if (x_39 == 0)
+uint8_t x_40; 
+x_40 = l_Lean_ConstantInfo_hasValue(x_35);
+if (x_40 == 0)
 {
-lean_object* x_40; 
-lean_dec(x_34);
+lean_object* x_41; 
+lean_dec(x_35);
 lean_dec(x_8);
 lean_dec(x_1);
-x_40 = lean_box(0);
-lean_ctor_set(x_9, 0, x_40);
+x_41 = lean_box(0);
+lean_ctor_set(x_9, 0, x_41);
 return x_9;
 }
 else
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; 
-x_41 = l_Lean_ConstantInfo_levelParams(x_34);
-x_42 = lean_unsigned_to_nat(0u);
-x_43 = l_List_lengthTRAux___rarg(x_41, x_42);
-lean_dec(x_41);
-x_44 = l_List_lengthTRAux___rarg(x_8, x_42);
-x_45 = lean_nat_dec_eq(x_43, x_44);
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint8_t x_46; 
+x_42 = l_Lean_ConstantInfo_levelParams(x_35);
+x_43 = lean_unsigned_to_nat(0u);
+x_44 = l_List_lengthTRAux___rarg(x_42, x_43);
+lean_dec(x_42);
+x_45 = l_List_lengthTRAux___rarg(x_8, x_43);
+x_46 = lean_nat_dec_eq(x_44, x_45);
+lean_dec(x_45);
 lean_dec(x_44);
-lean_dec(x_43);
-if (x_45 == 0)
+if (x_46 == 0)
 {
-lean_object* x_46; 
-lean_dec(x_34);
+lean_object* x_47; 
+lean_dec(x_35);
 lean_dec(x_8);
 lean_dec(x_1);
-x_46 = lean_box(0);
-lean_ctor_set(x_9, 0, x_46);
+x_47 = lean_box(0);
+lean_ctor_set(x_9, 0, x_47);
 return x_9;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_47 = lean_instantiate_value_lparams(x_34, x_8);
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; 
+x_48 = lean_instantiate_value_lparams(x_35, x_8);
 lean_dec(x_8);
-lean_dec(x_34);
-x_48 = l_Lean_Expr_getAppNumArgsAux(x_1, x_42);
-x_49 = lean_mk_empty_array_with_capacity(x_48);
-lean_dec(x_48);
-x_50 = l___private_Lean_Expr_0__Lean_Expr_getAppRevArgsAux(x_1, x_49);
-x_51 = l_Lean_Expr_betaRev(x_47, x_50);
-lean_dec(x_50);
-lean_dec(x_47);
-x_52 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_52, 0, x_51);
-lean_ctor_set(x_9, 0, x_52);
+lean_dec(x_35);
+x_49 = l_Lean_Expr_getAppNumArgsAux(x_1, x_43);
+x_50 = lean_mk_empty_array_with_capacity(x_49);
+lean_dec(x_49);
+x_51 = l___private_Lean_Expr_0__Lean_Expr_getAppRevArgsAux(x_1, x_50);
+x_52 = 1;
+x_53 = l_Lean_Expr_betaRev(x_48, x_51, x_52);
+lean_dec(x_51);
+x_54 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_54, 0, x_53);
+lean_ctor_set(x_9, 0, x_54);
 return x_9;
 }
 }
@@ -241,121 +241,121 @@ return x_9;
 }
 else
 {
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_53 = lean_ctor_get(x_9, 0);
-x_54 = lean_ctor_get(x_9, 1);
-lean_inc(x_54);
-lean_inc(x_53);
-lean_dec(x_9);
-x_55 = lean_ctor_get(x_53, 0);
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_55 = lean_ctor_get(x_9, 0);
+x_56 = lean_ctor_get(x_9, 1);
+lean_inc(x_56);
 lean_inc(x_55);
-lean_dec(x_53);
-x_56 = lean_environment_find(x_55, x_7);
-if (lean_obj_tag(x_56) == 0)
+lean_dec(x_9);
+x_57 = lean_ctor_get(x_55, 0);
+lean_inc(x_57);
+lean_dec(x_55);
+x_58 = lean_environment_find(x_57, x_7);
+if (lean_obj_tag(x_58) == 0)
 {
-lean_object* x_57; lean_object* x_58; 
+lean_object* x_59; lean_object* x_60; 
 lean_dec(x_8);
 lean_dec(x_2);
 lean_dec(x_1);
-x_57 = lean_box(0);
-x_58 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_58, 0, x_57);
-lean_ctor_set(x_58, 1, x_54);
-return x_58;
+x_59 = lean_box(0);
+x_60 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_60, 0, x_59);
+lean_ctor_set(x_60, 1, x_56);
+return x_60;
 }
 else
 {
-lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; 
-x_59 = lean_ctor_get(x_56, 0);
-lean_inc(x_59);
-if (lean_is_exclusive(x_56)) {
- lean_ctor_release(x_56, 0);
- x_60 = x_56;
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; 
+x_61 = lean_ctor_get(x_58, 0);
+lean_inc(x_61);
+if (lean_is_exclusive(x_58)) {
+ lean_ctor_release(x_58, 0);
+ x_62 = x_58;
 } else {
- lean_dec_ref(x_56);
- x_60 = lean_box(0);
+ lean_dec_ref(x_58);
+ x_62 = lean_box(0);
 }
-x_61 = l_Lean_ConstantInfo_name(x_59);
-x_62 = lean_apply_1(x_2, x_61);
-x_63 = lean_unbox(x_62);
+x_63 = l_Lean_ConstantInfo_name(x_61);
+x_64 = lean_apply_1(x_2, x_63);
+x_65 = lean_unbox(x_64);
+lean_dec(x_64);
+if (x_65 == 0)
+{
+lean_object* x_66; lean_object* x_67; 
 lean_dec(x_62);
-if (x_63 == 0)
-{
-lean_object* x_64; lean_object* x_65; 
-lean_dec(x_60);
-lean_dec(x_59);
+lean_dec(x_61);
 lean_dec(x_8);
 lean_dec(x_1);
-x_64 = lean_box(0);
-x_65 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_65, 0, x_64);
-lean_ctor_set(x_65, 1, x_54);
-return x_65;
+x_66 = lean_box(0);
+x_67 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_67, 0, x_66);
+lean_ctor_set(x_67, 1, x_56);
+return x_67;
 }
 else
 {
-uint8_t x_66; 
-x_66 = l_Lean_ConstantInfo_hasValue(x_59);
-if (x_66 == 0)
+uint8_t x_68; 
+x_68 = l_Lean_ConstantInfo_hasValue(x_61);
+if (x_68 == 0)
 {
-lean_object* x_67; lean_object* x_68; 
-lean_dec(x_60);
-lean_dec(x_59);
+lean_object* x_69; lean_object* x_70; 
+lean_dec(x_62);
+lean_dec(x_61);
 lean_dec(x_8);
 lean_dec(x_1);
-x_67 = lean_box(0);
-x_68 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_68, 0, x_67);
-lean_ctor_set(x_68, 1, x_54);
-return x_68;
+x_69 = lean_box(0);
+x_70 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_70, 0, x_69);
+lean_ctor_set(x_70, 1, x_56);
+return x_70;
 }
 else
 {
-lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; uint8_t x_73; 
-x_69 = l_Lean_ConstantInfo_levelParams(x_59);
-x_70 = lean_unsigned_to_nat(0u);
-x_71 = l_List_lengthTRAux___rarg(x_69, x_70);
-lean_dec(x_69);
-x_72 = l_List_lengthTRAux___rarg(x_8, x_70);
-x_73 = lean_nat_dec_eq(x_71, x_72);
-lean_dec(x_72);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; 
+x_71 = l_Lean_ConstantInfo_levelParams(x_61);
+x_72 = lean_unsigned_to_nat(0u);
+x_73 = l_List_lengthTRAux___rarg(x_71, x_72);
 lean_dec(x_71);
-if (x_73 == 0)
+x_74 = l_List_lengthTRAux___rarg(x_8, x_72);
+x_75 = lean_nat_dec_eq(x_73, x_74);
+lean_dec(x_74);
+lean_dec(x_73);
+if (x_75 == 0)
 {
-lean_object* x_74; lean_object* x_75; 
-lean_dec(x_60);
-lean_dec(x_59);
+lean_object* x_76; lean_object* x_77; 
+lean_dec(x_62);
+lean_dec(x_61);
 lean_dec(x_8);
 lean_dec(x_1);
-x_74 = lean_box(0);
-x_75 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_75, 0, x_74);
-lean_ctor_set(x_75, 1, x_54);
-return x_75;
+x_76 = lean_box(0);
+x_77 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_77, 0, x_76);
+lean_ctor_set(x_77, 1, x_56);
+return x_77;
 }
 else
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; 
-x_76 = lean_instantiate_value_lparams(x_59, x_8);
+lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+x_78 = lean_instantiate_value_lparams(x_61, x_8);
 lean_dec(x_8);
-lean_dec(x_59);
-x_77 = l_Lean_Expr_getAppNumArgsAux(x_1, x_70);
-x_78 = lean_mk_empty_array_with_capacity(x_77);
-lean_dec(x_77);
-x_79 = l___private_Lean_Expr_0__Lean_Expr_getAppRevArgsAux(x_1, x_78);
-x_80 = l_Lean_Expr_betaRev(x_76, x_79);
+lean_dec(x_61);
+x_79 = l_Lean_Expr_getAppNumArgsAux(x_1, x_72);
+x_80 = lean_mk_empty_array_with_capacity(x_79);
 lean_dec(x_79);
-lean_dec(x_76);
-if (lean_is_scalar(x_60)) {
- x_81 = lean_alloc_ctor(1, 1, 0);
+x_81 = l___private_Lean_Expr_0__Lean_Expr_getAppRevArgsAux(x_1, x_80);
+x_82 = 1;
+x_83 = l_Lean_Expr_betaRev(x_78, x_81, x_82);
+lean_dec(x_81);
+if (lean_is_scalar(x_62)) {
+ x_84 = lean_alloc_ctor(1, 1, 0);
 } else {
- x_81 = x_60;
+ x_84 = x_62;
 }
-lean_ctor_set(x_81, 0, x_80);
-x_82 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_82, 0, x_81);
-lean_ctor_set(x_82, 1, x_54);
-return x_82;
+lean_ctor_set(x_84, 0, x_83);
+x_85 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_85, 0, x_84);
+lean_ctor_set(x_85, 1, x_56);
+return x_85;
 }
 }
 }
@@ -364,15 +364,15 @@ return x_82;
 }
 else
 {
-lean_object* x_83; lean_object* x_84; 
+lean_object* x_86; lean_object* x_87; 
 lean_dec(x_6);
 lean_dec(x_2);
 lean_dec(x_1);
-x_83 = lean_box(0);
-x_84 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_84, 0, x_83);
-lean_ctor_set(x_84, 1, x_5);
-return x_84;
+x_86 = lean_box(0);
+x_87 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_87, 0, x_86);
+lean_ctor_set(x_87, 1, x_5);
+return x_87;
 }
 }
 }

stage0/stdlib/Lean/Meta/Tactic/Induction.c

@@ -98,7 +98,7 @@ lean_object* l_Lean_Meta_mkLambdaFVars(lean_object*, lean_object*, uint8_t, uint
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_InductionSubgoal_subst___default;
 LEAN_EXPORT lean_object* l___private_Lean_Meta_Tactic_Induction_0__Lean_Meta_finalize_loop___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_Lean_Expr_isHeadBetaTarget(lean_object*);
+uint8_t l_Lean_Expr_isHeadBetaTarget(lean_object*, uint8_t);
 LEAN_EXPORT lean_object* l_Lean_Expr_withAppAux___at_Lean_Meta_induction___spec__8(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*);
 lean_object* l_Nat_repr(lean_object*);
 static lean_object* l_Lean_Meta_instInhabitedInductionSubgoal___closed__1;
@@ -250,20 +250,21 @@ goto _start;
 }
 default: 
 {
-uint8_t x_8; 
-x_8 = l_Lean_Expr_isHeadBetaTarget(x_1);
-if (x_8 == 0)
+uint8_t x_8; uint8_t x_9; 
+x_8 = 0;
+x_9 = l_Lean_Expr_isHeadBetaTarget(x_1, x_8);
+if (x_9 == 0)
 {
-lean_object* x_9; 
+lean_object* x_10; 
 lean_dec(x_1);
-x_9 = lean_unsigned_to_nat(0u);
-return x_9;
+x_10 = lean_unsigned_to_nat(0u);
+return x_10;
 }
 else
 {
-lean_object* x_10; 
-x_10 = l_Lean_Expr_headBeta(x_1);
-x_1 = x_10;
+lean_object* x_11; 
+x_11 = l_Lean_Expr_headBeta(x_1);
+x_1 = x_11;
 goto _start;
 }
 }

stage0/stdlib/Lean/Meta/Tactic/Simp/SimpTheorems.c

@@ -11767,7 +11767,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_SimpTheorem_getValue___closed__1;
 x_2 = l_Lean_Meta_SimpTheorem_getValue___closed__2;
-x_3 = lean_unsigned_to_nat(975u);
+x_3 = lean_unsigned_to_nat(988u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Meta_SimpTheorem_getValue___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Meta/Tactic/Simp/Types.c

@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Lean.Meta.Tactic.Simp.Types
-// Imports: Init Lean.Meta.AppBuilder Lean.Meta.Tactic.Simp.SimpTheorems Lean.Meta.Tactic.Simp.SimpCongrTheorems
+// Imports: Init Lean.Meta.AppBuilder Lean.Meta.CongrTheorems Lean.Meta.Tactic.Simp.SimpTheorems Lean.Meta.Tactic.Simp.SimpCongrTheorems
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -72,6 +72,7 @@ extern lean_object* l_Std_PersistentHashMap_empty___at_Lean_Meta_Instances_insta
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_getConfig___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_instMonadBacktrackSavedStateSimpM___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_instInhabitedMethods___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Std_mkHashMap___at_Lean_Meta_Simp_State_congrCache___default___spec__1___boxed(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_Methods_pre___default___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_Methods_post___default(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_Step_result(lean_object*);
@@ -82,8 +83,10 @@ LEAN_EXPORT lean_object* l_Lean_Meta_Simp_getConfig___boxed(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_Context_mkDefault___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_withParent(lean_object*);
 static lean_object* l_Lean_Meta_Simp_instInhabitedResult___closed__3;
+LEAN_EXPORT lean_object* l_Lean_Meta_Simp_State_congrCache___default;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_instInhabitedMethods;
+LEAN_EXPORT lean_object* l_Std_mkHashMap___at_Lean_Meta_Simp_State_congrCache___default___spec__1(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_getSimpTheorems(lean_object*);
 static lean_object* l_Lean_Meta_Simp_Context_simpTheorems___default___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Meta_Simp_instInhabitedMethods___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -503,6 +506,32 @@ lean_dec(x_1);
 return x_2;
 }
 }
+LEAN_EXPORT lean_object* l_Std_mkHashMap___at_Lean_Meta_Simp_State_congrCache___default___spec__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_Std_mkHashMapImp___rarg(x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Meta_Simp_State_congrCache___default() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = lean_unsigned_to_nat(0u);
+x_2 = l_Std_mkHashMapImp___rarg(x_1);
+return x_2;
+}
+}
+LEAN_EXPORT lean_object* l_Std_mkHashMap___at_Lean_Meta_Simp_State_congrCache___default___spec__1___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_Std_mkHashMap___at_Lean_Meta_Simp_State_congrCache___default___spec__1(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
 static lean_object* _init_l_Lean_Meta_Simp_State_numSteps___default() {
 _start:
 {
@@ -1122,416 +1151,441 @@ return x_43;
 }
 else
 {
-lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
+lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
 x_44 = lean_ctor_get(x_35, 1);
+x_45 = lean_ctor_get(x_35, 2);
+lean_inc(x_45);
 lean_inc(x_44);
 lean_dec(x_35);
-x_45 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_45, 0, x_16);
-lean_ctor_set(x_45, 1, x_44);
-x_46 = lean_st_ref_set(x_5, x_45, x_36);
+x_46 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_46, 0, x_16);
+lean_ctor_set(x_46, 1, x_44);
+lean_ctor_set(x_46, 2, x_45);
+x_47 = lean_st_ref_set(x_5, x_46, x_36);
 lean_dec(x_5);
-x_47 = lean_ctor_get(x_46, 1);
-lean_inc(x_47);
-if (lean_is_exclusive(x_46)) {
- lean_ctor_release(x_46, 0);
- lean_ctor_release(x_46, 1);
- x_48 = x_46;
+x_48 = lean_ctor_get(x_47, 1);
+lean_inc(x_48);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ x_49 = x_47;
 } else {
- lean_dec_ref(x_46);
- x_48 = lean_box(0);
+ lean_dec_ref(x_47);
+ x_49 = lean_box(0);
 }
-if (lean_is_scalar(x_48)) {
- x_49 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_49)) {
+ x_50 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_49 = x_48;
+ x_50 = x_49;
 }
-lean_ctor_set(x_49, 0, x_30);
-lean_ctor_set(x_49, 1, x_47);
-return x_49;
+lean_ctor_set(x_50, 0, x_30);
+lean_ctor_set(x_50, 1, x_48);
+return x_50;
 }
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; 
-x_50 = lean_ctor_get(x_29, 0);
-lean_inc(x_50);
-x_51 = lean_ctor_get(x_29, 1);
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; 
+x_51 = lean_ctor_get(x_29, 0);
 lean_inc(x_51);
+x_52 = lean_ctor_get(x_29, 1);
+lean_inc(x_52);
 lean_dec(x_29);
-x_52 = lean_st_ref_get(x_9, x_51);
+x_53 = lean_st_ref_get(x_9, x_52);
 lean_dec(x_9);
-x_53 = lean_ctor_get(x_52, 1);
-lean_inc(x_53);
-lean_dec(x_52);
-x_54 = lean_st_ref_take(x_5, x_53);
-x_55 = lean_ctor_get(x_54, 0);
-lean_inc(x_55);
-x_56 = lean_ctor_get(x_54, 1);
+x_54 = lean_ctor_get(x_53, 1);
+lean_inc(x_54);
+lean_dec(x_53);
+x_55 = lean_st_ref_take(x_5, x_54);
+x_56 = lean_ctor_get(x_55, 0);
 lean_inc(x_56);
-lean_dec(x_54);
-x_57 = !lean_is_exclusive(x_55);
-if (x_57 == 0)
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_58 = lean_ctor_get(x_55, 0);
-lean_dec(x_58);
-lean_ctor_set(x_55, 0, x_16);
-x_59 = lean_st_ref_set(x_5, x_55, x_56);
-lean_dec(x_5);
-x_60 = !lean_is_exclusive(x_59);
-if (x_60 == 0)
-{
-lean_object* x_61; 
-x_61 = lean_ctor_get(x_59, 0);
-lean_dec(x_61);
-lean_ctor_set_tag(x_59, 1);
-lean_ctor_set(x_59, 0, x_50);
-return x_59;
-}
-else
-{
-lean_object* x_62; lean_object* x_63; 
-x_62 = lean_ctor_get(x_59, 1);
-lean_inc(x_62);
-lean_dec(x_59);
-x_63 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_63, 0, x_50);
-lean_ctor_set(x_63, 1, x_62);
-return x_63;
-}
-}
-else
-{
-lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
-x_64 = lean_ctor_get(x_55, 1);
-lean_inc(x_64);
+x_57 = lean_ctor_get(x_55, 1);
+lean_inc(x_57);
 lean_dec(x_55);
-x_65 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_65, 0, x_16);
-lean_ctor_set(x_65, 1, x_64);
-x_66 = lean_st_ref_set(x_5, x_65, x_56);
+x_58 = !lean_is_exclusive(x_56);
+if (x_58 == 0)
+{
+lean_object* x_59; lean_object* x_60; uint8_t x_61; 
+x_59 = lean_ctor_get(x_56, 0);
+lean_dec(x_59);
+lean_ctor_set(x_56, 0, x_16);
+x_60 = lean_st_ref_set(x_5, x_56, x_57);
 lean_dec(x_5);
-x_67 = lean_ctor_get(x_66, 1);
-lean_inc(x_67);
-if (lean_is_exclusive(x_66)) {
- lean_ctor_release(x_66, 0);
- lean_ctor_release(x_66, 1);
- x_68 = x_66;
-} else {
- lean_dec_ref(x_66);
- x_68 = lean_box(0);
+x_61 = !lean_is_exclusive(x_60);
+if (x_61 == 0)
+{
+lean_object* x_62; 
+x_62 = lean_ctor_get(x_60, 0);
+lean_dec(x_62);
+lean_ctor_set_tag(x_60, 1);
+lean_ctor_set(x_60, 0, x_51);
+return x_60;
 }
-if (lean_is_scalar(x_68)) {
- x_69 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_69 = x_68;
- lean_ctor_set_tag(x_69, 1);
+else
+{
+lean_object* x_63; lean_object* x_64; 
+x_63 = lean_ctor_get(x_60, 1);
+lean_inc(x_63);
+lean_dec(x_60);
+x_64 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_64, 0, x_51);
+lean_ctor_set(x_64, 1, x_63);
+return x_64;
 }
-lean_ctor_set(x_69, 0, x_50);
-lean_ctor_set(x_69, 1, x_67);
-return x_69;
+}
+else
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+x_65 = lean_ctor_get(x_56, 1);
+x_66 = lean_ctor_get(x_56, 2);
+lean_inc(x_66);
+lean_inc(x_65);
+lean_dec(x_56);
+x_67 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_67, 0, x_16);
+lean_ctor_set(x_67, 1, x_65);
+lean_ctor_set(x_67, 2, x_66);
+x_68 = lean_st_ref_set(x_5, x_67, x_57);
+lean_dec(x_5);
+x_69 = lean_ctor_get(x_68, 1);
+lean_inc(x_69);
+if (lean_is_exclusive(x_68)) {
+ lean_ctor_release(x_68, 0);
+ lean_ctor_release(x_68, 1);
+ x_70 = x_68;
+} else {
+ lean_dec_ref(x_68);
+ x_70 = lean_box(0);
+}
+if (lean_is_scalar(x_70)) {
+ x_71 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_71 = x_70;
+ lean_ctor_set_tag(x_71, 1);
+}
+lean_ctor_set(x_71, 0, x_51);
+lean_ctor_set(x_71, 1, x_69);
+return x_71;
 }
 }
 }
 else
 {
-lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_70 = lean_ctor_get(x_4, 0);
-x_71 = lean_ctor_get(x_4, 2);
-x_72 = lean_ctor_get(x_4, 3);
-x_73 = lean_ctor_get(x_4, 4);
+lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; 
+x_72 = lean_ctor_get(x_4, 0);
+x_73 = lean_ctor_get(x_4, 2);
+x_74 = lean_ctor_get(x_4, 3);
+x_75 = lean_ctor_get(x_4, 4);
+lean_inc(x_75);
+lean_inc(x_74);
 lean_inc(x_73);
 lean_inc(x_72);
-lean_inc(x_71);
-lean_inc(x_70);
 lean_dec(x_4);
-x_74 = lean_alloc_ctor(0, 5, 0);
-lean_ctor_set(x_74, 0, x_70);
-lean_ctor_set(x_74, 1, x_1);
-lean_ctor_set(x_74, 2, x_71);
-lean_ctor_set(x_74, 3, x_72);
-lean_ctor_set(x_74, 4, x_73);
+x_76 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_76, 0, x_72);
+lean_ctor_set(x_76, 1, x_1);
+lean_ctor_set(x_76, 2, x_73);
+lean_ctor_set(x_76, 3, x_74);
+lean_ctor_set(x_76, 4, x_75);
 lean_inc(x_9);
 lean_inc(x_5);
-x_75 = lean_apply_8(x_2, x_3, x_74, x_5, x_6, x_7, x_8, x_9, x_26);
-if (lean_obj_tag(x_75) == 0)
+x_77 = lean_apply_8(x_2, x_3, x_76, x_5, x_6, x_7, x_8, x_9, x_26);
+if (lean_obj_tag(x_77) == 0)
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; 
-x_76 = lean_ctor_get(x_75, 0);
-lean_inc(x_76);
-x_77 = lean_ctor_get(x_75, 1);
-lean_inc(x_77);
-lean_dec(x_75);
-x_78 = lean_st_ref_get(x_9, x_77);
-lean_dec(x_9);
-x_79 = lean_ctor_get(x_78, 1);
+lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
+x_78 = lean_ctor_get(x_77, 0);
+lean_inc(x_78);
+x_79 = lean_ctor_get(x_77, 1);
 lean_inc(x_79);
-lean_dec(x_78);
-x_80 = lean_st_ref_take(x_5, x_79);
-x_81 = lean_ctor_get(x_80, 0);
+lean_dec(x_77);
+x_80 = lean_st_ref_get(x_9, x_79);
+lean_dec(x_9);
+x_81 = lean_ctor_get(x_80, 1);
 lean_inc(x_81);
-x_82 = lean_ctor_get(x_80, 1);
-lean_inc(x_82);
 lean_dec(x_80);
-x_83 = lean_ctor_get(x_81, 1);
+x_82 = lean_st_ref_take(x_5, x_81);
+x_83 = lean_ctor_get(x_82, 0);
 lean_inc(x_83);
-if (lean_is_exclusive(x_81)) {
- lean_ctor_release(x_81, 0);
- lean_ctor_release(x_81, 1);
- x_84 = x_81;
+x_84 = lean_ctor_get(x_82, 1);
+lean_inc(x_84);
+lean_dec(x_82);
+x_85 = lean_ctor_get(x_83, 1);
+lean_inc(x_85);
+x_86 = lean_ctor_get(x_83, 2);
+lean_inc(x_86);
+if (lean_is_exclusive(x_83)) {
+ lean_ctor_release(x_83, 0);
+ lean_ctor_release(x_83, 1);
+ lean_ctor_release(x_83, 2);
+ x_87 = x_83;
 } else {
- lean_dec_ref(x_81);
- x_84 = lean_box(0);
+ lean_dec_ref(x_83);
+ x_87 = lean_box(0);
 }
-if (lean_is_scalar(x_84)) {
- x_85 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_87)) {
+ x_88 = lean_alloc_ctor(0, 3, 0);
 } else {
- x_85 = x_84;
+ x_88 = x_87;
 }
-lean_ctor_set(x_85, 0, x_16);
-lean_ctor_set(x_85, 1, x_83);
-x_86 = lean_st_ref_set(x_5, x_85, x_82);
+lean_ctor_set(x_88, 0, x_16);
+lean_ctor_set(x_88, 1, x_85);
+lean_ctor_set(x_88, 2, x_86);
+x_89 = lean_st_ref_set(x_5, x_88, x_84);
 lean_dec(x_5);
-x_87 = lean_ctor_get(x_86, 1);
-lean_inc(x_87);
-if (lean_is_exclusive(x_86)) {
- lean_ctor_release(x_86, 0);
- lean_ctor_release(x_86, 1);
- x_88 = x_86;
+x_90 = lean_ctor_get(x_89, 1);
+lean_inc(x_90);
+if (lean_is_exclusive(x_89)) {
+ lean_ctor_release(x_89, 0);
+ lean_ctor_release(x_89, 1);
+ x_91 = x_89;
 } else {
- lean_dec_ref(x_86);
- x_88 = lean_box(0);
+ lean_dec_ref(x_89);
+ x_91 = lean_box(0);
 }
-if (lean_is_scalar(x_88)) {
- x_89 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_91)) {
+ x_92 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_89 = x_88;
+ x_92 = x_91;
 }
-lean_ctor_set(x_89, 0, x_76);
-lean_ctor_set(x_89, 1, x_87);
-return x_89;
+lean_ctor_set(x_92, 0, x_78);
+lean_ctor_set(x_92, 1, x_90);
+return x_92;
 }
 else
 {
-lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; 
-x_90 = lean_ctor_get(x_75, 0);
-lean_inc(x_90);
-x_91 = lean_ctor_get(x_75, 1);
-lean_inc(x_91);
-lean_dec(x_75);
-x_92 = lean_st_ref_get(x_9, x_91);
-lean_dec(x_9);
-x_93 = lean_ctor_get(x_92, 1);
+lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; 
+x_93 = lean_ctor_get(x_77, 0);
 lean_inc(x_93);
-lean_dec(x_92);
-x_94 = lean_st_ref_take(x_5, x_93);
-x_95 = lean_ctor_get(x_94, 0);
-lean_inc(x_95);
-x_96 = lean_ctor_get(x_94, 1);
+x_94 = lean_ctor_get(x_77, 1);
+lean_inc(x_94);
+lean_dec(x_77);
+x_95 = lean_st_ref_get(x_9, x_94);
+lean_dec(x_9);
+x_96 = lean_ctor_get(x_95, 1);
 lean_inc(x_96);
-lean_dec(x_94);
-x_97 = lean_ctor_get(x_95, 1);
-lean_inc(x_97);
-if (lean_is_exclusive(x_95)) {
- lean_ctor_release(x_95, 0);
- lean_ctor_release(x_95, 1);
- x_98 = x_95;
-} else {
- lean_dec_ref(x_95);
- x_98 = lean_box(0);
-}
-if (lean_is_scalar(x_98)) {
- x_99 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_99 = x_98;
-}
-lean_ctor_set(x_99, 0, x_16);
-lean_ctor_set(x_99, 1, x_97);
-x_100 = lean_st_ref_set(x_5, x_99, x_96);
-lean_dec(x_5);
-x_101 = lean_ctor_get(x_100, 1);
+lean_dec(x_95);
+x_97 = lean_st_ref_take(x_5, x_96);
+x_98 = lean_ctor_get(x_97, 0);
+lean_inc(x_98);
+x_99 = lean_ctor_get(x_97, 1);
+lean_inc(x_99);
+lean_dec(x_97);
+x_100 = lean_ctor_get(x_98, 1);
+lean_inc(x_100);
+x_101 = lean_ctor_get(x_98, 2);
 lean_inc(x_101);
-if (lean_is_exclusive(x_100)) {
- lean_ctor_release(x_100, 0);
- lean_ctor_release(x_100, 1);
- x_102 = x_100;
+if (lean_is_exclusive(x_98)) {
+ lean_ctor_release(x_98, 0);
+ lean_ctor_release(x_98, 1);
+ lean_ctor_release(x_98, 2);
+ x_102 = x_98;
 } else {
- lean_dec_ref(x_100);
+ lean_dec_ref(x_98);
  x_102 = lean_box(0);
 }
 if (lean_is_scalar(x_102)) {
- x_103 = lean_alloc_ctor(1, 2, 0);
+ x_103 = lean_alloc_ctor(0, 3, 0);
 } else {
  x_103 = x_102;
- lean_ctor_set_tag(x_103, 1);
 }
-lean_ctor_set(x_103, 0, x_90);
-lean_ctor_set(x_103, 1, x_101);
-return x_103;
+lean_ctor_set(x_103, 0, x_16);
+lean_ctor_set(x_103, 1, x_100);
+lean_ctor_set(x_103, 2, x_101);
+x_104 = lean_st_ref_set(x_5, x_103, x_99);
+lean_dec(x_5);
+x_105 = lean_ctor_get(x_104, 1);
+lean_inc(x_105);
+if (lean_is_exclusive(x_104)) {
+ lean_ctor_release(x_104, 0);
+ lean_ctor_release(x_104, 1);
+ x_106 = x_104;
+} else {
+ lean_dec_ref(x_104);
+ x_106 = lean_box(0);
+}
+if (lean_is_scalar(x_106)) {
+ x_107 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_107 = x_106;
+ lean_ctor_set_tag(x_107, 1);
+}
+lean_ctor_set(x_107, 0, x_93);
+lean_ctor_set(x_107, 1, x_105);
+return x_107;
 }
 }
 }
 else
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; 
-x_104 = lean_ctor_get(x_20, 1);
-lean_inc(x_104);
-lean_dec(x_20);
-x_105 = l_Lean_Meta_Simp_Context_congrTheorems___default___closed__1;
-x_106 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_106, 0, x_105);
-lean_ctor_set(x_106, 1, x_104);
-x_107 = lean_st_ref_set(x_5, x_106, x_21);
-x_108 = lean_ctor_get(x_107, 1);
-lean_inc(x_108);
-lean_dec(x_107);
-x_109 = lean_ctor_get(x_4, 0);
+lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; 
+x_108 = lean_ctor_get(x_20, 1);
+x_109 = lean_ctor_get(x_20, 2);
 lean_inc(x_109);
-x_110 = lean_ctor_get(x_4, 2);
-lean_inc(x_110);
-x_111 = lean_ctor_get(x_4, 3);
-lean_inc(x_111);
-x_112 = lean_ctor_get(x_4, 4);
-lean_inc(x_112);
+lean_inc(x_108);
+lean_dec(x_20);
+x_110 = l_Lean_Meta_Simp_Context_congrTheorems___default___closed__1;
+x_111 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_111, 0, x_110);
+lean_ctor_set(x_111, 1, x_108);
+lean_ctor_set(x_111, 2, x_109);
+x_112 = lean_st_ref_set(x_5, x_111, x_21);
+x_113 = lean_ctor_get(x_112, 1);
+lean_inc(x_113);
+lean_dec(x_112);
+x_114 = lean_ctor_get(x_4, 0);
+lean_inc(x_114);
+x_115 = lean_ctor_get(x_4, 2);
+lean_inc(x_115);
+x_116 = lean_ctor_get(x_4, 3);
+lean_inc(x_116);
+x_117 = lean_ctor_get(x_4, 4);
+lean_inc(x_117);
 if (lean_is_exclusive(x_4)) {
  lean_ctor_release(x_4, 0);
  lean_ctor_release(x_4, 1);
  lean_ctor_release(x_4, 2);
  lean_ctor_release(x_4, 3);
  lean_ctor_release(x_4, 4);
- x_113 = x_4;
+ x_118 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_113 = lean_box(0);
+ x_118 = lean_box(0);
 }
-if (lean_is_scalar(x_113)) {
- x_114 = lean_alloc_ctor(0, 5, 0);
+if (lean_is_scalar(x_118)) {
+ x_119 = lean_alloc_ctor(0, 5, 0);
 } else {
- x_114 = x_113;
+ x_119 = x_118;
 }
-lean_ctor_set(x_114, 0, x_109);
-lean_ctor_set(x_114, 1, x_1);
-lean_ctor_set(x_114, 2, x_110);
-lean_ctor_set(x_114, 3, x_111);
-lean_ctor_set(x_114, 4, x_112);
+lean_ctor_set(x_119, 0, x_114);
+lean_ctor_set(x_119, 1, x_1);
+lean_ctor_set(x_119, 2, x_115);
+lean_ctor_set(x_119, 3, x_116);
+lean_ctor_set(x_119, 4, x_117);
 lean_inc(x_9);
 lean_inc(x_5);
-x_115 = lean_apply_8(x_2, x_3, x_114, x_5, x_6, x_7, x_8, x_9, x_108);
-if (lean_obj_tag(x_115) == 0)
+x_120 = lean_apply_8(x_2, x_3, x_119, x_5, x_6, x_7, x_8, x_9, x_113);
+if (lean_obj_tag(x_120) == 0)
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; 
-x_116 = lean_ctor_get(x_115, 0);
-lean_inc(x_116);
-x_117 = lean_ctor_get(x_115, 1);
-lean_inc(x_117);
-lean_dec(x_115);
-x_118 = lean_st_ref_get(x_9, x_117);
-lean_dec(x_9);
-x_119 = lean_ctor_get(x_118, 1);
-lean_inc(x_119);
-lean_dec(x_118);
-x_120 = lean_st_ref_take(x_5, x_119);
+lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; 
 x_121 = lean_ctor_get(x_120, 0);
 lean_inc(x_121);
 x_122 = lean_ctor_get(x_120, 1);
 lean_inc(x_122);
 lean_dec(x_120);
-x_123 = lean_ctor_get(x_121, 1);
-lean_inc(x_123);
-if (lean_is_exclusive(x_121)) {
- lean_ctor_release(x_121, 0);
- lean_ctor_release(x_121, 1);
- x_124 = x_121;
-} else {
- lean_dec_ref(x_121);
- x_124 = lean_box(0);
-}
-if (lean_is_scalar(x_124)) {
- x_125 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_125 = x_124;
-}
-lean_ctor_set(x_125, 0, x_16);
-lean_ctor_set(x_125, 1, x_123);
-x_126 = lean_st_ref_set(x_5, x_125, x_122);
-lean_dec(x_5);
-x_127 = lean_ctor_get(x_126, 1);
+x_123 = lean_st_ref_get(x_9, x_122);
+lean_dec(x_9);
+x_124 = lean_ctor_get(x_123, 1);
+lean_inc(x_124);
+lean_dec(x_123);
+x_125 = lean_st_ref_take(x_5, x_124);
+x_126 = lean_ctor_get(x_125, 0);
+lean_inc(x_126);
+x_127 = lean_ctor_get(x_125, 1);
 lean_inc(x_127);
+lean_dec(x_125);
+x_128 = lean_ctor_get(x_126, 1);
+lean_inc(x_128);
+x_129 = lean_ctor_get(x_126, 2);
+lean_inc(x_129);
 if (lean_is_exclusive(x_126)) {
  lean_ctor_release(x_126, 0);
  lean_ctor_release(x_126, 1);
- x_128 = x_126;
+ lean_ctor_release(x_126, 2);
+ x_130 = x_126;
 } else {
  lean_dec_ref(x_126);
- x_128 = lean_box(0);
+ x_130 = lean_box(0);
 }
-if (lean_is_scalar(x_128)) {
- x_129 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_130)) {
+ x_131 = lean_alloc_ctor(0, 3, 0);
 } else {
- x_129 = x_128;
+ x_131 = x_130;
 }
-lean_ctor_set(x_129, 0, x_116);
-lean_ctor_set(x_129, 1, x_127);
-return x_129;
+lean_ctor_set(x_131, 0, x_16);
+lean_ctor_set(x_131, 1, x_128);
+lean_ctor_set(x_131, 2, x_129);
+x_132 = lean_st_ref_set(x_5, x_131, x_127);
+lean_dec(x_5);
+x_133 = lean_ctor_get(x_132, 1);
+lean_inc(x_133);
+if (lean_is_exclusive(x_132)) {
+ lean_ctor_release(x_132, 0);
+ lean_ctor_release(x_132, 1);
+ x_134 = x_132;
+} else {
+ lean_dec_ref(x_132);
+ x_134 = lean_box(0);
+}
+if (lean_is_scalar(x_134)) {
+ x_135 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_135 = x_134;
+}
+lean_ctor_set(x_135, 0, x_121);
+lean_ctor_set(x_135, 1, x_133);
+return x_135;
 }
 else
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-x_130 = lean_ctor_get(x_115, 0);
-lean_inc(x_130);
-x_131 = lean_ctor_get(x_115, 1);
-lean_inc(x_131);
-lean_dec(x_115);
-x_132 = lean_st_ref_get(x_9, x_131);
-lean_dec(x_9);
-x_133 = lean_ctor_get(x_132, 1);
-lean_inc(x_133);
-lean_dec(x_132);
-x_134 = lean_st_ref_take(x_5, x_133);
-x_135 = lean_ctor_get(x_134, 0);
-lean_inc(x_135);
-x_136 = lean_ctor_get(x_134, 1);
+lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; 
+x_136 = lean_ctor_get(x_120, 0);
 lean_inc(x_136);
-lean_dec(x_134);
-x_137 = lean_ctor_get(x_135, 1);
+x_137 = lean_ctor_get(x_120, 1);
 lean_inc(x_137);
-if (lean_is_exclusive(x_135)) {
- lean_ctor_release(x_135, 0);
- lean_ctor_release(x_135, 1);
- x_138 = x_135;
-} else {
- lean_dec_ref(x_135);
- x_138 = lean_box(0);
-}
-if (lean_is_scalar(x_138)) {
- x_139 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_139 = x_138;
-}
-lean_ctor_set(x_139, 0, x_16);
-lean_ctor_set(x_139, 1, x_137);
-x_140 = lean_st_ref_set(x_5, x_139, x_136);
-lean_dec(x_5);
-x_141 = lean_ctor_get(x_140, 1);
+lean_dec(x_120);
+x_138 = lean_st_ref_get(x_9, x_137);
+lean_dec(x_9);
+x_139 = lean_ctor_get(x_138, 1);
+lean_inc(x_139);
+lean_dec(x_138);
+x_140 = lean_st_ref_take(x_5, x_139);
+x_141 = lean_ctor_get(x_140, 0);
 lean_inc(x_141);
-if (lean_is_exclusive(x_140)) {
- lean_ctor_release(x_140, 0);
- lean_ctor_release(x_140, 1);
- x_142 = x_140;
+x_142 = lean_ctor_get(x_140, 1);
+lean_inc(x_142);
+lean_dec(x_140);
+x_143 = lean_ctor_get(x_141, 1);
+lean_inc(x_143);
+x_144 = lean_ctor_get(x_141, 2);
+lean_inc(x_144);
+if (lean_is_exclusive(x_141)) {
+ lean_ctor_release(x_141, 0);
+ lean_ctor_release(x_141, 1);
+ lean_ctor_release(x_141, 2);
+ x_145 = x_141;
 } else {
- lean_dec_ref(x_140);
- x_142 = lean_box(0);
+ lean_dec_ref(x_141);
+ x_145 = lean_box(0);
 }
-if (lean_is_scalar(x_142)) {
- x_143 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_145)) {
+ x_146 = lean_alloc_ctor(0, 3, 0);
 } else {
- x_143 = x_142;
- lean_ctor_set_tag(x_143, 1);
+ x_146 = x_145;
 }
-lean_ctor_set(x_143, 0, x_130);
-lean_ctor_set(x_143, 1, x_141);
-return x_143;
+lean_ctor_set(x_146, 0, x_16);
+lean_ctor_set(x_146, 1, x_143);
+lean_ctor_set(x_146, 2, x_144);
+x_147 = lean_st_ref_set(x_5, x_146, x_142);
+lean_dec(x_5);
+x_148 = lean_ctor_get(x_147, 1);
+lean_inc(x_148);
+if (lean_is_exclusive(x_147)) {
+ lean_ctor_release(x_147, 0);
+ lean_ctor_release(x_147, 1);
+ x_149 = x_147;
+} else {
+ lean_dec_ref(x_147);
+ x_149 = lean_box(0);
+}
+if (lean_is_scalar(x_149)) {
+ x_150 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_150 = x_149;
+ lean_ctor_set_tag(x_150, 1);
+}
+lean_ctor_set(x_150, 0, x_136);
+lean_ctor_set(x_150, 1, x_148);
+return x_150;
 }
 }
 }
@@ -1546,6 +1600,7 @@ return x_2;
 }
 lean_object* initialize_Init(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Meta_AppBuilder(uint8_t builtin, lean_object*);
+lean_object* initialize_Lean_Meta_CongrTheorems(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Meta_Tactic_Simp_SimpTheorems(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Meta_Tactic_Simp_SimpCongrTheorems(uint8_t builtin, lean_object*);
 static bool _G_initialized = false;
@@ -1559,6 +1614,9 @@ lean_dec_ref(res);
 res = initialize_Lean_Meta_AppBuilder(builtin, lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Lean_Meta_CongrTheorems(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
 res = initialize_Lean_Meta_Tactic_Simp_SimpTheorems(builtin, lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
@@ -1616,6 +1674,8 @@ l_Lean_Meta_Simp_Context_mkDefault___rarg___closed__1 = _init_l_Lean_Meta_Simp_C
 lean_mark_persistent(l_Lean_Meta_Simp_Context_mkDefault___rarg___closed__1);
 l_Lean_Meta_Simp_State_cache___default = _init_l_Lean_Meta_Simp_State_cache___default();
 lean_mark_persistent(l_Lean_Meta_Simp_State_cache___default);
+l_Lean_Meta_Simp_State_congrCache___default = _init_l_Lean_Meta_Simp_State_congrCache___default();
+lean_mark_persistent(l_Lean_Meta_Simp_State_congrCache___default);
 l_Lean_Meta_Simp_State_numSteps___default = _init_l_Lean_Meta_Simp_State_numSteps___default();
 lean_mark_persistent(l_Lean_Meta_Simp_State_numSteps___default);
 l_Lean_Meta_Simp_instMonadBacktrackSavedStateSimpM___closed__1 = _init_l_Lean_Meta_Simp_instMonadBacktrackSavedStateSimpM___closed__1();

stage0/stdlib/Lean/Meta/Transform.c

@@ -657,7 +657,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__2;
-x_3 = lean_unsigned_to_nat(1034u);
+x_3 = lean_unsigned_to_nat(1047u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -763,7 +763,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__4___closed__1;
-x_3 = lean_unsigned_to_nat(1020u);
+x_3 = lean_unsigned_to_nat(1033u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__4___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -869,7 +869,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__6___closed__1;
-x_3 = lean_unsigned_to_nat(1043u);
+x_3 = lean_unsigned_to_nat(1056u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__6___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -1006,7 +1006,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__9___closed__1;
-x_3 = lean_unsigned_to_nat(1001u);
+x_3 = lean_unsigned_to_nat(1014u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__9___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -1079,7 +1079,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__10___closed__1;
-x_3 = lean_unsigned_to_nat(1006u);
+x_3 = lean_unsigned_to_nat(1019u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__10___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -5020,29 +5020,28 @@ return x_10;
 LEAN_EXPORT lean_object* l_Lean_Meta_transform_visit_visitLambda___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
 _start:
 {
-uint8_t x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
 x_12 = 0;
-x_13 = 1;
+x_13 = lean_box(x_12);
 x_14 = lean_box(x_12);
-x_15 = lean_box(x_13);
-x_16 = lean_alloc_closure((void*)(l_Lean_Meta_mkLambdaFVars___boxed), 9, 4);
-lean_closure_set(x_16, 0, x_1);
-lean_closure_set(x_16, 1, x_11);
-lean_closure_set(x_16, 2, x_14);
-lean_closure_set(x_16, 3, x_15);
+x_15 = lean_alloc_closure((void*)(l_Lean_Meta_mkLambdaFVars___boxed), 9, 4);
+lean_closure_set(x_15, 0, x_1);
+lean_closure_set(x_15, 1, x_11);
+lean_closure_set(x_15, 2, x_13);
+lean_closure_set(x_15, 3, x_14);
 lean_inc(x_2);
-x_17 = lean_apply_2(x_2, lean_box(0), x_16);
-x_18 = lean_alloc_closure((void*)(l_Lean_Meta_transform_visit_visitLambda___rarg___lambda__1), 9, 8);
-lean_closure_set(x_18, 0, x_3);
-lean_closure_set(x_18, 1, x_2);
-lean_closure_set(x_18, 2, x_4);
-lean_closure_set(x_18, 3, x_5);
-lean_closure_set(x_18, 4, x_6);
-lean_closure_set(x_18, 5, x_7);
-lean_closure_set(x_18, 6, x_8);
-lean_closure_set(x_18, 7, x_9);
-x_19 = lean_apply_4(x_10, lean_box(0), lean_box(0), x_17, x_18);
-return x_19;
+x_16 = lean_apply_2(x_2, lean_box(0), x_15);
+x_17 = lean_alloc_closure((void*)(l_Lean_Meta_transform_visit_visitLambda___rarg___lambda__1), 9, 8);
+lean_closure_set(x_17, 0, x_3);
+lean_closure_set(x_17, 1, x_2);
+lean_closure_set(x_17, 2, x_4);
+lean_closure_set(x_17, 3, x_5);
+lean_closure_set(x_17, 4, x_6);
+lean_closure_set(x_17, 5, x_7);
+lean_closure_set(x_17, 6, x_8);
+lean_closure_set(x_17, 7, x_9);
+x_18 = lean_apply_4(x_10, lean_box(0), lean_box(0), x_16, x_17);
+return x_18;
 }
 }
 LEAN_EXPORT lean_object* l_Lean_Meta_transform_visit_visitLambda___rarg___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
@@ -5196,29 +5195,28 @@ return x_2;
 LEAN_EXPORT lean_object* l_Lean_Meta_transform_visit_visitForall___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, 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; uint8_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
 x_12 = 0;
-x_13 = 1;
+x_13 = lean_box(x_12);
 x_14 = lean_box(x_12);
-x_15 = lean_box(x_13);
-x_16 = lean_alloc_closure((void*)(l_Lean_Meta_mkForallFVars___boxed), 9, 4);
-lean_closure_set(x_16, 0, x_1);
-lean_closure_set(x_16, 1, x_11);
-lean_closure_set(x_16, 2, x_14);
-lean_closure_set(x_16, 3, x_15);
+x_15 = lean_alloc_closure((void*)(l_Lean_Meta_mkForallFVars___boxed), 9, 4);
+lean_closure_set(x_15, 0, x_1);
+lean_closure_set(x_15, 1, x_11);
+lean_closure_set(x_15, 2, x_13);
+lean_closure_set(x_15, 3, x_14);
 lean_inc(x_2);
-x_17 = lean_apply_2(x_2, lean_box(0), x_16);
-x_18 = lean_alloc_closure((void*)(l_Lean_Meta_transform_visit_visitLambda___rarg___lambda__1), 9, 8);
-lean_closure_set(x_18, 0, x_3);
-lean_closure_set(x_18, 1, x_2);
-lean_closure_set(x_18, 2, x_4);
-lean_closure_set(x_18, 3, x_5);
-lean_closure_set(x_18, 4, x_6);
-lean_closure_set(x_18, 5, x_7);
-lean_closure_set(x_18, 6, x_8);
-lean_closure_set(x_18, 7, x_9);
-x_19 = lean_apply_4(x_10, lean_box(0), lean_box(0), x_17, x_18);
-return x_19;
+x_16 = lean_apply_2(x_2, lean_box(0), x_15);
+x_17 = lean_alloc_closure((void*)(l_Lean_Meta_transform_visit_visitLambda___rarg___lambda__1), 9, 8);
+lean_closure_set(x_17, 0, x_3);
+lean_closure_set(x_17, 1, x_2);
+lean_closure_set(x_17, 2, x_4);
+lean_closure_set(x_17, 3, x_5);
+lean_closure_set(x_17, 4, x_6);
+lean_closure_set(x_17, 5, x_7);
+lean_closure_set(x_17, 6, x_8);
+lean_closure_set(x_17, 7, x_9);
+x_18 = lean_apply_4(x_10, lean_box(0), lean_box(0), x_16, x_17);
+return x_18;
 }
 }
 LEAN_EXPORT lean_object* l_Lean_Meta_transform_visit_visitForall___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
@@ -5384,7 +5382,7 @@ LEAN_EXPORT lean_object* l_Lean_Meta_transform_visit_visitLet___rarg___lambda__1
 _start:
 {
 uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-x_12 = 1;
+x_12 = 0;
 x_13 = lean_box(x_12);
 x_14 = lean_alloc_closure((void*)(l_Lean_Meta_mkLetFVars___boxed), 8, 3);
 lean_closure_set(x_14, 0, x_1);

stage0/stdlib/Lean/Meta/WHNF.c

@@ -350,7 +350,7 @@ uint8_t l_Lean_Expr_hasMVar(lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_mkNullaryCtor___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBNode_isRed___rarg(lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_reduceRec(lean_object*);
-lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_betaRev(lean_object*, lean_object*, uint8_t);
 static lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_canUnfoldAtMatcher___closed__34;
 LEAN_EXPORT lean_object* l_Lean_getProjectionFnInfo_x3f___at_Lean_Meta_unfoldProjInst_x3f___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_deltaDefinition___at_Lean_Meta_unfoldDefinition_x3f___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -5548,13 +5548,13 @@ return x_12;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; 
 lean_dec(x_4);
 x_13 = lean_instantiate_value_lparams(x_1, x_2);
-x_14 = l_Lean_Expr_betaRev(x_13, x_3);
-lean_dec(x_13);
-x_15 = lean_apply_1(x_5, x_14);
-return x_15;
+x_14 = 0;
+x_15 = l_Lean_Expr_betaRev(x_13, x_3, x_14);
+x_16 = lean_apply_1(x_5, x_15);
+return x_16;
 }
 }
 }
@@ -9659,16 +9659,16 @@ return x_15;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; 
 lean_dec(x_1);
 x_16 = lean_instantiate_value_lparams(x_2, x_3);
 lean_dec(x_3);
 lean_dec(x_2);
-x_17 = l_Lean_Expr_betaRev(x_16, x_4);
+x_17 = 0;
+x_18 = l_Lean_Expr_betaRev(x_16, x_4, x_17);
 lean_dec(x_4);
-lean_dec(x_16);
-x_18 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3(x_17, x_5, x_6, x_7, x_8, x_9);
-return x_18;
+x_19 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3(x_18, x_5, x_6, x_7, x_8, x_9);
+return x_19;
 }
 }
 }
@@ -12625,154 +12625,154 @@ return x_91;
 }
 else
 {
-lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; 
+lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; uint8_t x_101; lean_object* x_102; lean_object* x_103; 
 lean_dec(x_10);
 x_97 = lean_unsigned_to_nat(0u);
 x_98 = l_Lean_Expr_getAppNumArgsAux(x_1, x_97);
 x_99 = lean_mk_empty_array_with_capacity(x_98);
 lean_dec(x_98);
 x_100 = l___private_Lean_Expr_0__Lean_Expr_getAppRevArgsAux(x_1, x_99);
-x_101 = l_Lean_Expr_betaRev(x_12, x_100);
+x_101 = 0;
+x_102 = l_Lean_Expr_betaRev(x_12, x_100, x_101);
 lean_dec(x_100);
-lean_dec(x_12);
-x_102 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3(x_101, x_3, x_4, x_5, x_6, x_13);
-return x_102;
+x_103 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3(x_102, x_3, x_4, x_5, x_6, x_13);
+return x_103;
 }
 }
 else
 {
-uint8_t x_103; 
+uint8_t x_104; 
 lean_dec(x_10);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_103 = !lean_is_exclusive(x_11);
-if (x_103 == 0)
+x_104 = !lean_is_exclusive(x_11);
+if (x_104 == 0)
 {
 return x_11;
 }
 else
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; 
-x_104 = lean_ctor_get(x_11, 0);
-x_105 = lean_ctor_get(x_11, 1);
+lean_object* x_105; lean_object* x_106; lean_object* x_107; 
+x_105 = lean_ctor_get(x_11, 0);
+x_106 = lean_ctor_get(x_11, 1);
+lean_inc(x_106);
 lean_inc(x_105);
-lean_inc(x_104);
 lean_dec(x_11);
-x_106 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_106, 0, x_104);
-lean_ctor_set(x_106, 1, x_105);
-return x_106;
+x_107 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_107, 0, x_105);
+lean_ctor_set(x_107, 1, x_106);
+return x_107;
 }
 }
 }
 case 8:
 {
-lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; 
-x_107 = lean_ctor_get(x_1, 2);
-lean_inc(x_107);
-x_108 = lean_ctor_get(x_1, 3);
+lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; 
+x_108 = lean_ctor_get(x_1, 2);
 lean_inc(x_108);
+x_109 = lean_ctor_get(x_1, 3);
+lean_inc(x_109);
 lean_dec(x_1);
-x_109 = lean_expr_instantiate1(x_108, x_107);
-lean_dec(x_107);
+x_110 = lean_expr_instantiate1(x_109, x_108);
 lean_dec(x_108);
-x_110 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3(x_109, x_3, x_4, x_5, x_6, x_7);
-return x_110;
+lean_dec(x_109);
+x_111 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3(x_110, x_3, x_4, x_5, x_6, x_7);
+return x_111;
 }
 case 11:
 {
-lean_object* x_111; 
+lean_object* x_112; 
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_1);
-x_111 = l_Lean_Meta_reduceProj_x3f(x_1, x_3, x_4, x_5, x_6, x_7);
-if (lean_obj_tag(x_111) == 0)
-{
-lean_object* x_112; 
-x_112 = lean_ctor_get(x_111, 0);
-lean_inc(x_112);
+x_112 = l_Lean_Meta_reduceProj_x3f(x_1, x_3, x_4, x_5, x_6, x_7);
 if (lean_obj_tag(x_112) == 0)
 {
-uint8_t x_113; 
+lean_object* x_113; 
+x_113 = lean_ctor_get(x_112, 0);
+lean_inc(x_113);
+if (lean_obj_tag(x_113) == 0)
+{
+uint8_t x_114; 
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_113 = !lean_is_exclusive(x_111);
-if (x_113 == 0)
+x_114 = !lean_is_exclusive(x_112);
+if (x_114 == 0)
 {
-lean_object* x_114; 
-x_114 = lean_ctor_get(x_111, 0);
-lean_dec(x_114);
-lean_ctor_set(x_111, 0, x_1);
-return x_111;
+lean_object* x_115; 
+x_115 = lean_ctor_get(x_112, 0);
+lean_dec(x_115);
+lean_ctor_set(x_112, 0, x_1);
+return x_112;
 }
 else
 {
-lean_object* x_115; lean_object* x_116; 
-x_115 = lean_ctor_get(x_111, 1);
-lean_inc(x_115);
-lean_dec(x_111);
-x_116 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_116, 0, x_1);
-lean_ctor_set(x_116, 1, x_115);
-return x_116;
+lean_object* x_116; lean_object* x_117; 
+x_116 = lean_ctor_get(x_112, 1);
+lean_inc(x_116);
+lean_dec(x_112);
+x_117 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_117, 0, x_1);
+lean_ctor_set(x_117, 1, x_116);
+return x_117;
 }
 }
 else
 {
-lean_object* x_117; lean_object* x_118; lean_object* x_119; 
+lean_object* x_118; lean_object* x_119; lean_object* x_120; 
 lean_dec(x_1);
-x_117 = lean_ctor_get(x_111, 1);
-lean_inc(x_117);
-lean_dec(x_111);
-x_118 = lean_ctor_get(x_112, 0);
+x_118 = lean_ctor_get(x_112, 1);
 lean_inc(x_118);
 lean_dec(x_112);
-x_119 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3(x_118, x_3, x_4, x_5, x_6, x_117);
-return x_119;
+x_119 = lean_ctor_get(x_113, 0);
+lean_inc(x_119);
+lean_dec(x_113);
+x_120 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3(x_119, x_3, x_4, x_5, x_6, x_118);
+return x_120;
 }
 }
 else
 {
-uint8_t x_120; 
+uint8_t x_121; 
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_1);
-x_120 = !lean_is_exclusive(x_111);
-if (x_120 == 0)
+x_121 = !lean_is_exclusive(x_112);
+if (x_121 == 0)
 {
-return x_111;
+return x_112;
 }
 else
 {
-lean_object* x_121; lean_object* x_122; lean_object* x_123; 
-x_121 = lean_ctor_get(x_111, 0);
-x_122 = lean_ctor_get(x_111, 1);
+lean_object* x_122; lean_object* x_123; lean_object* x_124; 
+x_122 = lean_ctor_get(x_112, 0);
+x_123 = lean_ctor_get(x_112, 1);
+lean_inc(x_123);
 lean_inc(x_122);
-lean_inc(x_121);
-lean_dec(x_111);
-x_123 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_123, 0, x_121);
-lean_ctor_set(x_123, 1, x_122);
-return x_123;
+lean_dec(x_112);
+x_124 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_124, 0, x_122);
+lean_ctor_set(x_124, 1, x_123);
+return x_124;
 }
 }
 }
 default: 
 {
-lean_object* x_124; lean_object* x_125; 
+lean_object* x_125; lean_object* x_126; 
 lean_dec(x_1);
-x_124 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3___lambda__3___closed__2;
-x_125 = l_panic___at_Lean_Meta_whnfCore___spec__1(x_124, x_3, x_4, x_5, x_6, x_7);
-return x_125;
+x_125 = l_Lean_Meta_whnfEasyCases___at_Lean_Meta_whnfCore___spec__3___lambda__3___closed__2;
+x_126 = l_panic___at_Lean_Meta_whnfCore___spec__1(x_125, x_3, x_4, x_5, x_6, x_7);
+return x_126;
 }
 }
 }
@@ -16306,16 +16306,16 @@ return x_15;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
 x_16 = lean_instantiate_value_lparams(x_1, x_2);
-x_17 = l_Lean_Expr_betaRev(x_16, x_3);
-lean_dec(x_16);
-x_18 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_18, 0, x_17);
-x_19 = lean_alloc_ctor(0, 2, 0);
+x_17 = 0;
+x_18 = l_Lean_Expr_betaRev(x_16, x_3, x_17);
+x_19 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_19, 0, x_18);
-lean_ctor_set(x_19, 1, x_8);
-return x_19;
+x_20 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_8);
+return x_20;
 }
 }
 }
@@ -16346,12 +16346,12 @@ return x_15;
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; 
 x_16 = lean_instantiate_value_lparams(x_1, x_2);
-x_17 = l_Lean_Expr_betaRev(x_16, x_3);
-lean_dec(x_16);
-x_18 = l_Lean_Meta_smartUnfoldingReduce_x3f_go(x_17, x_4, x_5, x_6, x_7, x_8);
-return x_18;
+x_17 = 0;
+x_18 = l_Lean_Expr_betaRev(x_16, x_3, x_17);
+x_19 = l_Lean_Meta_smartUnfoldingReduce_x3f_go(x_18, x_4, x_5, x_6, x_7, x_8);
+return x_19;
 }
 }
 }

stage0/stdlib/Lean/PrettyPrinter/Delaborator/Builtins.c

@@ -46,7 +46,6 @@ extern lean_object* l_Lean_PrettyPrinter_Delaborator_delabFailureId;
 LEAN_EXPORT lean_object* l_Lean_PrettyPrinter_Delaborator_delabMData(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getPPLetVarTypes___boxed(lean_object*);
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabDoElems___closed__1;
-lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAuxAux___rarg(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lean_PrettyPrinter_Delaborator_delabForall___spec__2(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabLetFun___lambda__1___closed__10;
 static lean_object* l___regBuiltin_Lean_PrettyPrinter_Delaborator_delabNameMkNum___closed__3;
@@ -804,7 +803,6 @@ lean_object* l_Lean_getPPMatch___boxed(lean_object*);
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabLetE___closed__2;
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabOfScientific___lambda__1___closed__2;
 static lean_object* l_Lean_PrettyPrinter_Delaborator_unexpandStructureInstance___lambda__3___closed__4;
-LEAN_EXPORT lean_object* l_Lean_Meta_forallTelescope___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___spec__6(lean_object*);
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppExplicit___lambda__5___closed__3;
 LEAN_EXPORT lean_object* l_Lean_PrettyPrinter_Delaborator_SubExpr_withAppFn___at_Lean_PrettyPrinter_Delaborator_delabAppExplicit___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_PrettyPrinter_Delaborator_delabOfScientific___lambda__1(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -994,7 +992,6 @@ LEAN_EXPORT lean_object* l_panic___at_Lean_PrettyPrinter_Delaborator_withMDataOp
 LEAN_EXPORT lean_object* l_Lean_Meta_forallBoundedTelescope___at_Lean_PrettyPrinter_Delaborator_getParamKinds_forallTelescopeArgs___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppMatch___lambda__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_isConstructorApp_x3f(lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Meta_forallTelescope___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabForall___lambda__1___closed__2;
 static lean_object* l___regBuiltin_Lean_PrettyPrinter_Delaborator_delabOfScientific___closed__2;
@@ -13191,71 +13188,6 @@ return x_66;
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Meta_forallTelescope___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
-_start:
-{
-lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
-x_10 = lean_alloc_closure((void*)(l_Lean_Meta_forallTelescopeReducing___at_Lean_PrettyPrinter_Delaborator_getParamKinds_forallTelescopeArgs___spec__1___rarg___lambda__1), 10, 3);
-lean_closure_set(x_10, 0, x_2);
-lean_closure_set(x_10, 1, x_3);
-lean_closure_set(x_10, 2, x_4);
-x_11 = lean_box(0);
-x_12 = 0;
-x_13 = l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAuxAux___rarg(x_12, x_11, x_1, x_10, x_5, x_6, x_7, x_8, x_9);
-if (lean_obj_tag(x_13) == 0)
-{
-uint8_t x_14; 
-x_14 = !lean_is_exclusive(x_13);
-if (x_14 == 0)
-{
-return x_13;
-}
-else
-{
-lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-x_15 = lean_ctor_get(x_13, 0);
-x_16 = lean_ctor_get(x_13, 1);
-lean_inc(x_16);
-lean_inc(x_15);
-lean_dec(x_13);
-x_17 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_17, 0, x_15);
-lean_ctor_set(x_17, 1, x_16);
-return x_17;
-}
-}
-else
-{
-uint8_t x_18; 
-x_18 = !lean_is_exclusive(x_13);
-if (x_18 == 0)
-{
-return x_13;
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_19 = lean_ctor_get(x_13, 0);
-x_20 = lean_ctor_get(x_13, 1);
-lean_inc(x_20);
-lean_inc(x_19);
-lean_dec(x_13);
-x_21 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_21, 0, x_19);
-lean_ctor_set(x_21, 1, x_20);
-return x_21;
-}
-}
-}
-}
-LEAN_EXPORT lean_object* l_Lean_Meta_forallTelescope___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___spec__6(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Meta_forallTelescope___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___spec__6___rarg), 9, 0);
-return x_2;
-}
-}
 LEAN_EXPORT lean_object* l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___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) {
 _start:
 {
@@ -13315,7 +13247,7 @@ lean_inc(x_18);
 lean_dec(x_16);
 x_19 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___lambda__1), 10, 1);
 lean_closure_set(x_19, 0, x_1);
-x_20 = l_Lean_Meta_forallTelescope___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___spec__6___rarg(x_17, x_19, x_2, x_3, x_4, x_5, x_6, x_7, x_18);
+x_20 = l_Lean_Meta_forallTelescopeReducing___at_Lean_PrettyPrinter_Delaborator_getParamKinds_forallTelescopeArgs___spec__1___rarg(x_17, x_19, x_2, x_3, x_4, x_5, x_6, x_7, x_18);
 return x_20;
 }
 else
@@ -13386,7 +13318,7 @@ lean_inc(x_35);
 lean_dec(x_33);
 x_36 = lean_alloc_closure((void*)(l___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___lambda__1), 10, 1);
 lean_closure_set(x_36, 0, x_1);
-x_37 = l_Lean_Meta_forallTelescope___at___private_Lean_PrettyPrinter_Delaborator_Builtins_0__Lean_PrettyPrinter_Delaborator_delabPatterns___spec__6___rarg(x_34, x_36, x_31, x_3, x_4, x_5, x_6, x_7, x_35);
+x_37 = l_Lean_Meta_forallTelescopeReducing___at_Lean_PrettyPrinter_Delaborator_getParamKinds_forallTelescopeArgs___spec__1___rarg(x_34, x_36, x_31, x_3, x_4, x_5, x_6, x_7, x_35);
 return x_37;
 }
 else
@@ -17736,7 +17668,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__1;
 x_2 = l_Lean_PrettyPrinter_Delaborator_delabLetFun___lambda__1___closed__1;
-x_3 = lean_unsigned_to_nat(434u);
+x_3 = lean_unsigned_to_nat(435u);
 x_4 = lean_unsigned_to_nat(37u);
 x_5 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -23941,7 +23873,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__1;
 x_2 = l_Lean_PrettyPrinter_Delaborator_delabLetE___closed__1;
-x_3 = lean_unsigned_to_nat(592u);
+x_3 = lean_unsigned_to_nat(593u);
 x_4 = lean_unsigned_to_nat(38u);
 x_5 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -24695,7 +24627,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__1;
 x_2 = l_Lean_PrettyPrinter_Delaborator_delabLit___closed__1;
-x_3 = lean_unsigned_to_nat(605u);
+x_3 = lean_unsigned_to_nat(606u);
 x_4 = lean_unsigned_to_nat(31u);
 x_5 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -26087,7 +26019,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__1;
 x_2 = l_Lean_PrettyPrinter_Delaborator_delabProj___closed__1;
-x_3 = lean_unsigned_to_nat(644u);
+x_3 = lean_unsigned_to_nat(645u);
 x_4 = lean_unsigned_to_nat(38u);
 x_5 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -29694,7 +29626,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__1;
 x_2 = l_Lean_PrettyPrinter_Delaborator_delabDoElems___closed__5;
-x_3 = lean_unsigned_to_nat(738u);
+x_3 = lean_unsigned_to_nat(739u);
 x_4 = lean_unsigned_to_nat(40u);
 x_5 = l_Lean_PrettyPrinter_Delaborator_delabFVar___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Server/FileWorker/WidgetRequests.c

@@ -22,7 +22,6 @@ LEAN_EXPORT lean_object* l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_i
 LEAN_EXPORT lean_object* l_Lean_Widget_Lean_Widget_MsgToInteractive_instRpcEncodingMsgToInteractiveRpcEncodingPacket___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_858____spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Server_FileWorker_WidgetRequests_0__Lean_Widget_fromJsonGetInteractiveDiagnosticsParams____x40_Lean_Server_FileWorker_WidgetRequests___hyg_916_(lean_object*);
-lean_object* l_liftExcept___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8438____spec__29___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 static lean_object* l_Lean_Widget_Lean_Widget_InfoPopup_instFromJsonRpcEncodingPacket___closed__1;
 static lean_object* l___private_Lean_Server_FileWorker_WidgetRequests_0__Lean_Widget_Lean_Widget_InfoPopup_toJsonRpcEncodingPacket____x40_Lean_Server_FileWorker_WidgetRequests___hyg_432____closed__6;
@@ -133,6 +132,7 @@ LEAN_EXPORT lean_object* l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_i
 LEAN_EXPORT lean_object* l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_858____spec__3___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Widget_getInteractiveDiagnostics___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_612____spec__1___lambda__3(lean_object*, lean_object*, uint64_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Server_parseRequestParams___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8441____spec__31(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___lambda__8(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_245____spec__1___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -144,7 +144,6 @@ lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Data_Lsp_Basic_0__L
 LEAN_EXPORT lean_object* l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_858____spec__1___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_245____spec__1___lambda__7(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_getLast_x3f___rarg(lean_object*);
-lean_object* l_Lean_Server_parseRequestParams___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8438____spec__31(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_TaggedText_mapM___at_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___spec__8(lean_object*);
 LEAN_EXPORT lean_object* l_liftExcept___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_1143____spec__3___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_Lean_Widget_InfoPopup_instToJsonRpcEncodingPacket;
@@ -211,7 +210,6 @@ LEAN_EXPORT lean_object* l_Lean_Widget_instInhabitedInfoPopup;
 static lean_object* l_Lean_Widget_getInteractiveDiagnostics___lambda__1___closed__1;
 lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Widget_InteractiveCode_0__Lean_Widget_Lean_Widget_CodeToken_fromJsonRpcEncodingPacket____x40_Lean_Widget_InteractiveCode___hyg_178____spec__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_ExceptT_bindCont___at_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___spec__20(lean_object*);
-lean_object* l_liftExcept___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8438____spec__32___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_getInteractiveDiagnostics___lambda__1___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_Lean_Widget_MsgToInteractive_instRpcEncodingMsgToInteractiveRpcEncodingPacket___lambda__5___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_858____spec__1___lambda__3(lean_object*, uint64_t, lean_object*, lean_object*, lean_object*);
@@ -239,7 +237,6 @@ LEAN_EXPORT lean_object* l_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfo
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___spec__9___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Widget_InteractiveCode_0__Lean_Widget_Lean_Widget_InfoWithCtx_decodeUnsafe____x40_Lean_Widget_InteractiveCode___hyg_5____at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_612____spec__4(size_t, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_instToJsonGetInteractiveDiagnosticsParams;
-lean_object* l_Lean_Server_parseRequestParams___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8438____spec__28(lean_object*);
 extern lean_object* l_Task_Priority_default;
 static lean_object* l_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___lambda__10___closed__1;
 static lean_object* l_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_858____closed__4;
@@ -248,6 +245,7 @@ size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_Widget_msgToInteractive(lean_object*, uint8_t, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Widget_InteractiveCode_0__Lean_Widget_Lean_Widget_InfoWithCtx_decodeUnsafe____x40_Lean_Widget_InteractiveCode___hyg_5____at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_612____spec__4___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___lambda__15(lean_object*, lean_object*, lean_object*, size_t);
+lean_object* l_Lean_Server_parseRequestParams___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8441____spec__28(lean_object*);
 lean_object* l_Lean_Elab_Info_docString_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_245____closed__2;
 LEAN_EXPORT lean_object* l_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___lambda__2(lean_object*);
@@ -347,6 +345,7 @@ static lean_object* l_Lean_Server_WithRpcRef_decodeUnsafeAs___at_Lean_Widget_ini
 LEAN_EXPORT lean_object* l_ExceptT_bindCont___at_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___spec__15___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Widget_TaggedText_0__Lean_Widget_toJsonTaggedText____x40_Lean_Widget_TaggedText___hyg_577____at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_245____spec__16___closed__2;
 static lean_object* l_Lean_Widget_Lean_Widget_InfoPopup_instToJsonRpcEncodingPacket___closed__1;
+lean_object* l_liftExcept___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8441____spec__32___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_find_x3f___at_Lean_Server_FileWorker_instMonadRpcSession___spec__1(lean_object*, size_t);
 LEAN_EXPORT lean_object* l_Lean_Widget_TaggedText_mapM___at_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___spec__3(lean_object*);
 lean_object* lean_io_initializing(lean_object*);
@@ -363,6 +362,7 @@ LEAN_EXPORT lean_object* l_ExceptT_bindCont___at_Lean_Widget_Lean_Widget_InfoPop
 LEAN_EXPORT lean_object* l_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_612____lambda__5(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_245____spec__1___closed__1;
 static lean_object* l_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_245____closed__5;
+lean_object* l_liftExcept___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8441____spec__29___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_TaggedText_mapM___at_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___spec__1___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_RequestM_asTask___rarg(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_TaggedText_mapM___at_Lean_Widget_Lean_Widget_InfoPopup_instRpcEncodingInfoPopupRpcEncodingPacket___spec__16___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -8127,8 +8127,8 @@ lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean
 x_10 = lean_ctor_get(x_7, 0);
 lean_inc(x_10);
 lean_dec(x_7);
-x_11 = l_Lean_Server_parseRequestParams___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8438____spec__28(x_3);
-x_12 = lean_alloc_closure((void*)(l_liftExcept___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8438____spec__29___boxed), 3, 1);
+x_11 = l_Lean_Server_parseRequestParams___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8441____spec__28(x_3);
+x_12 = lean_alloc_closure((void*)(l_liftExcept___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8441____spec__29___boxed), 3, 1);
 lean_closure_set(x_12, 0, x_11);
 lean_inc(x_10);
 x_13 = lean_alloc_closure((void*)(l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_858____spec__1___lambda__1___boxed), 4, 1);
@@ -8482,8 +8482,8 @@ lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean
 x_10 = lean_ctor_get(x_7, 0);
 lean_inc(x_10);
 lean_dec(x_7);
-x_11 = l_Lean_Server_parseRequestParams___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8438____spec__31(x_3);
-x_12 = lean_alloc_closure((void*)(l_liftExcept___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8438____spec__32___boxed), 3, 1);
+x_11 = l_Lean_Server_parseRequestParams___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8441____spec__31(x_3);
+x_12 = lean_alloc_closure((void*)(l_liftExcept___at_Lean_Server_FileWorker_initFn____x40_Lean_Server_FileWorker_RequestHandling___hyg_8441____spec__32___boxed), 3, 1);
 lean_closure_set(x_12, 0, x_11);
 lean_inc(x_10);
 x_13 = lean_alloc_closure((void*)(l_Lean_Server_registerRpcCallHandler___at_Lean_Widget_initFn____x40_Lean_Server_FileWorker_WidgetRequests___hyg_858____spec__1___lambda__1___boxed), 4, 1);